Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2020 Facebook */
0003 #include <test_progs.h>
0004 #include "bpf_iter_ipv6_route.skel.h"
0005 #include "bpf_iter_netlink.skel.h"
0006 #include "bpf_iter_bpf_map.skel.h"
0007 #include "bpf_iter_task.skel.h"
0008 #include "bpf_iter_task_stack.skel.h"
0009 #include "bpf_iter_task_file.skel.h"
0010 #include "bpf_iter_task_vma.skel.h"
0011 #include "bpf_iter_task_btf.skel.h"
0012 #include "bpf_iter_tcp4.skel.h"
0013 #include "bpf_iter_tcp6.skel.h"
0014 #include "bpf_iter_udp4.skel.h"
0015 #include "bpf_iter_udp6.skel.h"
0016 #include "bpf_iter_unix.skel.h"
0017 #include "bpf_iter_test_kern1.skel.h"
0018 #include "bpf_iter_test_kern2.skel.h"
0019 #include "bpf_iter_test_kern3.skel.h"
0020 #include "bpf_iter_test_kern4.skel.h"
0021 #include "bpf_iter_bpf_hash_map.skel.h"
0022 #include "bpf_iter_bpf_percpu_hash_map.skel.h"
0023 #include "bpf_iter_bpf_array_map.skel.h"
0024 #include "bpf_iter_bpf_percpu_array_map.skel.h"
0025 #include "bpf_iter_bpf_sk_storage_helpers.skel.h"
0026 #include "bpf_iter_bpf_sk_storage_map.skel.h"
0027 #include "bpf_iter_test_kern5.skel.h"
0028 #include "bpf_iter_test_kern6.skel.h"
0029 #include "bpf_iter_bpf_link.skel.h"
0030 #include "bpf_iter_ksym.skel.h"
0031 #include "bpf_iter_sockmap.skel.h"
0032 
0033 static int duration;
0034 
0035 static void test_btf_id_or_null(void)
0036 {
0037     struct bpf_iter_test_kern3 *skel;
0038 
0039     skel = bpf_iter_test_kern3__open_and_load();
0040     if (!ASSERT_ERR_PTR(skel, "bpf_iter_test_kern3__open_and_load")) {
0041         bpf_iter_test_kern3__destroy(skel);
0042         return;
0043     }
0044 }
0045 
0046 static void do_dummy_read(struct bpf_program *prog)
0047 {
0048     struct bpf_link *link;
0049     char buf[16] = {};
0050     int iter_fd, len;
0051 
0052     link = bpf_program__attach_iter(prog, NULL);
0053     if (!ASSERT_OK_PTR(link, "attach_iter"))
0054         return;
0055 
0056     iter_fd = bpf_iter_create(bpf_link__fd(link));
0057     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0058         goto free_link;
0059 
0060     /* not check contents, but ensure read() ends without error */
0061     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0062         ;
0063     CHECK(len < 0, "read", "read failed: %s\n", strerror(errno));
0064 
0065     close(iter_fd);
0066 
0067 free_link:
0068     bpf_link__destroy(link);
0069 }
0070 
0071 static void do_read_map_iter_fd(struct bpf_object_skeleton **skel, struct bpf_program *prog,
0072                 struct bpf_map *map)
0073 {
0074     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0075     union bpf_iter_link_info linfo;
0076     struct bpf_link *link;
0077     char buf[16] = {};
0078     int iter_fd, len;
0079 
0080     memset(&linfo, 0, sizeof(linfo));
0081     linfo.map.map_fd = bpf_map__fd(map);
0082     opts.link_info = &linfo;
0083     opts.link_info_len = sizeof(linfo);
0084     link = bpf_program__attach_iter(prog, &opts);
0085     if (!ASSERT_OK_PTR(link, "attach_map_iter"))
0086         return;
0087 
0088     iter_fd = bpf_iter_create(bpf_link__fd(link));
0089     if (!ASSERT_GE(iter_fd, 0, "create_map_iter")) {
0090         bpf_link__destroy(link);
0091         return;
0092     }
0093 
0094     /* Close link and map fd prematurely */
0095     bpf_link__destroy(link);
0096     bpf_object__destroy_skeleton(*skel);
0097     *skel = NULL;
0098 
0099     /* Try to let map free work to run first if map is freed */
0100     usleep(100);
0101     /* Memory used by both sock map and sock local storage map are
0102      * freed after two synchronize_rcu() calls, so wait for it
0103      */
0104     kern_sync_rcu();
0105     kern_sync_rcu();
0106 
0107     /* Read after both map fd and link fd are closed */
0108     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0109         ;
0110     ASSERT_GE(len, 0, "read_iterator");
0111 
0112     close(iter_fd);
0113 }
0114 
0115 static int read_fd_into_buffer(int fd, char *buf, int size)
0116 {
0117     int bufleft = size;
0118     int len;
0119 
0120     do {
0121         len = read(fd, buf, bufleft);
0122         if (len > 0) {
0123             buf += len;
0124             bufleft -= len;
0125         }
0126     } while (len > 0);
0127 
0128     return len < 0 ? len : size - bufleft;
0129 }
0130 
0131 static void test_ipv6_route(void)
0132 {
0133     struct bpf_iter_ipv6_route *skel;
0134 
0135     skel = bpf_iter_ipv6_route__open_and_load();
0136     if (!ASSERT_OK_PTR(skel, "bpf_iter_ipv6_route__open_and_load"))
0137         return;
0138 
0139     do_dummy_read(skel->progs.dump_ipv6_route);
0140 
0141     bpf_iter_ipv6_route__destroy(skel);
0142 }
0143 
0144 static void test_netlink(void)
0145 {
0146     struct bpf_iter_netlink *skel;
0147 
0148     skel = bpf_iter_netlink__open_and_load();
0149     if (!ASSERT_OK_PTR(skel, "bpf_iter_netlink__open_and_load"))
0150         return;
0151 
0152     do_dummy_read(skel->progs.dump_netlink);
0153 
0154     bpf_iter_netlink__destroy(skel);
0155 }
0156 
0157 static void test_bpf_map(void)
0158 {
0159     struct bpf_iter_bpf_map *skel;
0160 
0161     skel = bpf_iter_bpf_map__open_and_load();
0162     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_map__open_and_load"))
0163         return;
0164 
0165     do_dummy_read(skel->progs.dump_bpf_map);
0166 
0167     bpf_iter_bpf_map__destroy(skel);
0168 }
0169 
0170 static void test_task(void)
0171 {
0172     struct bpf_iter_task *skel;
0173 
0174     skel = bpf_iter_task__open_and_load();
0175     if (!ASSERT_OK_PTR(skel, "bpf_iter_task__open_and_load"))
0176         return;
0177 
0178     do_dummy_read(skel->progs.dump_task);
0179 
0180     bpf_iter_task__destroy(skel);
0181 }
0182 
0183 static void test_task_sleepable(void)
0184 {
0185     struct bpf_iter_task *skel;
0186 
0187     skel = bpf_iter_task__open_and_load();
0188     if (!ASSERT_OK_PTR(skel, "bpf_iter_task__open_and_load"))
0189         return;
0190 
0191     do_dummy_read(skel->progs.dump_task_sleepable);
0192 
0193     ASSERT_GT(skel->bss->num_expected_failure_copy_from_user_task, 0,
0194           "num_expected_failure_copy_from_user_task");
0195     ASSERT_GT(skel->bss->num_success_copy_from_user_task, 0,
0196           "num_success_copy_from_user_task");
0197 
0198     bpf_iter_task__destroy(skel);
0199 }
0200 
0201 static void test_task_stack(void)
0202 {
0203     struct bpf_iter_task_stack *skel;
0204 
0205     skel = bpf_iter_task_stack__open_and_load();
0206     if (!ASSERT_OK_PTR(skel, "bpf_iter_task_stack__open_and_load"))
0207         return;
0208 
0209     do_dummy_read(skel->progs.dump_task_stack);
0210     do_dummy_read(skel->progs.get_task_user_stacks);
0211 
0212     bpf_iter_task_stack__destroy(skel);
0213 }
0214 
0215 static void *do_nothing(void *arg)
0216 {
0217     pthread_exit(arg);
0218 }
0219 
0220 static void test_task_file(void)
0221 {
0222     struct bpf_iter_task_file *skel;
0223     pthread_t thread_id;
0224     void *ret;
0225 
0226     skel = bpf_iter_task_file__open_and_load();
0227     if (!ASSERT_OK_PTR(skel, "bpf_iter_task_file__open_and_load"))
0228         return;
0229 
0230     skel->bss->tgid = getpid();
0231 
0232     if (!ASSERT_OK(pthread_create(&thread_id, NULL, &do_nothing, NULL),
0233           "pthread_create"))
0234         goto done;
0235 
0236     do_dummy_read(skel->progs.dump_task_file);
0237 
0238     if (!ASSERT_FALSE(pthread_join(thread_id, &ret) || ret != NULL,
0239           "pthread_join"))
0240         goto done;
0241 
0242     ASSERT_EQ(skel->bss->count, 0, "check_count");
0243 
0244 done:
0245     bpf_iter_task_file__destroy(skel);
0246 }
0247 
0248 #define TASKBUFSZ       32768
0249 
0250 static char taskbuf[TASKBUFSZ];
0251 
0252 static int do_btf_read(struct bpf_iter_task_btf *skel)
0253 {
0254     struct bpf_program *prog = skel->progs.dump_task_struct;
0255     struct bpf_iter_task_btf__bss *bss = skel->bss;
0256     int iter_fd = -1, err;
0257     struct bpf_link *link;
0258     char *buf = taskbuf;
0259     int ret = 0;
0260 
0261     link = bpf_program__attach_iter(prog, NULL);
0262     if (!ASSERT_OK_PTR(link, "attach_iter"))
0263         return ret;
0264 
0265     iter_fd = bpf_iter_create(bpf_link__fd(link));
0266     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0267         goto free_link;
0268 
0269     err = read_fd_into_buffer(iter_fd, buf, TASKBUFSZ);
0270     if (bss->skip) {
0271         printf("%s:SKIP:no __builtin_btf_type_id\n", __func__);
0272         ret = 1;
0273         test__skip();
0274         goto free_link;
0275     }
0276 
0277     if (CHECK(err < 0, "read", "read failed: %s\n", strerror(errno)))
0278         goto free_link;
0279 
0280     ASSERT_HAS_SUBSTR(taskbuf, "(struct task_struct)",
0281           "check for btf representation of task_struct in iter data");
0282 free_link:
0283     if (iter_fd > 0)
0284         close(iter_fd);
0285     bpf_link__destroy(link);
0286     return ret;
0287 }
0288 
0289 static void test_task_btf(void)
0290 {
0291     struct bpf_iter_task_btf__bss *bss;
0292     struct bpf_iter_task_btf *skel;
0293     int ret;
0294 
0295     skel = bpf_iter_task_btf__open_and_load();
0296     if (!ASSERT_OK_PTR(skel, "bpf_iter_task_btf__open_and_load"))
0297         return;
0298 
0299     bss = skel->bss;
0300 
0301     ret = do_btf_read(skel);
0302     if (ret)
0303         goto cleanup;
0304 
0305     if (!ASSERT_NEQ(bss->tasks, 0, "no task iteration, did BPF program run?"))
0306         goto cleanup;
0307 
0308     ASSERT_EQ(bss->seq_err, 0, "check for unexpected err");
0309 
0310 cleanup:
0311     bpf_iter_task_btf__destroy(skel);
0312 }
0313 
0314 static void test_tcp4(void)
0315 {
0316     struct bpf_iter_tcp4 *skel;
0317 
0318     skel = bpf_iter_tcp4__open_and_load();
0319     if (!ASSERT_OK_PTR(skel, "bpf_iter_tcp4__open_and_load"))
0320         return;
0321 
0322     do_dummy_read(skel->progs.dump_tcp4);
0323 
0324     bpf_iter_tcp4__destroy(skel);
0325 }
0326 
0327 static void test_tcp6(void)
0328 {
0329     struct bpf_iter_tcp6 *skel;
0330 
0331     skel = bpf_iter_tcp6__open_and_load();
0332     if (!ASSERT_OK_PTR(skel, "bpf_iter_tcp6__open_and_load"))
0333         return;
0334 
0335     do_dummy_read(skel->progs.dump_tcp6);
0336 
0337     bpf_iter_tcp6__destroy(skel);
0338 }
0339 
0340 static void test_udp4(void)
0341 {
0342     struct bpf_iter_udp4 *skel;
0343 
0344     skel = bpf_iter_udp4__open_and_load();
0345     if (!ASSERT_OK_PTR(skel, "bpf_iter_udp4__open_and_load"))
0346         return;
0347 
0348     do_dummy_read(skel->progs.dump_udp4);
0349 
0350     bpf_iter_udp4__destroy(skel);
0351 }
0352 
0353 static void test_udp6(void)
0354 {
0355     struct bpf_iter_udp6 *skel;
0356 
0357     skel = bpf_iter_udp6__open_and_load();
0358     if (!ASSERT_OK_PTR(skel, "bpf_iter_udp6__open_and_load"))
0359         return;
0360 
0361     do_dummy_read(skel->progs.dump_udp6);
0362 
0363     bpf_iter_udp6__destroy(skel);
0364 }
0365 
0366 static void test_unix(void)
0367 {
0368     struct bpf_iter_unix *skel;
0369 
0370     skel = bpf_iter_unix__open_and_load();
0371     if (!ASSERT_OK_PTR(skel, "bpf_iter_unix__open_and_load"))
0372         return;
0373 
0374     do_dummy_read(skel->progs.dump_unix);
0375 
0376     bpf_iter_unix__destroy(skel);
0377 }
0378 
0379 /* The expected string is less than 16 bytes */
0380 static int do_read_with_fd(int iter_fd, const char *expected,
0381                bool read_one_char)
0382 {
0383     int len, read_buf_len, start;
0384     char buf[16] = {};
0385 
0386     read_buf_len = read_one_char ? 1 : 16;
0387     start = 0;
0388     while ((len = read(iter_fd, buf + start, read_buf_len)) > 0) {
0389         start += len;
0390         if (CHECK(start >= 16, "read", "read len %d\n", len))
0391             return -1;
0392         read_buf_len = read_one_char ? 1 : 16 - start;
0393     }
0394     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
0395         return -1;
0396 
0397     if (!ASSERT_STREQ(buf, expected, "read"))
0398         return -1;
0399 
0400     return 0;
0401 }
0402 
0403 static void test_anon_iter(bool read_one_char)
0404 {
0405     struct bpf_iter_test_kern1 *skel;
0406     struct bpf_link *link;
0407     int iter_fd, err;
0408 
0409     skel = bpf_iter_test_kern1__open_and_load();
0410     if (!ASSERT_OK_PTR(skel, "bpf_iter_test_kern1__open_and_load"))
0411         return;
0412 
0413     err = bpf_iter_test_kern1__attach(skel);
0414     if (!ASSERT_OK(err, "bpf_iter_test_kern1__attach")) {
0415         goto out;
0416     }
0417 
0418     link = skel->links.dump_task;
0419     iter_fd = bpf_iter_create(bpf_link__fd(link));
0420     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0421         goto out;
0422 
0423     do_read_with_fd(iter_fd, "abcd", read_one_char);
0424     close(iter_fd);
0425 
0426 out:
0427     bpf_iter_test_kern1__destroy(skel);
0428 }
0429 
0430 static int do_read(const char *path, const char *expected)
0431 {
0432     int err, iter_fd;
0433 
0434     iter_fd = open(path, O_RDONLY);
0435     if (CHECK(iter_fd < 0, "open", "open %s failed: %s\n",
0436           path, strerror(errno)))
0437         return -1;
0438 
0439     err = do_read_with_fd(iter_fd, expected, false);
0440     close(iter_fd);
0441     return err;
0442 }
0443 
0444 static void test_file_iter(void)
0445 {
0446     const char *path = "/sys/fs/bpf/bpf_iter_test1";
0447     struct bpf_iter_test_kern1 *skel1;
0448     struct bpf_iter_test_kern2 *skel2;
0449     struct bpf_link *link;
0450     int err;
0451 
0452     skel1 = bpf_iter_test_kern1__open_and_load();
0453     if (!ASSERT_OK_PTR(skel1, "bpf_iter_test_kern1__open_and_load"))
0454         return;
0455 
0456     link = bpf_program__attach_iter(skel1->progs.dump_task, NULL);
0457     if (!ASSERT_OK_PTR(link, "attach_iter"))
0458         goto out;
0459 
0460     /* unlink this path if it exists. */
0461     unlink(path);
0462 
0463     err = bpf_link__pin(link, path);
0464     if (CHECK(err, "pin_iter", "pin_iter to %s failed: %d\n", path, err))
0465         goto free_link;
0466 
0467     err = do_read(path, "abcd");
0468     if (err)
0469         goto unlink_path;
0470 
0471     /* file based iterator seems working fine. Let us a link update
0472      * of the underlying link and `cat` the iterator again, its content
0473      * should change.
0474      */
0475     skel2 = bpf_iter_test_kern2__open_and_load();
0476     if (!ASSERT_OK_PTR(skel2, "bpf_iter_test_kern2__open_and_load"))
0477         goto unlink_path;
0478 
0479     err = bpf_link__update_program(link, skel2->progs.dump_task);
0480     if (!ASSERT_OK(err, "update_prog"))
0481         goto destroy_skel2;
0482 
0483     do_read(path, "ABCD");
0484 
0485 destroy_skel2:
0486     bpf_iter_test_kern2__destroy(skel2);
0487 unlink_path:
0488     unlink(path);
0489 free_link:
0490     bpf_link__destroy(link);
0491 out:
0492     bpf_iter_test_kern1__destroy(skel1);
0493 }
0494 
0495 static void test_overflow(bool test_e2big_overflow, bool ret1)
0496 {
0497     __u32 map_info_len, total_read_len, expected_read_len;
0498     int err, iter_fd, map1_fd, map2_fd, len;
0499     struct bpf_map_info map_info = {};
0500     struct bpf_iter_test_kern4 *skel;
0501     struct bpf_link *link;
0502     __u32 iter_size;
0503     char *buf;
0504 
0505     skel = bpf_iter_test_kern4__open();
0506     if (!ASSERT_OK_PTR(skel, "bpf_iter_test_kern4__open"))
0507         return;
0508 
0509     /* create two maps: bpf program will only do bpf_seq_write
0510      * for these two maps. The goal is one map output almost
0511      * fills seq_file buffer and then the other will trigger
0512      * overflow and needs restart.
0513      */
0514     map1_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, 4, 8, 1, NULL);
0515     if (CHECK(map1_fd < 0, "bpf_map_create",
0516           "map_creation failed: %s\n", strerror(errno)))
0517         goto out;
0518     map2_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, 4, 8, 1, NULL);
0519     if (CHECK(map2_fd < 0, "bpf_map_create",
0520           "map_creation failed: %s\n", strerror(errno)))
0521         goto free_map1;
0522 
0523     /* bpf_seq_printf kernel buffer is 8 pages, so one map
0524      * bpf_seq_write will mostly fill it, and the other map
0525      * will partially fill and then trigger overflow and need
0526      * bpf_seq_read restart.
0527      */
0528     iter_size = sysconf(_SC_PAGE_SIZE) << 3;
0529 
0530     if (test_e2big_overflow) {
0531         skel->rodata->print_len = (iter_size + 8) / 8;
0532         expected_read_len = 2 * (iter_size + 8);
0533     } else if (!ret1) {
0534         skel->rodata->print_len = (iter_size - 8) / 8;
0535         expected_read_len = 2 * (iter_size - 8);
0536     } else {
0537         skel->rodata->print_len = 1;
0538         expected_read_len = 2 * 8;
0539     }
0540     skel->rodata->ret1 = ret1;
0541 
0542     if (!ASSERT_OK(bpf_iter_test_kern4__load(skel),
0543           "bpf_iter_test_kern4__load"))
0544         goto free_map2;
0545 
0546     /* setup filtering map_id in bpf program */
0547     map_info_len = sizeof(map_info);
0548     err = bpf_obj_get_info_by_fd(map1_fd, &map_info, &map_info_len);
0549     if (CHECK(err, "get_map_info", "get map info failed: %s\n",
0550           strerror(errno)))
0551         goto free_map2;
0552     skel->bss->map1_id = map_info.id;
0553 
0554     err = bpf_obj_get_info_by_fd(map2_fd, &map_info, &map_info_len);
0555     if (CHECK(err, "get_map_info", "get map info failed: %s\n",
0556           strerror(errno)))
0557         goto free_map2;
0558     skel->bss->map2_id = map_info.id;
0559 
0560     link = bpf_program__attach_iter(skel->progs.dump_bpf_map, NULL);
0561     if (!ASSERT_OK_PTR(link, "attach_iter"))
0562         goto free_map2;
0563 
0564     iter_fd = bpf_iter_create(bpf_link__fd(link));
0565     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0566         goto free_link;
0567 
0568     buf = malloc(expected_read_len);
0569     if (!buf)
0570         goto close_iter;
0571 
0572     /* do read */
0573     total_read_len = 0;
0574     if (test_e2big_overflow) {
0575         while ((len = read(iter_fd, buf, expected_read_len)) > 0)
0576             total_read_len += len;
0577 
0578         CHECK(len != -1 || errno != E2BIG, "read",
0579               "expected ret -1, errno E2BIG, but get ret %d, error %s\n",
0580               len, strerror(errno));
0581         goto free_buf;
0582     } else if (!ret1) {
0583         while ((len = read(iter_fd, buf, expected_read_len)) > 0)
0584             total_read_len += len;
0585 
0586         if (CHECK(len < 0, "read", "read failed: %s\n",
0587               strerror(errno)))
0588             goto free_buf;
0589     } else {
0590         do {
0591             len = read(iter_fd, buf, expected_read_len);
0592             if (len > 0)
0593                 total_read_len += len;
0594         } while (len > 0 || len == -EAGAIN);
0595 
0596         if (CHECK(len < 0, "read", "read failed: %s\n",
0597               strerror(errno)))
0598             goto free_buf;
0599     }
0600 
0601     if (!ASSERT_EQ(total_read_len, expected_read_len, "read"))
0602         goto free_buf;
0603 
0604     if (!ASSERT_EQ(skel->bss->map1_accessed, 1, "map1_accessed"))
0605         goto free_buf;
0606 
0607     if (!ASSERT_EQ(skel->bss->map2_accessed, 2, "map2_accessed"))
0608         goto free_buf;
0609 
0610     ASSERT_EQ(skel->bss->map2_seqnum1, skel->bss->map2_seqnum2, "map2_seqnum");
0611 
0612 free_buf:
0613     free(buf);
0614 close_iter:
0615     close(iter_fd);
0616 free_link:
0617     bpf_link__destroy(link);
0618 free_map2:
0619     close(map2_fd);
0620 free_map1:
0621     close(map1_fd);
0622 out:
0623     bpf_iter_test_kern4__destroy(skel);
0624 }
0625 
0626 static void test_bpf_hash_map(void)
0627 {
0628     __u32 expected_key_a = 0, expected_key_b = 0;
0629     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0630     struct bpf_iter_bpf_hash_map *skel;
0631     int err, i, len, map_fd, iter_fd;
0632     union bpf_iter_link_info linfo;
0633     __u64 val, expected_val = 0;
0634     struct bpf_link *link;
0635     struct key_t {
0636         int a;
0637         int b;
0638         int c;
0639     } key;
0640     char buf[64];
0641 
0642     skel = bpf_iter_bpf_hash_map__open();
0643     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_hash_map__open"))
0644         return;
0645 
0646     skel->bss->in_test_mode = true;
0647 
0648     err = bpf_iter_bpf_hash_map__load(skel);
0649     if (!ASSERT_OK(err, "bpf_iter_bpf_hash_map__load"))
0650         goto out;
0651 
0652     /* iterator with hashmap2 and hashmap3 should fail */
0653     memset(&linfo, 0, sizeof(linfo));
0654     linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap2);
0655     opts.link_info = &linfo;
0656     opts.link_info_len = sizeof(linfo);
0657     link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
0658     if (!ASSERT_ERR_PTR(link, "attach_iter"))
0659         goto out;
0660 
0661     linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap3);
0662     link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
0663     if (!ASSERT_ERR_PTR(link, "attach_iter"))
0664         goto out;
0665 
0666     /* hashmap1 should be good, update map values here */
0667     map_fd = bpf_map__fd(skel->maps.hashmap1);
0668     for (i = 0; i < bpf_map__max_entries(skel->maps.hashmap1); i++) {
0669         key.a = i + 1;
0670         key.b = i + 2;
0671         key.c = i + 3;
0672         val = i + 4;
0673         expected_key_a += key.a;
0674         expected_key_b += key.b;
0675         expected_val += val;
0676 
0677         err = bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);
0678         if (!ASSERT_OK(err, "map_update"))
0679             goto out;
0680     }
0681 
0682     /* Sleepable program is prohibited for hash map iterator */
0683     linfo.map.map_fd = map_fd;
0684     link = bpf_program__attach_iter(skel->progs.sleepable_dummy_dump, &opts);
0685     if (!ASSERT_ERR_PTR(link, "attach_sleepable_prog_to_iter"))
0686         goto out;
0687 
0688     linfo.map.map_fd = map_fd;
0689     link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
0690     if (!ASSERT_OK_PTR(link, "attach_iter"))
0691         goto out;
0692 
0693     iter_fd = bpf_iter_create(bpf_link__fd(link));
0694     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0695         goto free_link;
0696 
0697     /* do some tests */
0698     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0699         ;
0700     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
0701         goto close_iter;
0702 
0703     /* test results */
0704     if (!ASSERT_EQ(skel->bss->key_sum_a, expected_key_a, "key_sum_a"))
0705         goto close_iter;
0706     if (!ASSERT_EQ(skel->bss->key_sum_b, expected_key_b, "key_sum_b"))
0707         goto close_iter;
0708     if (!ASSERT_EQ(skel->bss->val_sum, expected_val, "val_sum"))
0709         goto close_iter;
0710 
0711 close_iter:
0712     close(iter_fd);
0713 free_link:
0714     bpf_link__destroy(link);
0715 out:
0716     bpf_iter_bpf_hash_map__destroy(skel);
0717 }
0718 
0719 static void test_bpf_percpu_hash_map(void)
0720 {
0721     __u32 expected_key_a = 0, expected_key_b = 0;
0722     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0723     struct bpf_iter_bpf_percpu_hash_map *skel;
0724     int err, i, j, len, map_fd, iter_fd;
0725     union bpf_iter_link_info linfo;
0726     __u32 expected_val = 0;
0727     struct bpf_link *link;
0728     struct key_t {
0729         int a;
0730         int b;
0731         int c;
0732     } key;
0733     char buf[64];
0734     void *val;
0735 
0736     skel = bpf_iter_bpf_percpu_hash_map__open();
0737     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_percpu_hash_map__open"))
0738         return;
0739 
0740     skel->rodata->num_cpus = bpf_num_possible_cpus();
0741     val = malloc(8 * bpf_num_possible_cpus());
0742 
0743     err = bpf_iter_bpf_percpu_hash_map__load(skel);
0744     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_percpu_hash_map__load"))
0745         goto out;
0746 
0747     /* update map values here */
0748     map_fd = bpf_map__fd(skel->maps.hashmap1);
0749     for (i = 0; i < bpf_map__max_entries(skel->maps.hashmap1); i++) {
0750         key.a = i + 1;
0751         key.b = i + 2;
0752         key.c = i + 3;
0753         expected_key_a += key.a;
0754         expected_key_b += key.b;
0755 
0756         for (j = 0; j < bpf_num_possible_cpus(); j++) {
0757             *(__u32 *)(val + j * 8) = i + j;
0758             expected_val += i + j;
0759         }
0760 
0761         err = bpf_map_update_elem(map_fd, &key, val, BPF_ANY);
0762         if (!ASSERT_OK(err, "map_update"))
0763             goto out;
0764     }
0765 
0766     memset(&linfo, 0, sizeof(linfo));
0767     linfo.map.map_fd = map_fd;
0768     opts.link_info = &linfo;
0769     opts.link_info_len = sizeof(linfo);
0770     link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_hash_map, &opts);
0771     if (!ASSERT_OK_PTR(link, "attach_iter"))
0772         goto out;
0773 
0774     iter_fd = bpf_iter_create(bpf_link__fd(link));
0775     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0776         goto free_link;
0777 
0778     /* do some tests */
0779     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0780         ;
0781     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
0782         goto close_iter;
0783 
0784     /* test results */
0785     if (!ASSERT_EQ(skel->bss->key_sum_a, expected_key_a, "key_sum_a"))
0786         goto close_iter;
0787     if (!ASSERT_EQ(skel->bss->key_sum_b, expected_key_b, "key_sum_b"))
0788         goto close_iter;
0789     if (!ASSERT_EQ(skel->bss->val_sum, expected_val, "val_sum"))
0790         goto close_iter;
0791 
0792 close_iter:
0793     close(iter_fd);
0794 free_link:
0795     bpf_link__destroy(link);
0796 out:
0797     bpf_iter_bpf_percpu_hash_map__destroy(skel);
0798     free(val);
0799 }
0800 
0801 static void test_bpf_array_map(void)
0802 {
0803     __u64 val, expected_val = 0, res_first_val, first_val = 0;
0804     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0805     __u32 expected_key = 0, res_first_key;
0806     struct bpf_iter_bpf_array_map *skel;
0807     union bpf_iter_link_info linfo;
0808     int err, i, map_fd, iter_fd;
0809     struct bpf_link *link;
0810     char buf[64] = {};
0811     int len, start;
0812 
0813     skel = bpf_iter_bpf_array_map__open_and_load();
0814     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_array_map__open_and_load"))
0815         return;
0816 
0817     map_fd = bpf_map__fd(skel->maps.arraymap1);
0818     for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
0819         val = i + 4;
0820         expected_key += i;
0821         expected_val += val;
0822 
0823         if (i == 0)
0824             first_val = val;
0825 
0826         err = bpf_map_update_elem(map_fd, &i, &val, BPF_ANY);
0827         if (!ASSERT_OK(err, "map_update"))
0828             goto out;
0829     }
0830 
0831     memset(&linfo, 0, sizeof(linfo));
0832     linfo.map.map_fd = map_fd;
0833     opts.link_info = &linfo;
0834     opts.link_info_len = sizeof(linfo);
0835     link = bpf_program__attach_iter(skel->progs.dump_bpf_array_map, &opts);
0836     if (!ASSERT_OK_PTR(link, "attach_iter"))
0837         goto out;
0838 
0839     iter_fd = bpf_iter_create(bpf_link__fd(link));
0840     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0841         goto free_link;
0842 
0843     /* do some tests */
0844     start = 0;
0845     while ((len = read(iter_fd, buf + start, sizeof(buf) - start)) > 0)
0846         start += len;
0847     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
0848         goto close_iter;
0849 
0850     /* test results */
0851     res_first_key = *(__u32 *)buf;
0852     res_first_val = *(__u64 *)(buf + sizeof(__u32));
0853     if (CHECK(res_first_key != 0 || res_first_val != first_val,
0854           "bpf_seq_write",
0855           "seq_write failure: first key %u vs expected 0, "
0856           " first value %llu vs expected %llu\n",
0857           res_first_key, res_first_val, first_val))
0858         goto close_iter;
0859 
0860     if (!ASSERT_EQ(skel->bss->key_sum, expected_key, "key_sum"))
0861         goto close_iter;
0862     if (!ASSERT_EQ(skel->bss->val_sum, expected_val, "val_sum"))
0863         goto close_iter;
0864 
0865     for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
0866         err = bpf_map_lookup_elem(map_fd, &i, &val);
0867         if (!ASSERT_OK(err, "map_lookup"))
0868             goto out;
0869         if (!ASSERT_EQ(i, val, "invalid_val"))
0870             goto out;
0871     }
0872 
0873 close_iter:
0874     close(iter_fd);
0875 free_link:
0876     bpf_link__destroy(link);
0877 out:
0878     bpf_iter_bpf_array_map__destroy(skel);
0879 }
0880 
0881 static void test_bpf_array_map_iter_fd(void)
0882 {
0883     struct bpf_iter_bpf_array_map *skel;
0884 
0885     skel = bpf_iter_bpf_array_map__open_and_load();
0886     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_array_map__open_and_load"))
0887         return;
0888 
0889     do_read_map_iter_fd(&skel->skeleton, skel->progs.dump_bpf_array_map,
0890                 skel->maps.arraymap1);
0891 
0892     bpf_iter_bpf_array_map__destroy(skel);
0893 }
0894 
0895 static void test_bpf_percpu_array_map(void)
0896 {
0897     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0898     struct bpf_iter_bpf_percpu_array_map *skel;
0899     __u32 expected_key = 0, expected_val = 0;
0900     union bpf_iter_link_info linfo;
0901     int err, i, j, map_fd, iter_fd;
0902     struct bpf_link *link;
0903     char buf[64];
0904     void *val;
0905     int len;
0906 
0907     skel = bpf_iter_bpf_percpu_array_map__open();
0908     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_percpu_array_map__open"))
0909         return;
0910 
0911     skel->rodata->num_cpus = bpf_num_possible_cpus();
0912     val = malloc(8 * bpf_num_possible_cpus());
0913 
0914     err = bpf_iter_bpf_percpu_array_map__load(skel);
0915     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_percpu_array_map__load"))
0916         goto out;
0917 
0918     /* update map values here */
0919     map_fd = bpf_map__fd(skel->maps.arraymap1);
0920     for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
0921         expected_key += i;
0922 
0923         for (j = 0; j < bpf_num_possible_cpus(); j++) {
0924             *(__u32 *)(val + j * 8) = i + j;
0925             expected_val += i + j;
0926         }
0927 
0928         err = bpf_map_update_elem(map_fd, &i, val, BPF_ANY);
0929         if (!ASSERT_OK(err, "map_update"))
0930             goto out;
0931     }
0932 
0933     memset(&linfo, 0, sizeof(linfo));
0934     linfo.map.map_fd = map_fd;
0935     opts.link_info = &linfo;
0936     opts.link_info_len = sizeof(linfo);
0937     link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_array_map, &opts);
0938     if (!ASSERT_OK_PTR(link, "attach_iter"))
0939         goto out;
0940 
0941     iter_fd = bpf_iter_create(bpf_link__fd(link));
0942     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
0943         goto free_link;
0944 
0945     /* do some tests */
0946     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0947         ;
0948     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
0949         goto close_iter;
0950 
0951     /* test results */
0952     if (!ASSERT_EQ(skel->bss->key_sum, expected_key, "key_sum"))
0953         goto close_iter;
0954     if (!ASSERT_EQ(skel->bss->val_sum, expected_val, "val_sum"))
0955         goto close_iter;
0956 
0957 close_iter:
0958     close(iter_fd);
0959 free_link:
0960     bpf_link__destroy(link);
0961 out:
0962     bpf_iter_bpf_percpu_array_map__destroy(skel);
0963     free(val);
0964 }
0965 
0966 /* An iterator program deletes all local storage in a map. */
0967 static void test_bpf_sk_storage_delete(void)
0968 {
0969     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0970     struct bpf_iter_bpf_sk_storage_helpers *skel;
0971     union bpf_iter_link_info linfo;
0972     int err, len, map_fd, iter_fd;
0973     struct bpf_link *link;
0974     int sock_fd = -1;
0975     __u32 val = 42;
0976     char buf[64];
0977 
0978     skel = bpf_iter_bpf_sk_storage_helpers__open_and_load();
0979     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_sk_storage_helpers__open_and_load"))
0980         return;
0981 
0982     map_fd = bpf_map__fd(skel->maps.sk_stg_map);
0983 
0984     sock_fd = socket(AF_INET6, SOCK_STREAM, 0);
0985     if (!ASSERT_GE(sock_fd, 0, "socket"))
0986         goto out;
0987     err = bpf_map_update_elem(map_fd, &sock_fd, &val, BPF_NOEXIST);
0988     if (!ASSERT_OK(err, "map_update"))
0989         goto out;
0990 
0991     memset(&linfo, 0, sizeof(linfo));
0992     linfo.map.map_fd = map_fd;
0993     opts.link_info = &linfo;
0994     opts.link_info_len = sizeof(linfo);
0995     link = bpf_program__attach_iter(skel->progs.delete_bpf_sk_storage_map,
0996                     &opts);
0997     if (!ASSERT_OK_PTR(link, "attach_iter"))
0998         goto out;
0999 
1000     iter_fd = bpf_iter_create(bpf_link__fd(link));
1001     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
1002         goto free_link;
1003 
1004     /* do some tests */
1005     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
1006         ;
1007     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
1008         goto close_iter;
1009 
1010     /* test results */
1011     err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);
1012     if (CHECK(!err || errno != ENOENT, "bpf_map_lookup_elem",
1013           "map value wasn't deleted (err=%d, errno=%d)\n", err, errno))
1014         goto close_iter;
1015 
1016 close_iter:
1017     close(iter_fd);
1018 free_link:
1019     bpf_link__destroy(link);
1020 out:
1021     if (sock_fd >= 0)
1022         close(sock_fd);
1023     bpf_iter_bpf_sk_storage_helpers__destroy(skel);
1024 }
1025 
1026 /* This creates a socket and its local storage. It then runs a task_iter BPF
1027  * program that replaces the existing socket local storage with the tgid of the
1028  * only task owning a file descriptor to this socket, this process, prog_tests.
1029  * It then runs a tcp socket iterator that negates the value in the existing
1030  * socket local storage, the test verifies that the resulting value is -pid.
1031  */
1032 static void test_bpf_sk_storage_get(void)
1033 {
1034     struct bpf_iter_bpf_sk_storage_helpers *skel;
1035     int err, map_fd, val = -1;
1036     int sock_fd = -1;
1037 
1038     skel = bpf_iter_bpf_sk_storage_helpers__open_and_load();
1039     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_sk_storage_helpers__open_and_load"))
1040         return;
1041 
1042     sock_fd = socket(AF_INET6, SOCK_STREAM, 0);
1043     if (!ASSERT_GE(sock_fd, 0, "socket"))
1044         goto out;
1045 
1046     err = listen(sock_fd, 1);
1047     if (!ASSERT_OK(err, "listen"))
1048         goto close_socket;
1049 
1050     map_fd = bpf_map__fd(skel->maps.sk_stg_map);
1051 
1052     err = bpf_map_update_elem(map_fd, &sock_fd, &val, BPF_NOEXIST);
1053     if (!ASSERT_OK(err, "bpf_map_update_elem"))
1054         goto close_socket;
1055 
1056     do_dummy_read(skel->progs.fill_socket_owner);
1057 
1058     err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);
1059     if (CHECK(err || val != getpid(), "bpf_map_lookup_elem",
1060         "map value wasn't set correctly (expected %d, got %d, err=%d)\n",
1061         getpid(), val, err))
1062         goto close_socket;
1063 
1064     do_dummy_read(skel->progs.negate_socket_local_storage);
1065 
1066     err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);
1067     CHECK(err || val != -getpid(), "bpf_map_lookup_elem",
1068           "map value wasn't set correctly (expected %d, got %d, err=%d)\n",
1069           -getpid(), val, err);
1070 
1071 close_socket:
1072     close(sock_fd);
1073 out:
1074     bpf_iter_bpf_sk_storage_helpers__destroy(skel);
1075 }
1076 
1077 static void test_bpf_sk_stoarge_map_iter_fd(void)
1078 {
1079     struct bpf_iter_bpf_sk_storage_map *skel;
1080 
1081     skel = bpf_iter_bpf_sk_storage_map__open_and_load();
1082     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_sk_storage_map__open_and_load"))
1083         return;
1084 
1085     do_read_map_iter_fd(&skel->skeleton, skel->progs.rw_bpf_sk_storage_map,
1086                 skel->maps.sk_stg_map);
1087 
1088     bpf_iter_bpf_sk_storage_map__destroy(skel);
1089 }
1090 
1091 static void test_bpf_sk_storage_map(void)
1092 {
1093     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
1094     int err, i, len, map_fd, iter_fd, num_sockets;
1095     struct bpf_iter_bpf_sk_storage_map *skel;
1096     union bpf_iter_link_info linfo;
1097     int sock_fd[3] = {-1, -1, -1};
1098     __u32 val, expected_val = 0;
1099     struct bpf_link *link;
1100     char buf[64];
1101 
1102     skel = bpf_iter_bpf_sk_storage_map__open_and_load();
1103     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_sk_storage_map__open_and_load"))
1104         return;
1105 
1106     map_fd = bpf_map__fd(skel->maps.sk_stg_map);
1107     num_sockets = ARRAY_SIZE(sock_fd);
1108     for (i = 0; i < num_sockets; i++) {
1109         sock_fd[i] = socket(AF_INET6, SOCK_STREAM, 0);
1110         if (!ASSERT_GE(sock_fd[i], 0, "socket"))
1111             goto out;
1112 
1113         val = i + 1;
1114         expected_val += val;
1115 
1116         err = bpf_map_update_elem(map_fd, &sock_fd[i], &val,
1117                       BPF_NOEXIST);
1118         if (!ASSERT_OK(err, "map_update"))
1119             goto out;
1120     }
1121 
1122     memset(&linfo, 0, sizeof(linfo));
1123     linfo.map.map_fd = map_fd;
1124     opts.link_info = &linfo;
1125     opts.link_info_len = sizeof(linfo);
1126     link = bpf_program__attach_iter(skel->progs.oob_write_bpf_sk_storage_map, &opts);
1127     err = libbpf_get_error(link);
1128     if (!ASSERT_EQ(err, -EACCES, "attach_oob_write_iter")) {
1129         if (!err)
1130             bpf_link__destroy(link);
1131         goto out;
1132     }
1133 
1134     link = bpf_program__attach_iter(skel->progs.rw_bpf_sk_storage_map, &opts);
1135     if (!ASSERT_OK_PTR(link, "attach_iter"))
1136         goto out;
1137 
1138     iter_fd = bpf_iter_create(bpf_link__fd(link));
1139     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
1140         goto free_link;
1141 
1142     skel->bss->to_add_val = time(NULL);
1143     /* do some tests */
1144     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
1145         ;
1146     if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
1147         goto close_iter;
1148 
1149     /* test results */
1150     if (!ASSERT_EQ(skel->bss->ipv6_sk_count, num_sockets, "ipv6_sk_count"))
1151         goto close_iter;
1152 
1153     if (!ASSERT_EQ(skel->bss->val_sum, expected_val, "val_sum"))
1154         goto close_iter;
1155 
1156     for (i = 0; i < num_sockets; i++) {
1157         err = bpf_map_lookup_elem(map_fd, &sock_fd[i], &val);
1158         if (!ASSERT_OK(err, "map_lookup") ||
1159             !ASSERT_EQ(val, i + 1 + skel->bss->to_add_val, "check_map_value"))
1160             break;
1161     }
1162 
1163 close_iter:
1164     close(iter_fd);
1165 free_link:
1166     bpf_link__destroy(link);
1167 out:
1168     for (i = 0; i < num_sockets; i++) {
1169         if (sock_fd[i] >= 0)
1170             close(sock_fd[i]);
1171     }
1172     bpf_iter_bpf_sk_storage_map__destroy(skel);
1173 }
1174 
1175 static void test_rdonly_buf_out_of_bound(void)
1176 {
1177     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
1178     struct bpf_iter_test_kern5 *skel;
1179     union bpf_iter_link_info linfo;
1180     struct bpf_link *link;
1181 
1182     skel = bpf_iter_test_kern5__open_and_load();
1183     if (!ASSERT_OK_PTR(skel, "bpf_iter_test_kern5__open_and_load"))
1184         return;
1185 
1186     memset(&linfo, 0, sizeof(linfo));
1187     linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap1);
1188     opts.link_info = &linfo;
1189     opts.link_info_len = sizeof(linfo);
1190     link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
1191     if (!ASSERT_ERR_PTR(link, "attach_iter"))
1192         bpf_link__destroy(link);
1193 
1194     bpf_iter_test_kern5__destroy(skel);
1195 }
1196 
1197 static void test_buf_neg_offset(void)
1198 {
1199     struct bpf_iter_test_kern6 *skel;
1200 
1201     skel = bpf_iter_test_kern6__open_and_load();
1202     if (!ASSERT_ERR_PTR(skel, "bpf_iter_test_kern6__open_and_load"))
1203         bpf_iter_test_kern6__destroy(skel);
1204 }
1205 
1206 static void test_link_iter(void)
1207 {
1208     struct bpf_iter_bpf_link *skel;
1209 
1210     skel = bpf_iter_bpf_link__open_and_load();
1211     if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_link__open_and_load"))
1212         return;
1213 
1214     do_dummy_read(skel->progs.dump_bpf_link);
1215 
1216     bpf_iter_bpf_link__destroy(skel);
1217 }
1218 
1219 static void test_ksym_iter(void)
1220 {
1221     struct bpf_iter_ksym *skel;
1222 
1223     skel = bpf_iter_ksym__open_and_load();
1224     if (!ASSERT_OK_PTR(skel, "bpf_iter_ksym__open_and_load"))
1225         return;
1226 
1227     do_dummy_read(skel->progs.dump_ksym);
1228 
1229     bpf_iter_ksym__destroy(skel);
1230 }
1231 
1232 #define CMP_BUFFER_SIZE 1024
1233 static char task_vma_output[CMP_BUFFER_SIZE];
1234 static char proc_maps_output[CMP_BUFFER_SIZE];
1235 
1236 /* remove \0 and \t from str, and only keep the first line */
1237 static void str_strip_first_line(char *str)
1238 {
1239     char *dst = str, *src = str;
1240 
1241     do {
1242         if (*src == ' ' || *src == '\t')
1243             src++;
1244         else
1245             *(dst++) = *(src++);
1246 
1247     } while (*src != '\0' && *src != '\n');
1248 
1249     *dst = '\0';
1250 }
1251 
1252 static void test_task_vma(void)
1253 {
1254     int err, iter_fd = -1, proc_maps_fd = -1;
1255     struct bpf_iter_task_vma *skel;
1256     int len, read_size = 4;
1257     char maps_path[64];
1258 
1259     skel = bpf_iter_task_vma__open();
1260     if (!ASSERT_OK_PTR(skel, "bpf_iter_task_vma__open"))
1261         return;
1262 
1263     skel->bss->pid = getpid();
1264 
1265     err = bpf_iter_task_vma__load(skel);
1266     if (!ASSERT_OK(err, "bpf_iter_task_vma__load"))
1267         goto out;
1268 
1269     skel->links.proc_maps = bpf_program__attach_iter(
1270         skel->progs.proc_maps, NULL);
1271 
1272     if (!ASSERT_OK_PTR(skel->links.proc_maps, "bpf_program__attach_iter")) {
1273         skel->links.proc_maps = NULL;
1274         goto out;
1275     }
1276 
1277     iter_fd = bpf_iter_create(bpf_link__fd(skel->links.proc_maps));
1278     if (!ASSERT_GE(iter_fd, 0, "create_iter"))
1279         goto out;
1280 
1281     /* Read CMP_BUFFER_SIZE (1kB) from bpf_iter. Read in small chunks
1282      * to trigger seq_file corner cases.
1283      */
1284     len = 0;
1285     while (len < CMP_BUFFER_SIZE) {
1286         err = read_fd_into_buffer(iter_fd, task_vma_output + len,
1287                       MIN(read_size, CMP_BUFFER_SIZE - len));
1288         if (!err)
1289             break;
1290         if (!ASSERT_GE(err, 0, "read_iter_fd"))
1291             goto out;
1292         len += err;
1293     }
1294 
1295     /* read CMP_BUFFER_SIZE (1kB) from /proc/pid/maps */
1296     snprintf(maps_path, 64, "/proc/%u/maps", skel->bss->pid);
1297     proc_maps_fd = open(maps_path, O_RDONLY);
1298     if (!ASSERT_GE(proc_maps_fd, 0, "open_proc_maps"))
1299         goto out;
1300     err = read_fd_into_buffer(proc_maps_fd, proc_maps_output, CMP_BUFFER_SIZE);
1301     if (!ASSERT_GE(err, 0, "read_prog_maps_fd"))
1302         goto out;
1303 
1304     /* strip and compare the first line of the two files */
1305     str_strip_first_line(task_vma_output);
1306     str_strip_first_line(proc_maps_output);
1307 
1308     ASSERT_STREQ(task_vma_output, proc_maps_output, "compare_output");
1309 out:
1310     close(proc_maps_fd);
1311     close(iter_fd);
1312     bpf_iter_task_vma__destroy(skel);
1313 }
1314 
1315 void test_bpf_sockmap_map_iter_fd(void)
1316 {
1317     struct bpf_iter_sockmap *skel;
1318 
1319     skel = bpf_iter_sockmap__open_and_load();
1320     if (!ASSERT_OK_PTR(skel, "bpf_iter_sockmap__open_and_load"))
1321         return;
1322 
1323     do_read_map_iter_fd(&skel->skeleton, skel->progs.copy, skel->maps.sockmap);
1324 
1325     bpf_iter_sockmap__destroy(skel);
1326 }
1327 
1328 void test_bpf_iter(void)
1329 {
1330     if (test__start_subtest("btf_id_or_null"))
1331         test_btf_id_or_null();
1332     if (test__start_subtest("ipv6_route"))
1333         test_ipv6_route();
1334     if (test__start_subtest("netlink"))
1335         test_netlink();
1336     if (test__start_subtest("bpf_map"))
1337         test_bpf_map();
1338     if (test__start_subtest("task"))
1339         test_task();
1340     if (test__start_subtest("task_sleepable"))
1341         test_task_sleepable();
1342     if (test__start_subtest("task_stack"))
1343         test_task_stack();
1344     if (test__start_subtest("task_file"))
1345         test_task_file();
1346     if (test__start_subtest("task_vma"))
1347         test_task_vma();
1348     if (test__start_subtest("task_btf"))
1349         test_task_btf();
1350     if (test__start_subtest("tcp4"))
1351         test_tcp4();
1352     if (test__start_subtest("tcp6"))
1353         test_tcp6();
1354     if (test__start_subtest("udp4"))
1355         test_udp4();
1356     if (test__start_subtest("udp6"))
1357         test_udp6();
1358     if (test__start_subtest("unix"))
1359         test_unix();
1360     if (test__start_subtest("anon"))
1361         test_anon_iter(false);
1362     if (test__start_subtest("anon-read-one-char"))
1363         test_anon_iter(true);
1364     if (test__start_subtest("file"))
1365         test_file_iter();
1366     if (test__start_subtest("overflow"))
1367         test_overflow(false, false);
1368     if (test__start_subtest("overflow-e2big"))
1369         test_overflow(true, false);
1370     if (test__start_subtest("prog-ret-1"))
1371         test_overflow(false, true);
1372     if (test__start_subtest("bpf_hash_map"))
1373         test_bpf_hash_map();
1374     if (test__start_subtest("bpf_percpu_hash_map"))
1375         test_bpf_percpu_hash_map();
1376     if (test__start_subtest("bpf_array_map"))
1377         test_bpf_array_map();
1378     if (test__start_subtest("bpf_array_map_iter_fd"))
1379         test_bpf_array_map_iter_fd();
1380     if (test__start_subtest("bpf_percpu_array_map"))
1381         test_bpf_percpu_array_map();
1382     if (test__start_subtest("bpf_sk_storage_map"))
1383         test_bpf_sk_storage_map();
1384     if (test__start_subtest("bpf_sk_storage_map_iter_fd"))
1385         test_bpf_sk_stoarge_map_iter_fd();
1386     if (test__start_subtest("bpf_sk_storage_delete"))
1387         test_bpf_sk_storage_delete();
1388     if (test__start_subtest("bpf_sk_storage_get"))
1389         test_bpf_sk_storage_get();
1390     if (test__start_subtest("rdonly-buf-out-of-bound"))
1391         test_rdonly_buf_out_of_bound();
1392     if (test__start_subtest("buf-neg-offset"))
1393         test_buf_neg_offset();
1394     if (test__start_subtest("link-iter"))
1395         test_link_iter();
1396     if (test__start_subtest("ksym"))
1397         test_ksym_iter();
1398     if (test__start_subtest("bpf_sockmap_map_iter_fd"))
1399         test_bpf_sockmap_map_iter_fd();
1400 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!