tools/bpf: Support new uapi for map element bpf iterator

Previous commit adjusted kernel uapi for map
element bpf iterator. This patch adjusted libbpf API
due to uapi change. bpftool and bpf_iter selftests
are also changed accordingly.

Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Andrii Nakryiko <andriin@fb.com>
Acked-by: John Fastabend <john.fastabend@gmail.com>
Link: https://lore.kernel.org/bpf/20200805055058.1457623-1-yhs@fb.com

diff --git a/tools/bpf/bpftool/iter.c b/tools/bpf/bpftool/iter.c
index c9dba75..3b1aad7 100644 (file)
--- a/tools/bpf/bpftool/iter.c
+++ b/tools/bpf/bpftool/iter.c
@@ -11,6 +11,7 @@
 static int do_pin(int argc, char **argv)
 {
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, iter_opts);
+       union bpf_iter_link_info linfo;
        const char *objfile, *path;
        struct bpf_program *prog;
        struct bpf_object *obj;
@@ -36,6 +37,11 @@ static int do_pin(int argc, char **argv)
                        map_fd = map_parse_fd(&argc, &argv);
                        if (map_fd < 0)
                                return -1;
+
+                       memset(&linfo, 0, sizeof(linfo));
+                       linfo.map.map_fd = map_fd;
+                       iter_opts.link_info = &linfo;
+                       iter_opts.link_info_len = sizeof(linfo);
                }
        }
 
@@ -57,9 +63,6 @@ static int do_pin(int argc, char **argv)
                goto close_obj;
        }
 
-       if (map_fd >= 0)
-               iter_opts.map_fd = map_fd;
-
        link = bpf_program__attach_iter(prog, &iter_opts);
        if (IS_ERR(link)) {
                err = PTR_ERR(link);

diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index b134e67..0480f89 100644 (file)
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -81,6 +81,12 @@ struct bpf_cgroup_storage_key {
        __u32   attach_type;            /* program attach type */
 };
 
+union bpf_iter_link_info {
+       struct {
+               __u32   map_fd;
+       } map;
+};
+
 /* BPF syscall commands, see bpf(2) man-page for details. */
 enum bpf_cmd {
        BPF_MAP_CREATE,
@@ -249,13 +255,6 @@ enum bpf_link_type {
        MAX_BPF_LINK_TYPE,
 };
 
-enum bpf_iter_link_info {
-       BPF_ITER_LINK_UNSPEC = 0,
-       BPF_ITER_LINK_MAP_FD = 1,
-
-       MAX_BPF_ITER_LINK_INFO,
-};
-
 /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command
  *
  * NONE(default): No further bpf programs allowed in the subtree.
@@ -623,6 +622,8 @@ union bpf_attr {
                };
                __u32           attach_type;    /* attach type */
                __u32           flags;          /* extra flags */
+               __aligned_u64   iter_info;      /* extra bpf_iter_link_info */
+               __u32           iter_info_len;  /* iter_info length */
        } link_create;
 
        struct { /* struct used by BPF_LINK_UPDATE command */

diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index eab14c9..0750681 100644 (file)
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -599,6 +599,9 @@ int bpf_link_create(int prog_fd, int target_fd,
        attr.link_create.target_fd = target_fd;
        attr.link_create.attach_type = attach_type;
        attr.link_create.flags = OPTS_GET(opts, flags, 0);
+       attr.link_create.iter_info =
+               ptr_to_u64(OPTS_GET(opts, iter_info, (void *)0));
+       attr.link_create.iter_info_len = OPTS_GET(opts, iter_info_len, 0);
 
        return sys_bpf(BPF_LINK_CREATE, &attr, sizeof(attr));
 }

diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index 28855fd..015d13f 100644 (file)
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -168,11 +168,14 @@ LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
 LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
                                enum bpf_attach_type type);
 
+union bpf_iter_link_info; /* defined in up-to-date linux/bpf.h */
 struct bpf_link_create_opts {
        size_t sz; /* size of this struct for forward/backward compatibility */
        __u32 flags;
+       union bpf_iter_link_info *iter_info;
+       __u32 iter_info_len;
 };
-#define bpf_link_create_opts__last_field flags
+#define bpf_link_create_opts__last_field iter_info_len
 
 LIBBPF_API int bpf_link_create(int prog_fd, int target_fd,
                               enum bpf_attach_type attach_type,

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 7be04e4..0a06124 100644 (file)
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -8306,10 +8306,8 @@ bpf_program__attach_iter(struct bpf_program *prog,
        if (!OPTS_VALID(opts, bpf_iter_attach_opts))
                return ERR_PTR(-EINVAL);
 
-       if (OPTS_HAS(opts, map_fd)) {
-               target_fd = opts->map_fd;
-               link_create_opts.flags = BPF_ITER_LINK_MAP_FD;
-       }
+       link_create_opts.iter_info = OPTS_GET(opts, link_info, (void *)0);
+       link_create_opts.iter_info_len = OPTS_GET(opts, link_info_len, 0);
 
        prog_fd = bpf_program__fd(prog);
        if (prog_fd < 0) {

diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index 3ed1399..5ecb406 100644 (file)
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -267,9 +267,10 @@ LIBBPF_API struct bpf_link *bpf_map__attach_struct_ops(struct bpf_map *map);
 
 struct bpf_iter_attach_opts {
        size_t sz; /* size of this struct for forward/backward compatibility */
-       __u32 map_fd;
+       union bpf_iter_link_info *link_info;
+       __u32 link_info_len;
 };
-#define bpf_iter_attach_opts__last_field map_fd
+#define bpf_iter_attach_opts__last_field link_info_len
 
 LIBBPF_API struct bpf_link *
 bpf_program__attach_iter(struct bpf_program *prog,

diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
index 4ffefdc..7375d9a 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
@@ -468,6 +468,7 @@ static void test_bpf_hash_map(void)
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        struct bpf_iter_bpf_hash_map *skel;
        int err, i, len, map_fd, iter_fd;
+       union bpf_iter_link_info linfo;
        __u64 val, expected_val = 0;
        struct bpf_link *link;
        struct key_t {
@@ -490,13 +491,16 @@ static void test_bpf_hash_map(void)
                goto out;
 
        /* iterator with hashmap2 and hashmap3 should fail */
-       opts.map_fd = bpf_map__fd(skel->maps.hashmap2);
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap2);
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
        if (CHECK(!IS_ERR(link), "attach_iter",
                  "attach_iter for hashmap2 unexpected succeeded\n"))
                goto out;
 
-       opts.map_fd = bpf_map__fd(skel->maps.hashmap3);
+       linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap3);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
        if (CHECK(!IS_ERR(link), "attach_iter",
                  "attach_iter for hashmap3 unexpected succeeded\n"))
@@ -519,7 +523,7 @@ static void test_bpf_hash_map(void)
                        goto out;
        }
 
-       opts.map_fd = map_fd;
+       linfo.map.map_fd = map_fd;
        link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
        if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
                goto out;
@@ -562,6 +566,7 @@ static void test_bpf_percpu_hash_map(void)
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        struct bpf_iter_bpf_percpu_hash_map *skel;
        int err, i, j, len, map_fd, iter_fd;
+       union bpf_iter_link_info linfo;
        __u32 expected_val = 0;
        struct bpf_link *link;
        struct key_t {
@@ -606,7 +611,10 @@ static void test_bpf_percpu_hash_map(void)
                        goto out;
        }
 
-       opts.map_fd = map_fd;
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = map_fd;
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_hash_map, &opts);
        if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
                goto out;
@@ -649,6 +657,7 @@ static void test_bpf_array_map(void)
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        __u32 expected_key = 0, res_first_key;
        struct bpf_iter_bpf_array_map *skel;
+       union bpf_iter_link_info linfo;
        int err, i, map_fd, iter_fd;
        struct bpf_link *link;
        char buf[64] = {};
@@ -673,7 +682,10 @@ static void test_bpf_array_map(void)
                        goto out;
        }
 
-       opts.map_fd = map_fd;
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = map_fd;
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_array_map, &opts);
        if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
                goto out;
@@ -730,6 +742,7 @@ static void test_bpf_percpu_array_map(void)
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        struct bpf_iter_bpf_percpu_array_map *skel;
        __u32 expected_key = 0, expected_val = 0;
+       union bpf_iter_link_info linfo;
        int err, i, j, map_fd, iter_fd;
        struct bpf_link *link;
        char buf[64];
@@ -765,7 +778,10 @@ static void test_bpf_percpu_array_map(void)
                        goto out;
        }
 
-       opts.map_fd = map_fd;
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = map_fd;
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_array_map, &opts);
        if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
                goto out;
@@ -803,6 +819,7 @@ static void test_bpf_sk_storage_map(void)
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        int err, i, len, map_fd, iter_fd, num_sockets;
        struct bpf_iter_bpf_sk_storage_map *skel;
+       union bpf_iter_link_info linfo;
        int sock_fd[3] = {-1, -1, -1};
        __u32 val, expected_val = 0;
        struct bpf_link *link;
@@ -829,7 +846,10 @@ static void test_bpf_sk_storage_map(void)
                        goto out;
        }
 
-       opts.map_fd = map_fd;
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = map_fd;
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_sk_storage_map, &opts);
        if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
                goto out;
@@ -871,6 +891,7 @@ static void test_rdonly_buf_out_of_bound(void)
 {
        DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
        struct bpf_iter_test_kern5 *skel;
+       union bpf_iter_link_info linfo;
        struct bpf_link *link;
 
        skel = bpf_iter_test_kern5__open_and_load();
@@ -878,7 +899,10 @@ static void test_rdonly_buf_out_of_bound(void)
                  "skeleton open_and_load failed\n"))
                return;
 
-       opts.map_fd = bpf_map__fd(skel->maps.hashmap1);
+       memset(&linfo, 0, sizeof(linfo));
+       linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap1);
+       opts.link_info = &linfo;
+       opts.link_info_len = sizeof(linfo);
        link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
        if (CHECK(!IS_ERR(link), "attach_iter", "unexpected success\n"))
                bpf_link__destroy(link);