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 struct bpf_spinlock_cnt {
  39         struct bpf_spin_lock lock;
  40         __u32 cnt;
  41 };
  42
  43 #define CHECK(condition, tag, format...) ({                             \
  44         int __ret = !!(condition);                                      \
  45         if (__ret) {                                                    \
  46                 printf("%s(%d):FAIL:%s ", __func__, __LINE__, tag);     \
  47                 printf(format);                                         \
  48                 printf("\n");                                           \
  49                 exit(-1);                                               \
  50         }                                                               \
  51 })
  52
  53 #define TEST_CGROUP "/test-bpf-sock-fields"
  54 #define DATA "Hello BPF!"
  55 #define DATA_LEN sizeof(DATA)
  56
  57 static struct sockaddr_in6 srv_sa6, cli_sa6;
  58 static int sk_pkt_out_cnt10_fd;
  59 static int sk_pkt_out_cnt_fd;
  60 static int linum_map_fd;
  61 static int addr_map_fd;
  62 static int tp_map_fd;
  63 static int sk_map_fd;
  64
  65 static __u32 addr_srv_idx = ADDR_SRV_IDX;
  66 static __u32 addr_cli_idx = ADDR_CLI_IDX;
  67
  68 static __u32 egress_srv_idx = EGRESS_SRV_IDX;
  69 static __u32 egress_cli_idx = EGRESS_CLI_IDX;
  70 static __u32 ingress_listen_idx = INGRESS_LISTEN_IDX;
  71
  72 static __u32 egress_linum_idx = EGRESS_LINUM_IDX;
  73 static __u32 ingress_linum_idx = INGRESS_LINUM_IDX;
  74
  75 static void init_loopback6(struct sockaddr_in6 *sa6)
  76 {
  77         memset(sa6, 0, sizeof(*sa6));
  78         sa6->sin6_family = AF_INET6;
  79         sa6->sin6_addr = in6addr_loopback;
  80 }
  81
  82 static void print_sk(const struct bpf_sock *sk)
  83 {
  84         char src_ip4[24], dst_ip4[24];
  85         char src_ip6[64], dst_ip6[64];
  86
  87         inet_ntop(AF_INET, &sk->src_ip4, src_ip4, sizeof(src_ip4));
  88         inet_ntop(AF_INET6, &sk->src_ip6, src_ip6, sizeof(src_ip6));
  89         inet_ntop(AF_INET, &sk->dst_ip4, dst_ip4, sizeof(dst_ip4));
  90         inet_ntop(AF_INET6, &sk->dst_ip6, dst_ip6, sizeof(dst_ip6));
  91
  92         printf("state:%u bound_dev_if:%u family:%u type:%u protocol:%u mark:%u priority:%u "
  93                "src_ip4:%x(%s) src_ip6:%x:%x:%x:%x(%s) src_port:%u "
  94                "dst_ip4:%x(%s) dst_ip6:%x:%x:%x:%x(%s) dst_port:%u\n",
  95                sk->state, sk->bound_dev_if, sk->family, sk->type, sk->protocol,
  96                sk->mark, sk->priority,
  97                sk->src_ip4, src_ip4,
  98                sk->src_ip6[0], sk->src_ip6[1], sk->src_ip6[2], sk->src_ip6[3],
  99                src_ip6, sk->src_port,
 100                sk->dst_ip4, dst_ip4,
 101                sk->dst_ip6[0], sk->dst_ip6[1], sk->dst_ip6[2], sk->dst_ip6[3],
 102                dst_ip6, ntohs(sk->dst_port));
 103 }
 104
 105 static void print_tp(const struct bpf_tcp_sock *tp)
 106 {
 107         printf("snd_cwnd:%u srtt_us:%u rtt_min:%u snd_ssthresh:%u rcv_nxt:%u "
 108                "snd_nxt:%u snd:una:%u mss_cache:%u ecn_flags:%u "
 109                "rate_delivered:%u rate_interval_us:%u packets_out:%u "
 110                "retrans_out:%u total_retrans:%u segs_in:%u data_segs_in:%u "
 111                "segs_out:%u data_segs_out:%u lost_out:%u sacked_out:%u "
 112                "bytes_received:%llu bytes_acked:%llu\n",
 113                tp->snd_cwnd, tp->srtt_us, tp->rtt_min, tp->snd_ssthresh,
 114                tp->rcv_nxt, tp->snd_nxt, tp->snd_una, tp->mss_cache,
 115                tp->ecn_flags, tp->rate_delivered, tp->rate_interval_us,
 116                tp->packets_out, tp->retrans_out, tp->total_retrans,
 117                tp->segs_in, tp->data_segs_in, tp->segs_out,
 118                tp->data_segs_out, tp->lost_out, tp->sacked_out,
 119                tp->bytes_received, tp->bytes_acked);
 120 }
 121
 122 static void check_result(void)
 123 {
 124         struct bpf_tcp_sock srv_tp, cli_tp, listen_tp;
 125         struct bpf_sock srv_sk, cli_sk, listen_sk;
 126         __u32 ingress_linum, egress_linum;
 127         int err;
 128
 129         err = bpf_map_lookup_elem(linum_map_fd, &egress_linum_idx,
 130                                   &egress_linum);
 131         CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
 132               "err:%d errno:%d", err, errno);
 133
 134         err = bpf_map_lookup_elem(linum_map_fd, &ingress_linum_idx,
 135                                   &ingress_linum);
 136         CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
 137               "err:%d errno:%d", err, errno);
 138
 139         err = bpf_map_lookup_elem(sk_map_fd, &egress_srv_idx, &srv_sk);
 140         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &egress_srv_idx)",
 141               "err:%d errno:%d", err, errno);
 142         err = bpf_map_lookup_elem(tp_map_fd, &egress_srv_idx, &srv_tp);
 143         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &egress_srv_idx)",
 144               "err:%d errno:%d", err, errno);
 145
 146         err = bpf_map_lookup_elem(sk_map_fd, &egress_cli_idx, &cli_sk);
 147         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &egress_cli_idx)",
 148               "err:%d errno:%d", err, errno);
 149         err = bpf_map_lookup_elem(tp_map_fd, &egress_cli_idx, &cli_tp);
 150         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &egress_cli_idx)",
 151               "err:%d errno:%d", err, errno);
 152
 153         err = bpf_map_lookup_elem(sk_map_fd, &ingress_listen_idx, &listen_sk);
 154         CHECK(err == -1, "bpf_map_lookup_elem(sk_map_fd, &ingress_listen_idx)",
 155               "err:%d errno:%d", err, errno);
 156         err = bpf_map_lookup_elem(tp_map_fd, &ingress_listen_idx, &listen_tp);
 157         CHECK(err == -1, "bpf_map_lookup_elem(tp_map_fd, &ingress_listen_idx)",
 158               "err:%d errno:%d", err, errno);
 159
 160         printf("listen_sk: ");
 161         print_sk(&listen_sk);
 162         printf("\n");
 163
 164         printf("srv_sk: ");
 165         print_sk(&srv_sk);
 166         printf("\n");
 167
 168         printf("cli_sk: ");
 169         print_sk(&cli_sk);
 170         printf("\n");
 171
 172         printf("listen_tp: ");
 173         print_tp(&listen_tp);
 174         printf("\n");
 175
 176         printf("srv_tp: ");
 177         print_tp(&srv_tp);
 178         printf("\n");
 179
 180         printf("cli_tp: ");
 181         print_tp(&cli_tp);
 182         printf("\n");
 183
 184         CHECK(listen_sk.state != 10 ||
 185               listen_sk.family != AF_INET6 ||
 186               listen_sk.protocol != IPPROTO_TCP ||
 187               memcmp(listen_sk.src_ip6, &in6addr_loopback,
 188                      sizeof(listen_sk.src_ip6)) ||
 189               listen_sk.dst_ip6[0] || listen_sk.dst_ip6[1] ||
 190               listen_sk.dst_ip6[2] || listen_sk.dst_ip6[3] ||
 191               listen_sk.src_port != ntohs(srv_sa6.sin6_port) ||
 192               listen_sk.dst_port,
 193               "Unexpected listen_sk",
 194               "Check listen_sk output. ingress_linum:%u",
 195               ingress_linum);
 196
 197         CHECK(srv_sk.state == 10 ||
 198               !srv_sk.state ||
 199               srv_sk.family != AF_INET6 ||
 200               srv_sk.protocol != IPPROTO_TCP ||
 201               memcmp(srv_sk.src_ip6, &in6addr_loopback,
 202                      sizeof(srv_sk.src_ip6)) ||
 203               memcmp(srv_sk.dst_ip6, &in6addr_loopback,
 204                      sizeof(srv_sk.dst_ip6)) ||
 205               srv_sk.src_port != ntohs(srv_sa6.sin6_port) ||
 206               srv_sk.dst_port != cli_sa6.sin6_port,
 207               "Unexpected srv_sk", "Check srv_sk output. egress_linum:%u",
 208               egress_linum);
 209
 210         CHECK(cli_sk.state == 10 ||
 211               !cli_sk.state ||
 212               cli_sk.family != AF_INET6 ||
 213               cli_sk.protocol != IPPROTO_TCP ||
 214               memcmp(cli_sk.src_ip6, &in6addr_loopback,
 215                      sizeof(cli_sk.src_ip6)) ||
 216               memcmp(cli_sk.dst_ip6, &in6addr_loopback,
 217                      sizeof(cli_sk.dst_ip6)) ||
 218               cli_sk.src_port != ntohs(cli_sa6.sin6_port) ||
 219               cli_sk.dst_port != srv_sa6.sin6_port,
 220               "Unexpected cli_sk", "Check cli_sk output. egress_linum:%u",
 221               egress_linum);
 222
 223         CHECK(listen_tp.data_segs_out ||
 224               listen_tp.data_segs_in ||
 225               listen_tp.total_retrans ||
 226               listen_tp.bytes_acked,
 227               "Unexpected listen_tp", "Check listen_tp output. ingress_linum:%u",
 228               ingress_linum);
 229
 230         CHECK(srv_tp.data_segs_out != 2 ||
 231               srv_tp.data_segs_in ||
 232               srv_tp.snd_cwnd != 10 ||
 233               srv_tp.total_retrans ||
 234               srv_tp.bytes_acked != 2 * DATA_LEN,
 235               "Unexpected srv_tp", "Check srv_tp output. egress_linum:%u",
 236               egress_linum);
 237
 238         CHECK(cli_tp.data_segs_out ||
 239               cli_tp.data_segs_in != 2 ||
 240               cli_tp.snd_cwnd != 10 ||
 241               cli_tp.total_retrans ||
 242               cli_tp.bytes_received != 2 * DATA_LEN,
 243               "Unexpected cli_tp", "Check cli_tp output. egress_linum:%u",
 244               egress_linum);
 245 }
 246
 247 static void check_sk_pkt_out_cnt(int accept_fd, int cli_fd)
 248 {
 249         struct bpf_spinlock_cnt pkt_out_cnt = {}, pkt_out_cnt10 = {};
 250         int err;
 251
 252         pkt_out_cnt.cnt = ~0;
 253         pkt_out_cnt10.cnt = ~0;
 254         err = bpf_map_lookup_elem(sk_pkt_out_cnt_fd, &accept_fd, &pkt_out_cnt);
 255         if (!err)
 256                 err = bpf_map_lookup_elem(sk_pkt_out_cnt10_fd, &accept_fd,
 257                                           &pkt_out_cnt10);
 258
 259         /* The bpf prog only counts for fullsock and
 260          * passive conneciton did not become fullsock until 3WHS
 261          * had been finished.
 262          * The bpf prog only counted two data packet out but we
 263          * specially init accept_fd's pkt_out_cnt by 2 in
 264          * init_sk_storage().  Hence, 4 here.
 265          */
 266         CHECK(err || pkt_out_cnt.cnt != 4 || pkt_out_cnt10.cnt != 40,
 267               "bpf_map_lookup_elem(sk_pkt_out_cnt, &accept_fd)",
 268               "err:%d errno:%d pkt_out_cnt:%u pkt_out_cnt10:%u",
 269               err, errno, pkt_out_cnt.cnt, pkt_out_cnt10.cnt);
 270
 271         pkt_out_cnt.cnt = ~0;
 272         pkt_out_cnt10.cnt = ~0;
 273         err = bpf_map_lookup_elem(sk_pkt_out_cnt_fd, &cli_fd, &pkt_out_cnt);
 274         if (!err)
 275                 err = bpf_map_lookup_elem(sk_pkt_out_cnt10_fd, &cli_fd,
 276                                           &pkt_out_cnt10);
 277         /* Active connection is fullsock from the beginning.
 278          * 1 SYN and 1 ACK during 3WHS
 279          * 2 Acks on data packet.
 280          *
 281          * The bpf_prog initialized it to 0xeB9F.
 282          */
 283         CHECK(err || pkt_out_cnt.cnt != 0xeB9F + 4 ||
 284               pkt_out_cnt10.cnt != 0xeB9F + 40,
 285               "bpf_map_lookup_elem(sk_pkt_out_cnt, &cli_fd)",
 286               "err:%d errno:%d pkt_out_cnt:%u pkt_out_cnt10:%u",
 287               err, errno, pkt_out_cnt.cnt, pkt_out_cnt10.cnt);
 288 }
 289
 290 static void init_sk_storage(int sk_fd, __u32 pkt_out_cnt)
 291 {
 292         struct bpf_spinlock_cnt scnt = {};
 293         int err;
 294
 295         scnt.cnt = pkt_out_cnt;
 296         err = bpf_map_update_elem(sk_pkt_out_cnt_fd, &sk_fd, &scnt,
 297                                   BPF_NOEXIST);
 298         CHECK(err, "bpf_map_update_elem(sk_pkt_out_cnt_fd)",
 299               "err:%d errno:%d", err, errno);
 300
 301         scnt.cnt *= 10;
 302         err = bpf_map_update_elem(sk_pkt_out_cnt10_fd, &sk_fd, &scnt,
 303                                   BPF_NOEXIST);
 304         CHECK(err, "bpf_map_update_elem(sk_pkt_out_cnt10_fd)",
 305               "err:%d errno:%d", err, errno);
 306 }
 307
 308 static void test(void)
 309 {
 310         int listen_fd, cli_fd, accept_fd, epfd, err;
 311         struct epoll_event ev;
 312         socklen_t addrlen;
 313         int i;
 314
 315         addrlen = sizeof(struct sockaddr_in6);
 316         ev.events = EPOLLIN;
 317
 318         epfd = epoll_create(1);
 319         CHECK(epfd == -1, "epoll_create()", "epfd:%d errno:%d", epfd, errno);
 320
 321         /* Prepare listen_fd */
 322         listen_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 323         CHECK(listen_fd == -1, "socket()", "listen_fd:%d errno:%d",
 324               listen_fd, errno);
 325
 326         init_loopback6(&srv_sa6);
 327         err = bind(listen_fd, (struct sockaddr *)&srv_sa6, sizeof(srv_sa6));
 328         CHECK(err, "bind(listen_fd)", "err:%d errno:%d", err, errno);
 329
 330         err = getsockname(listen_fd, (struct sockaddr *)&srv_sa6, &addrlen);
 331         CHECK(err, "getsockname(listen_fd)", "err:%d errno:%d", err, errno);
 332
 333         err = listen(listen_fd, 1);
 334         CHECK(err, "listen(listen_fd)", "err:%d errno:%d", err, errno);
 335
 336         /* Prepare cli_fd */
 337         cli_fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 338         CHECK(cli_fd == -1, "socket()", "cli_fd:%d errno:%d", cli_fd, errno);
 339
 340         init_loopback6(&cli_sa6);
 341         err = bind(cli_fd, (struct sockaddr *)&cli_sa6, sizeof(cli_sa6));
 342         CHECK(err, "bind(cli_fd)", "err:%d errno:%d", err, errno);
 343
 344         err = getsockname(cli_fd, (struct sockaddr *)&cli_sa6, &addrlen);
 345         CHECK(err, "getsockname(cli_fd)", "err:%d errno:%d",
 346               err, errno);
 347
 348         /* Update addr_map with srv_sa6 and cli_sa6 */
 349         err = bpf_map_update_elem(addr_map_fd, &addr_srv_idx, &srv_sa6, 0);
 350         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 351
 352         err = bpf_map_update_elem(addr_map_fd, &addr_cli_idx, &cli_sa6, 0);
 353         CHECK(err, "map_update", "err:%d errno:%d", err, errno);
 354
 355         /* Connect from cli_sa6 to srv_sa6 */
 356         err = connect(cli_fd, (struct sockaddr *)&srv_sa6, addrlen);
 357         printf("srv_sa6.sin6_port:%u cli_sa6.sin6_port:%u\n\n",
 358                ntohs(srv_sa6.sin6_port), ntohs(cli_sa6.sin6_port));
 359         CHECK(err && errno != EINPROGRESS,
 360               "connect(cli_fd)", "err:%d errno:%d", err, errno);
 361
 362         ev.data.fd = listen_fd;
 363         err = epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
 364         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, listen_fd)", "err:%d errno:%d",
 365               err, errno);
 366
 367         /* Accept the connection */
 368         /* Have some timeout in accept(listen_fd). Just in case. */
 369         err = epoll_wait(epfd, &ev, 1, 1000);
 370         CHECK(err != 1 || ev.data.fd != listen_fd,
 371               "epoll_wait(listen_fd)",
 372               "err:%d errno:%d ev.data.fd:%d listen_fd:%d",
 373               err, errno, ev.data.fd, listen_fd);
 374
 375         accept_fd = accept(listen_fd, NULL, NULL);
 376         CHECK(accept_fd == -1, "accept(listen_fd)", "accept_fd:%d errno:%d",
 377               accept_fd, errno);
 378         close(listen_fd);
 379
 380         ev.data.fd = cli_fd;
 381         err = epoll_ctl(epfd, EPOLL_CTL_ADD, cli_fd, &ev);
 382         CHECK(err, "epoll_ctl(EPOLL_CTL_ADD, cli_fd)", "err:%d errno:%d",
 383               err, errno);
 384
 385         init_sk_storage(accept_fd, 2);
 386
 387         for (i = 0; i < 2; i++) {
 388                 /* Send some data from accept_fd to cli_fd */
 389                 err = send(accept_fd, DATA, DATA_LEN, 0);
 390                 CHECK(err != DATA_LEN, "send(accept_fd)", "err:%d errno:%d",
 391                       err, errno);
 392
 393                 /* Have some timeout in recv(cli_fd). Just in case. */
 394                 err = epoll_wait(epfd, &ev, 1, 1000);
 395                 CHECK(err != 1 || ev.data.fd != cli_fd,
 396                       "epoll_wait(cli_fd)", "err:%d errno:%d ev.data.fd:%d cli_fd:%d",
 397                       err, errno, ev.data.fd, cli_fd);
 398
 399                 err = recv(cli_fd, NULL, 0, MSG_TRUNC);
 400                 CHECK(err, "recv(cli_fd)", "err:%d errno:%d", err, errno);
 401         }
 402
 403         check_sk_pkt_out_cnt(accept_fd, cli_fd);
 404
 405         close(epfd);
 406         close(accept_fd);
 407         close(cli_fd);
 408
 409         check_result();
 410 }
 411
 412 int main(int argc, char **argv)
 413 {
 414         struct bpf_prog_load_attr attr = {
 415                 .file = "test_sock_fields_kern.o",
 416                 .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
 417                 .prog_flags = BPF_F_TEST_RND_HI32,
 418         };
 419         int cgroup_fd, egress_fd, ingress_fd, err;
 420         struct bpf_program *ingress_prog;
 421         struct bpf_object *obj;
 422         struct bpf_map *map;
 423
 424         err = setup_cgroup_environment();
 425         CHECK(err, "setup_cgroup_environment()", "err:%d errno:%d",
 426               err, errno);
 427
 428         atexit(cleanup_cgroup_environment);
 429
 430         /* Create a cgroup, get fd, and join it */
 431         cgroup_fd = create_and_get_cgroup(TEST_CGROUP);
 432         CHECK(cgroup_fd == -1, "create_and_get_cgroup()",
 433               "cgroup_fd:%d errno:%d", cgroup_fd, errno);
 434
 435         err = join_cgroup(TEST_CGROUP);
 436         CHECK(err, "join_cgroup", "err:%d errno:%d", err, errno);
 437
 438         err = bpf_prog_load_xattr(&attr, &obj, &egress_fd);
 439         CHECK(err, "bpf_prog_load_xattr()", "err:%d", err);
 440
 441         ingress_prog = bpf_object__find_program_by_title(obj,
 442                                                          "cgroup_skb/ingress");
 443         CHECK(!ingress_prog,
 444               "bpf_object__find_program_by_title(cgroup_skb/ingress)",
 445               "not found");
 446         ingress_fd = bpf_program__fd(ingress_prog);
 447
 448         err = bpf_prog_attach(egress_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0);
 449         CHECK(err == -1, "bpf_prog_attach(CPF_CGROUP_INET_EGRESS)",
 450               "err:%d errno%d", err, errno);
 451
 452         err = bpf_prog_attach(ingress_fd, cgroup_fd,
 453                               BPF_CGROUP_INET_INGRESS, 0);
 454         CHECK(err == -1, "bpf_prog_attach(CPF_CGROUP_INET_INGRESS)",
 455               "err:%d errno%d", err, errno);
 456         close(cgroup_fd);
 457
 458         map = bpf_object__find_map_by_name(obj, "addr_map");
 459         CHECK(!map, "cannot find addr_map", "(null)");
 460         addr_map_fd = bpf_map__fd(map);
 461
 462         map = bpf_object__find_map_by_name(obj, "sock_result_map");
 463         CHECK(!map, "cannot find sock_result_map", "(null)");
 464         sk_map_fd = bpf_map__fd(map);
 465
 466         map = bpf_object__find_map_by_name(obj, "tcp_sock_result_map");
 467         CHECK(!map, "cannot find tcp_sock_result_map", "(null)");
 468         tp_map_fd = bpf_map__fd(map);
 469
 470         map = bpf_object__find_map_by_name(obj, "linum_map");
 471         CHECK(!map, "cannot find linum_map", "(null)");
 472         linum_map_fd = bpf_map__fd(map);
 473
 474         map = bpf_object__find_map_by_name(obj, "sk_pkt_out_cnt");
 475         CHECK(!map, "cannot find sk_pkt_out_cnt", "(null)");
 476         sk_pkt_out_cnt_fd = bpf_map__fd(map);
 477
 478         map = bpf_object__find_map_by_name(obj, "sk_pkt_out_cnt10");
 479         CHECK(!map, "cannot find sk_pkt_out_cnt10", "(null)");
 480         sk_pkt_out_cnt10_fd = bpf_map__fd(map);
 481
 482         test();
 483
 484         bpf_object__close(obj);
 485         cleanup_cgroup_environment();
 486
 487         printf("PASS\n");
 488
 489         return 0;
 490 }