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_addr_array_idx {
  20         ADDR_SRV_IDX,
  21         ADDR_CLI_IDX,
  22         __NR_BPF_ADDR_ARRAY_IDX,
  23 };
  24
  25 enum bpf_result_array_idx {
  26         EGRESS_SRV_IDX,
  27         EGRESS_CLI_IDX,
  28         INGRESS_LISTEN_IDX,
  29         __NR_BPF_RESULT_ARRAY_IDX,
  30 };
  31
  32 enum bpf_linum_array_idx {
  33         EGRESS_LINUM_IDX,
  34         INGRESS_LINUM_IDX,
  35         __NR_BPF_LINUM_ARRAY_IDX,
  36 };
  37
  38 #define CHECK(condition, tag, format...) ({                             \
  39         int __ret = !!(condition);                                      \
  40         if (__ret) {                                                    \
  41                 printf("%s(%d):FAIL:%s ", __func__, __LINE__, tag);     \
  42                 printf(format);                                         \
  43                 printf("\n");                                           \
  44                 exit(-1);                                               \
  45         }                                                               \
  46 })
  47
  48 #define TEST_CGROUP "/test-bpf-sock-fields"
  49 #define DATA "Hello BPF!"
  50 #define DATA_LEN sizeof(DATA)
  51
  52 static struct sockaddr_in6 srv_sa6, cli_sa6;
  53 static int linum_map_fd;
  54 static int addr_map_fd;
  55 static int tp_map_fd;
  56 static int sk_map_fd;
  57
  58 static __u32 addr_srv_idx = ADDR_SRV_IDX;
  59 static __u32 addr_cli_idx = ADDR_CLI_IDX;
  60
  61 static __u32 egress_srv_idx = EGRESS_SRV_IDX;
  62 static __u32 egress_cli_idx = EGRESS_CLI_IDX;
  63 static __u32 ingress_listen_idx = INGRESS_LISTEN_IDX;
  64
  65 static __u32 egress_linum_idx = EGRESS_LINUM_IDX;
  66 static __u32 ingress_linum_idx = INGRESS_LINUM_IDX;
  67
  68 static void init_loopback6(struct sockaddr_in6 *sa6)
  69 {
  70         memset(sa6, 0, sizeof(*sa6));
  71         sa6->sin6_family = AF_INET6;
  72         sa6->sin6_addr = in6addr_loopback;
  73 }
  74
  75 static void print_sk(const struct bpf_sock *sk)
  76 {
  77         char src_ip4[24], dst_ip4[24];
  78         char src_ip6[64], dst_ip6[64];
  79
  80         inet_ntop(AF_INET, &sk->src_ip4, src_ip4, sizeof(src_ip4));
  81         inet_ntop(AF_INET6, &sk->src_ip6, src_ip6, sizeof(src_ip6));
  82         inet_ntop(AF_INET, &sk->dst_ip4, dst_ip4, sizeof(dst_ip4));
  83         inet_ntop(AF_INET6, &sk->dst_ip6, dst_ip6, sizeof(dst_ip6));
  84
  85         printf("state:%u bound_dev_if:%u family:%u type:%u protocol:%u mark:%u priority:%u "
  86                "src_ip4:%x(%s) src_ip6:%x:%x:%x:%x(%s) src_port:%u "
  87                "dst_ip4:%x(%s) dst_ip6:%x:%x:%x:%x(%s) dst_port:%u\n",
  88                sk->state, sk->bound_dev_if, sk->family, sk->type, sk->protocol,
  89                sk->mark, sk->priority,
  90                sk->src_ip4, src_ip4,
  91                sk->src_ip6[0], sk->src_ip6[1], sk->src_ip6[2], sk->src_ip6[3],
  92                src_ip6, sk->src_port,
  93                sk->dst_ip4, dst_ip4,
  94                sk->dst_ip6[0], sk->dst_ip6[1], sk->dst_ip6[2], sk->dst_ip6[3],
  95                dst_ip6, ntohs(sk->dst_port));
  96 }
  97
  98 static void print_tp(const struct bpf_tcp_sock *tp)
  99 {
 100         printf("snd_cwnd:%u srtt_us:%u rtt_min:%u snd_ssthresh:%u rcv_nxt:%u "
 101                "snd_nxt:%u snd:una:%u mss_cache:%u ecn_flags:%u "
 102                "rate_delivered:%u rate_interval_us:%u packets_out:%u "
 103                "retrans_out:%u total_retrans:%u segs_in:%u data_segs_in:%u "
 104                "segs_out:%u data_segs_out:%u lost_out:%u sacked_out:%u "
 105                "bytes_received:%llu bytes_acked:%llu\n",
 106                tp->snd_cwnd, tp->srtt_us, tp->rtt_min, tp->snd_ssthresh,
 107                tp->rcv_nxt, tp->snd_nxt, tp->snd_una, tp->mss_cache,
 108                tp->ecn_flags, tp->rate_delivered, tp->rate_interval_us,
 109                tp->packets_out, tp->retrans_out, tp->total_retrans,
 110                tp->segs_in, tp->data_segs_in, tp->segs_out,
 111                tp->data_segs_out, tp->lost_out, tp->sacked_out,
 112                tp->bytes_received, tp->bytes_acked);
 113 }
 114
 115 static void check_result(void)
 116 {
 117         struct bpf_tcp_sock srv_tp, cli_tp, listen_tp;
 118         struct bpf_sock srv_sk, cli_sk, listen_sk;
 119         __u32 ingress_linum, egress_linum;
 120         int err;
 121
 122         err = bpf_map_lookup_elem(linum_map_fd, &egress_linum_idx,
 123                                   &egress_linum);
 124         CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
 125               "err:%d errno:%d", err, errno);
 126
 127         err = bpf_map_lookup_elem(linum_map_fd, &ingress_linum_idx,
 128                                   &ingress_linum);
 129         CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
 130               "err:%d errno:%d", err, errno);
 131
 132         err = bpf_map_lookup_elem(sk_map_fd, &egress_srv_idx, &srv_sk);
 133         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &egress_srv_idx)",
 134               "err:%d errno:%d", err, errno);
 135         err = bpf_map_lookup_elem(tp_map_fd, &egress_srv_idx, &srv_tp);
 136         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &egress_srv_idx)",
 137               "err:%d errno:%d", err, errno);
 138
 139         err = bpf_map_lookup_elem(sk_map_fd, &egress_cli_idx, &cli_sk);
 140         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &egress_cli_idx)",
 141               "err:%d errno:%d", err, errno);
 142         err = bpf_map_lookup_elem(tp_map_fd, &egress_cli_idx, &cli_tp);
 143         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &egress_cli_idx)",
 144               "err:%d errno:%d", err, errno);
 145
 146         err = bpf_map_lookup_elem(sk_map_fd, &ingress_listen_idx, &listen_sk);
 147         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &ingress_listen_idx)",
 148               "err:%d errno:%d", err, errno);
 149         err = bpf_map_lookup_elem(tp_map_fd, &ingress_listen_idx, &listen_tp);
 150         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &ingress_listen_idx)",
 151               "err:%d errno:%d", err, errno);
 152
 153         printf("listen_sk: ");
 154         print_sk(&listen_sk);
 155         printf("\n");
 156
 157         printf("srv_sk: ");
 158         print_sk(&srv_sk);
 159         printf("\n");
 160
 161         printf("cli_sk: ");
 162         print_sk(&cli_sk);
 163         printf("\n");
 164
 165         printf("listen_tp: ");
 166         print_tp(&listen_tp);
 167         printf("\n");
 168
 169         printf("srv_tp: ");
 170         print_tp(&srv_tp);
 171         printf("\n");
 172
 173         printf("cli_tp: ");
 174         print_tp(&cli_tp);
 175         printf("\n");
 176
 177         CHECK(listen_sk.state != 10 ||
 178               listen_sk.family != AF_INET6 ||
 179               listen_sk.protocol != IPPROTO_TCP ||
 180               memcmp(listen_sk.src_ip6, &in6addr_loopback,
 181                      sizeof(listen_sk.src_ip6)) ||
 182               listen_sk.dst_ip6[0] || listen_sk.dst_ip6[1] ||
 183               listen_sk.dst_ip6[2] || listen_sk.dst_ip6[3] ||
 184               listen_sk.src_port != ntohs(srv_sa6.sin6_port) ||
 185               listen_sk.dst_port,
 186               "Unexpected listen_sk",
 187               "Check listen_sk output. ingress_linum:%u",
 188               ingress_linum);
 189
 190         CHECK(srv_sk.state == 10 ||
 191               !srv_sk.state ||
 192               srv_sk.family != AF_INET6 ||
 193               srv_sk.protocol != IPPROTO_TCP ||
 194               memcmp(srv_sk.src_ip6, &in6addr_loopback,
 195                      sizeof(srv_sk.src_ip6)) ||
 196               memcmp(srv_sk.dst_ip6, &in6addr_loopback,
 197                      sizeof(srv_sk.dst_ip6)) ||
 198               srv_sk.src_port != ntohs(srv_sa6.sin6_port) ||
 199               srv_sk.dst_port != cli_sa6.sin6_port,
 200               "Unexpected srv_sk", "Check srv_sk output. egress_linum:%u",
 201               egress_linum);
 202
 203         CHECK(cli_sk.state == 10 ||
 204               !cli_sk.state ||
 205               cli_sk.family != AF_INET6 ||
 206               cli_sk.protocol != IPPROTO_TCP ||
 207               memcmp(cli_sk.src_ip6, &in6addr_loopback,
 208                      sizeof(cli_sk.src_ip6)) ||
 209               memcmp(cli_sk.dst_ip6, &in6addr_loopback,
 210                      sizeof(cli_sk.dst_ip6)) ||
 211               cli_sk.src_port != ntohs(cli_sa6.sin6_port) ||
 212               cli_sk.dst_port != srv_sa6.sin6_port,
 213               "Unexpected cli_sk", "Check cli_sk output. egress_linum:%u",
 214               egress_linum);
 215
 216         CHECK(listen_tp.data_segs_out ||
 217               listen_tp.data_segs_in ||
 218               listen_tp.total_retrans ||
 219               listen_tp.bytes_acked,
 220               "Unexpected listen_tp", "Check listen_tp output. ingress_linum:%u",
 221               ingress_linum);
 222
 223         CHECK(srv_tp.data_segs_out != 1 ||
 224               srv_tp.data_segs_in ||
 225               srv_tp.snd_cwnd != 10 ||
 226               srv_tp.total_retrans ||
 227               srv_tp.bytes_acked != DATA_LEN,
 228               "Unexpected srv_tp", "Check srv_tp output. egress_linum:%u",
 229               egress_linum);
 230
 231         CHECK(cli_tp.data_segs_out ||
 232               cli_tp.data_segs_in != 1 ||
 233               cli_tp.snd_cwnd != 10 ||
 234               cli_tp.total_retrans ||
 235               cli_tp.bytes_received != DATA_LEN,
 236               "Unexpected cli_tp", "Check cli_tp output. egress_linum:%u",
 237               egress_linum);
 238 }
 239
 240 static void test(void)
 241 {
 242         int listen_fd, cli_fd, accept_fd, epfd, err;
 243         struct epoll_event ev;
 244         socklen_t addrlen;
 245
 246         addrlen = sizeof(struct sockaddr_in6);
 247         ev.events = EPOLLIN;
 248
 249         epfd = epoll_create(1);
 250         CHECK(epfd == -1, "epoll_create()", "epfd:%d errno:%d", epfd, errno);
 251
 252         /* Prepare listen_fd */
 253         listen_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 254         CHECK(listen_fd == -1, "socket()", "listen_fd:%d errno:%d",
 255               listen_fd, errno);
 256
 257         init_loopback6(&srv_sa6);
 258         err = bind(listen_fd, (struct sockaddr *)&srv_sa6, sizeof(srv_sa6));
 259         CHECK(err, "bind(listen_fd)", "err:%d errno:%d", err, errno);
 260
 261         err = getsockname(listen_fd, (struct sockaddr *)&srv_sa6, &addrlen);
 262         CHECK(err, "getsockname(listen_fd)", "err:%d errno:%d", err, errno);
 263
 264         err = listen(listen_fd, 1);
 265         CHECK(err, "listen(listen_fd)", "err:%d errno:%d", err, errno);
 266
 267         /* Prepare cli_fd */
 268         cli_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 269         CHECK(cli_fd == -1, "socket()", "cli_fd:%d errno:%d", cli_fd, errno);
 270
 271         init_loopback6(&cli_sa6);
 272         err = bind(cli_fd, (struct sockaddr *)&cli_sa6, sizeof(cli_sa6));
 273         CHECK(err, "bind(cli_fd)", "err:%d errno:%d", err, errno);
 274
 275         err = getsockname(cli_fd, (struct sockaddr *)&cli_sa6, &addrlen);
 276         CHECK(err, "getsockname(cli_fd)", "err:%d errno:%d",
 277               err, errno);
 278
 279         /* Update addr_map with srv_sa6 and cli_sa6 */
 280         err = bpf_map_update_elem(addr_map_fd, &addr_srv_idx, &srv_sa6, 0);
 281         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 282
 283         err = bpf_map_update_elem(addr_map_fd, &addr_cli_idx, &cli_sa6, 0);
 284         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 285
 286         /* Connect from cli_sa6 to srv_sa6 */
 287         err = connect(cli_fd, (struct sockaddr *)&srv_sa6, addrlen);
 288         printf("srv_sa6.sin6_port:%u cli_sa6.sin6_port:%u\n\n",
 289                ntohs(srv_sa6.sin6_port), ntohs(cli_sa6.sin6_port));
 290         CHECK(err && errno != EINPROGRESS,
 291               "connect(cli_fd)", "err:%d errno:%d", err, errno);
 292
 293         ev.data.fd = listen_fd;
 294         err = epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
 295         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, listen_fd)", "err:%d errno:%d",
 296               err, errno);
 297
 298         /* Accept the connection */
 299         /* Have some timeout in accept(listen_fd). Just in case. */
 300         err = epoll_wait(epfd, &ev, 1, 1000);
 301         CHECK(err != 1 || ev.data.fd != listen_fd,
 302               "epoll_wait(listen_fd)",
 303               "err:%d errno:%d ev.data.fd:%d listen_fd:%d",
 304               err, errno, ev.data.fd, listen_fd);
 305
 306         accept_fd = accept(listen_fd, NULL, NULL);
 307         CHECK(accept_fd == -1, "accept(listen_fd)", "accept_fd:%d errno:%d",
 308               accept_fd, errno);
 309         close(listen_fd);
 310
 311         /* Send some data from accept_fd to cli_fd */
 312         err = send(accept_fd, DATA, DATA_LEN, 0);
 313         CHECK(err != DATA_LEN, "send(accept_fd)", "err:%d errno:%d",
 314               err, errno);
 315
 316         /* Have some timeout in recv(cli_fd). Just in case. */
 317         ev.data.fd = cli_fd;
 318         err = epoll_ctl(epfd, EPOLL_CTL_ADD, cli_fd, &ev);
 319         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, cli_fd)", "err:%d errno:%d",
 320               err, errno);
 321
 322         err = epoll_wait(epfd, &ev, 1, 1000);
 323         CHECK(err != 1 || ev.data.fd != cli_fd,
 324               "epoll_wait(cli_fd)", "err:%d errno:%d ev.data.fd:%d cli_fd:%d",
 325               err, errno, ev.data.fd, cli_fd);
 326
 327         err = recv(cli_fd, NULL, 0, MSG_TRUNC);
 328         CHECK(err, "recv(cli_fd)", "err:%d errno:%d", err, errno);
 329
 330         close(epfd);
 331         close(accept_fd);
 332         close(cli_fd);
 333
 334         check_result();
 335 }
 336
 337 int main(int argc, char **argv)
 338 {
 339         struct bpf_prog_load_attr attr = {
 340                 .file = "test_sock_fields_kern.o",
 341                 .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
 342         };
 343         int cgroup_fd, egress_fd, ingress_fd, err;
 344         struct bpf_program *ingress_prog;
 345         struct bpf_object *obj;
 346         struct bpf_map *map;
 347
 348         err = setup_cgroup_environment();
 349         CHECK(err, "setup_cgroup_environment()", "err:%d errno:%d",
 350               err, errno);
 351
 352         atexit(cleanup_cgroup_environment);
 353
 354         /* Create a cgroup, get fd, and join it */
 355         cgroup_fd = create_and_get_cgroup(TEST_CGROUP);
 356         CHECK(cgroup_fd == -1, "create_and_get_cgroup()",
 357               "cgroup_fd:%d errno:%d", cgroup_fd, errno);
 358
 359         err = join_cgroup(TEST_CGROUP);
 360         CHECK(err, "join_cgroup", "err:%d errno:%d", err, errno);
 361
 362         err = bpf_prog_load_xattr(&attr, &obj, &egress_fd);
 363         CHECK(err, "bpf_prog_load_xattr()", "err:%d", err);
 364
 365         ingress_prog = bpf_object__find_program_by_title(obj,
 366                                                          "cgroup_skb/ingress");
 367         CHECK(!ingress_prog,
 368               "bpf_object__find_program_by_title(cgroup_skb/ingress)",
 369               "not found");
 370         ingress_fd = bpf_program__fd(ingress_prog);
 371
 372         err = bpf_prog_attach(egress_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0);
 373         CHECK(err == -1, "bpf_prog_attach(CPF_CGROUP_INET_EGRESS)",
 374               "err:%d errno%d", err, errno);
 375
 376         err = bpf_prog_attach(ingress_fd, cgroup_fd,
 377                               BPF_CGROUP_INET_INGRESS, 0);
 378         CHECK(err == -1, "bpf_prog_attach(CPF_CGROUP_INET_INGRESS)",
 379               "err:%d errno%d", err, errno);
 380         close(cgroup_fd);
 381
 382         map = bpf_object__find_map_by_name(obj, "addr_map");
 383         CHECK(!map, "cannot find addr_map", "(null)");
 384         addr_map_fd = bpf_map__fd(map);
 385
 386         map = bpf_object__find_map_by_name(obj, "sock_result_map");
 387         CHECK(!map, "cannot find sock_result_map", "(null)");
 388         sk_map_fd = bpf_map__fd(map);
 389
 390         map = bpf_object__find_map_by_name(obj, "tcp_sock_result_map");
 391         CHECK(!map, "cannot find tcp_sock_result_map", "(null)");
 392         tp_map_fd = bpf_map__fd(map);
 393
 394         map = bpf_object__find_map_by_name(obj, "linum_map");
 395         CHECK(!map, "cannot find linum_map", "(null)");
 396         linum_map_fd = bpf_map__fd(map);
 397
 398         test();
 399
 400         bpf_object__close(obj);
 401         cleanup_cgroup_environment();
 402
 403         printf("PASS\n");
 404
 405         return 0;
 406 }