tools/testing/selftests/bpf/test_sock_fields.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2019 Facebook */
   3
   4 #include <sys/socket.h>
   5 #include <sys/epoll.h>
   6 #include <netinet/in.h>
   7 #include <arpa/inet.h>
   8 #include <unistd.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <errno.h>
  12
  13 #include <bpf/bpf.h>
  14 #include <bpf/libbpf.h>
  15
  16 #include "cgroup_helpers.h"
  17 #include "bpf_rlimit.h"
  18
  19 enum bpf_array_idx {
  20         SRV_IDX,
  21         CLI_IDX,
  22         __NR_BPF_ARRAY_IDX,
  23 };
  24
  25 #define CHECK(condition, tag, format...) ({                             \
  26         int __ret = !!(condition);                                      \
  27         if (__ret) {                                                    \
  28                 printf("%s(%d):FAIL:%s ", __func__, __LINE__, tag);     \
  29                 printf(format);                                         \
  30                 printf("\n");                                           \
  31                 exit(-1);                                               \
  32         }                                                               \
  33 })
  34
  35 #define TEST_CGROUP "/test-bpf-sock-fields"
  36 #define DATA "Hello BPF!"
  37 #define DATA_LEN sizeof(DATA)
  38
  39 static struct sockaddr_in6 srv_sa6, cli_sa6;
  40 static int linum_map_fd;
  41 static int addr_map_fd;
  42 static int tp_map_fd;
  43 static int sk_map_fd;
  44 static __u32 srv_idx = SRV_IDX;
  45 static __u32 cli_idx = CLI_IDX;
  46
  47 static void init_loopback6(struct sockaddr_in6 *sa6)
  48 {
  49         memset(sa6, 0, sizeof(*sa6));
  50         sa6->sin6_family = AF_INET6;
  51         sa6->sin6_addr = in6addr_loopback;
  52 }
  53
  54 static void print_sk(const struct bpf_sock *sk)
  55 {
  56         char src_ip4[24], dst_ip4[24];
  57         char src_ip6[64], dst_ip6[64];
  58
  59         inet_ntop(AF_INET, &sk->src_ip4, src_ip4, sizeof(src_ip4));
  60         inet_ntop(AF_INET6, &sk->src_ip6, src_ip6, sizeof(src_ip6));
  61         inet_ntop(AF_INET, &sk->dst_ip4, dst_ip4, sizeof(dst_ip4));
  62         inet_ntop(AF_INET6, &sk->dst_ip6, dst_ip6, sizeof(dst_ip6));
  63
  64         printf("state:%u bound_dev_if:%u family:%u type:%u protocol:%u mark:%u priority:%u "
  65                "src_ip4:%x(%s) src_ip6:%x:%x:%x:%x(%s) src_port:%u "
  66                "dst_ip4:%x(%s) dst_ip6:%x:%x:%x:%x(%s) dst_port:%u\n",
  67                sk->state, sk->bound_dev_if, sk->family, sk->type, sk->protocol,
  68                sk->mark, sk->priority,
  69                sk->src_ip4, src_ip4,
  70                sk->src_ip6[0], sk->src_ip6[1], sk->src_ip6[2], sk->src_ip6[3],
  71                src_ip6, sk->src_port,
  72                sk->dst_ip4, dst_ip4,
  73                sk->dst_ip6[0], sk->dst_ip6[1], sk->dst_ip6[2], sk->dst_ip6[3],
  74                dst_ip6, ntohs(sk->dst_port));
  75 }
  76
  77 static void print_tp(const struct bpf_tcp_sock *tp)
  78 {
  79         printf("snd_cwnd:%u srtt_us:%u rtt_min:%u snd_ssthresh:%u rcv_nxt:%u "
  80                "snd_nxt:%u snd:una:%u mss_cache:%u ecn_flags:%u "
  81                "rate_delivered:%u rate_interval_us:%u packets_out:%u "
  82                "retrans_out:%u total_retrans:%u segs_in:%u data_segs_in:%u "
  83                "segs_out:%u data_segs_out:%u lost_out:%u sacked_out:%u "
  84                "bytes_received:%llu bytes_acked:%llu\n",
  85                tp->snd_cwnd, tp->srtt_us, tp->rtt_min, tp->snd_ssthresh,
  86                tp->rcv_nxt, tp->snd_nxt, tp->snd_una, tp->mss_cache,
  87                tp->ecn_flags, tp->rate_delivered, tp->rate_interval_us,
  88                tp->packets_out, tp->retrans_out, tp->total_retrans,
  89                tp->segs_in, tp->data_segs_in, tp->segs_out,
  90                tp->data_segs_out, tp->lost_out, tp->sacked_out,
  91                tp->bytes_received, tp->bytes_acked);
  92 }
  93
  94 static void check_result(void)
  95 {
  96         struct bpf_tcp_sock srv_tp, cli_tp;
  97         struct bpf_sock srv_sk, cli_sk;
  98         __u32 linum, idx0 = 0;
  99         int err;
 100
 101         err = bpf_map_lookup_elem(linum_map_fd, &idx0, &linum);
 102         CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
 103               "err:%d errno:%d", err, errno);
 104
 105         err = bpf_map_lookup_elem(sk_map_fd, &srv_idx, &srv_sk);
 106         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &srv_idx)",
 107               "err:%d errno:%d", err, errno);
 108         err = bpf_map_lookup_elem(tp_map_fd, &srv_idx, &srv_tp);
 109         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &srv_idx)",
 110               "err:%d errno:%d", err, errno);
 111
 112         err = bpf_map_lookup_elem(sk_map_fd, &cli_idx, &cli_sk);
 113         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &cli_idx)",
 114               "err:%d errno:%d", err, errno);
 115         err = bpf_map_lookup_elem(tp_map_fd, &cli_idx, &cli_tp);
 116         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &cli_idx)",
 117               "err:%d errno:%d", err, errno);
 118
 119         printf("srv_sk: ");
 120         print_sk(&srv_sk);
 121         printf("\n");
 122
 123         printf("cli_sk: ");
 124         print_sk(&cli_sk);
 125         printf("\n");
 126
 127         printf("srv_tp: ");
 128         print_tp(&srv_tp);
 129         printf("\n");
 130
 131         printf("cli_tp: ");
 132         print_tp(&cli_tp);
 133         printf("\n");
 134
 135         CHECK(srv_sk.state == 10 ||
 136               !srv_sk.state ||
 137               srv_sk.family != AF_INET6 ||
 138               srv_sk.protocol != IPPROTO_TCP ||
 139               memcmp(srv_sk.src_ip6, &in6addr_loopback,
 140                      sizeof(srv_sk.src_ip6)) ||
 141               memcmp(srv_sk.dst_ip6, &in6addr_loopback,
 142                      sizeof(srv_sk.dst_ip6)) ||
 143               srv_sk.src_port != ntohs(srv_sa6.sin6_port) ||
 144               srv_sk.dst_port != cli_sa6.sin6_port,
 145               "Unexpected srv_sk", "Check srv_sk output. linum:%u", linum);
 146
 147         CHECK(cli_sk.state == 10 ||
 148               !cli_sk.state ||
 149               cli_sk.family != AF_INET6 ||
 150               cli_sk.protocol != IPPROTO_TCP ||
 151               memcmp(cli_sk.src_ip6, &in6addr_loopback,
 152                      sizeof(cli_sk.src_ip6)) ||
 153               memcmp(cli_sk.dst_ip6, &in6addr_loopback,
 154                      sizeof(cli_sk.dst_ip6)) ||
 155               cli_sk.src_port != ntohs(cli_sa6.sin6_port) ||
 156               cli_sk.dst_port != srv_sa6.sin6_port,
 157               "Unexpected cli_sk", "Check cli_sk output. linum:%u", linum);
 158
 159         CHECK(srv_tp.data_segs_out != 1 ||
 160               srv_tp.data_segs_in ||
 161               srv_tp.snd_cwnd != 10 ||
 162               srv_tp.total_retrans ||
 163               srv_tp.bytes_acked != DATA_LEN,
 164               "Unexpected srv_tp", "Check srv_tp output. linum:%u", linum);
 165
 166         CHECK(cli_tp.data_segs_out ||
 167               cli_tp.data_segs_in != 1 ||
 168               cli_tp.snd_cwnd != 10 ||
 169               cli_tp.total_retrans ||
 170               cli_tp.bytes_received != DATA_LEN,
 171               "Unexpected cli_tp", "Check cli_tp output. linum:%u", linum);
 172 }
 173
 174 static void test(void)
 175 {
 176         int listen_fd, cli_fd, accept_fd, epfd, err;
 177         struct epoll_event ev;
 178         socklen_t addrlen;
 179
 180         addrlen = sizeof(struct sockaddr_in6);
 181         ev.events = EPOLLIN;
 182
 183         epfd = epoll_create(1);
 184         CHECK(epfd == -1, "epoll_create()", "epfd:%d errno:%d", epfd, errno);
 185
 186         /* Prepare listen_fd */
 187         listen_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 188         CHECK(listen_fd == -1, "socket()", "listen_fd:%d errno:%d",
 189               listen_fd, errno);
 190
 191         init_loopback6(&srv_sa6);
 192         err = bind(listen_fd, (struct sockaddr *)&srv_sa6, sizeof(srv_sa6));
 193         CHECK(err, "bind(listen_fd)", "err:%d errno:%d", err, errno);
 194
 195         err = getsockname(listen_fd, (struct sockaddr *)&srv_sa6, &addrlen);
 196         CHECK(err, "getsockname(listen_fd)", "err:%d errno:%d", err, errno);
 197
 198         err = listen(listen_fd, 1);
 199         CHECK(err, "listen(listen_fd)", "err:%d errno:%d", err, errno);
 200
 201         /* Prepare cli_fd */
 202         cli_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 203         CHECK(cli_fd == -1, "socket()", "cli_fd:%d errno:%d", cli_fd, errno);
 204
 205         init_loopback6(&cli_sa6);
 206         err = bind(cli_fd, (struct sockaddr *)&cli_sa6, sizeof(cli_sa6));
 207         CHECK(err, "bind(cli_fd)", "err:%d errno:%d", err, errno);
 208
 209         err = getsockname(cli_fd, (struct sockaddr *)&cli_sa6, &addrlen);
 210         CHECK(err, "getsockname(cli_fd)", "err:%d errno:%d",
 211               err, errno);
 212
 213         /* Update addr_map with srv_sa6 and cli_sa6 */
 214         err = bpf_map_update_elem(addr_map_fd, &srv_idx, &srv_sa6, 0);
 215         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 216
 217         err = bpf_map_update_elem(addr_map_fd, &cli_idx, &cli_sa6, 0);
 218         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 219
 220         /* Connect from cli_sa6 to srv_sa6 */
 221         err = connect(cli_fd, (struct sockaddr *)&srv_sa6, addrlen);
 222         printf("srv_sa6.sin6_port:%u cli_sa6.sin6_port:%u\n\n",
 223                ntohs(srv_sa6.sin6_port), ntohs(cli_sa6.sin6_port));
 224         CHECK(err && errno != EINPROGRESS,
 225               "connect(cli_fd)", "err:%d errno:%d", err, errno);
 226
 227         ev.data.fd = listen_fd;
 228         err = epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
 229         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, listen_fd)", "err:%d errno:%d",
 230               err, errno);
 231
 232         /* Accept the connection */
 233         /* Have some timeout in accept(listen_fd). Just in case. */
 234         err = epoll_wait(epfd, &ev, 1, 1000);
 235         CHECK(err != 1 || ev.data.fd != listen_fd,
 236               "epoll_wait(listen_fd)",
 237               "err:%d errno:%d ev.data.fd:%d listen_fd:%d",
 238               err, errno, ev.data.fd, listen_fd);
 239
 240         accept_fd = accept(listen_fd, NULL, NULL);
 241         CHECK(accept_fd == -1, "accept(listen_fd)", "accept_fd:%d errno:%d",
 242               accept_fd, errno);
 243         close(listen_fd);
 244
 245         /* Send some data from accept_fd to cli_fd */
 246         err = send(accept_fd, DATA, DATA_LEN, 0);
 247         CHECK(err != DATA_LEN, "send(accept_fd)", "err:%d errno:%d",
 248               err, errno);
 249
 250         /* Have some timeout in recv(cli_fd). Just in case. */
 251         ev.data.fd = cli_fd;
 252         err = epoll_ctl(epfd, EPOLL_CTL_ADD, cli_fd, &ev);
 253         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, cli_fd)", "err:%d errno:%d",
 254               err, errno);
 255
 256         err = epoll_wait(epfd, &ev, 1, 1000);
 257         CHECK(err != 1 || ev.data.fd != cli_fd,
 258               "epoll_wait(cli_fd)", "err:%d errno:%d ev.data.fd:%d cli_fd:%d",
 259               err, errno, ev.data.fd, cli_fd);
 260
 261         err = recv(cli_fd, NULL, 0, MSG_TRUNC);
 262         CHECK(err, "recv(cli_fd)", "err:%d errno:%d", err, errno);
 263
 264         close(epfd);
 265         close(accept_fd);
 266         close(cli_fd);
 267
 268         check_result();
 269 }
 270
 271 int main(int argc, char **argv)
 272 {
 273         struct bpf_prog_load_attr attr = {
 274                 .file = "test_sock_fields_kern.o",
 275                 .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
 276                 .expected_attach_type = BPF_CGROUP_INET_EGRESS,
 277         };
 278         int cgroup_fd, prog_fd, err;
 279         struct bpf_object *obj;
 280         struct bpf_map *map;
 281
 282         err = setup_cgroup_environment();
 283         CHECK(err, "setup_cgroup_environment()", "err:%d errno:%d",
 284               err, errno);
 285
 286         atexit(cleanup_cgroup_environment);
 287
 288         /* Create a cgroup, get fd, and join it */
 289         cgroup_fd = create_and_get_cgroup(TEST_CGROUP);
 290         CHECK(cgroup_fd == -1, "create_and_get_cgroup()",
 291               "cgroup_fd:%d errno:%d", cgroup_fd, errno);
 292
 293         err = join_cgroup(TEST_CGROUP);
 294         CHECK(err, "join_cgroup", "err:%d errno:%d", err, errno);
 295
 296         err = bpf_prog_load_xattr(&attr, &obj, &prog_fd);
 297         CHECK(err, "bpf_prog_load_xattr()", "err:%d", err);
 298
 299         err = bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0);
 300         CHECK(err == -1, "bpf_prog_attach(CPF_CGROUP_INET_EGRESS)",
 301               "err:%d errno%d", err, errno);
 302         close(cgroup_fd);
 303
 304         map = bpf_object__find_map_by_name(obj, "addr_map");
 305         CHECK(!map, "cannot find addr_map", "(null)");
 306         addr_map_fd = bpf_map__fd(map);
 307
 308         map = bpf_object__find_map_by_name(obj, "sock_result_map");
 309         CHECK(!map, "cannot find sock_result_map", "(null)");
 310         sk_map_fd = bpf_map__fd(map);
 311
 312         map = bpf_object__find_map_by_name(obj, "tcp_sock_result_map");
 313         CHECK(!map, "cannot find tcp_sock_result_map", "(null)");
 314         tp_map_fd = bpf_map__fd(map);
 315
 316         map = bpf_object__find_map_by_name(obj, "linum_map");
 317         CHECK(!map, "cannot find linum_map", "(null)");
 318         linum_map_fd = bpf_map__fd(map);
 319
 320         test();
 321
 322         bpf_object__close(obj);
 323         cleanup_cgroup_environment();
 324
 325         printf("PASS\n");
 326
 327         return 0;
 328 }