selftests/bpf: Add test for bpf array map iterators

Two subtests are added.
  $ ./test_progs -n 4
  ...
  #4/20 bpf_array_map:OK
  #4/21 bpf_percpu_array_map:OK
  ...

The bpf_array_map subtest also tested bpf program
changing array element values and send key/value
to user space through bpf_seq_write() interface.

Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200723184121.591367-1-yhs@fb.com

diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
index 72790b600c62ce24ea05367f7fc18a07eb855aee..4a02b2222a6d03cbc604a6ec40919d975f7448c6 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
@@ -17,6 +17,8 @@
 #include "bpf_iter_test_kern4.skel.h"
 #include "bpf_iter_bpf_hash_map.skel.h"
 #include "bpf_iter_bpf_percpu_hash_map.skel.h"
+#include "bpf_iter_bpf_array_map.skel.h"
+#include "bpf_iter_bpf_percpu_array_map.skel.h"
 
 static int duration;
 
@@ -638,6 +640,161 @@ out:
        bpf_iter_bpf_percpu_hash_map__destroy(skel);
 }
 
+static void test_bpf_array_map(void)
+{
+       __u64 val, expected_val = 0, res_first_val, first_val = 0;
+       DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
+       __u32 expected_key = 0, res_first_key;
+       struct bpf_iter_bpf_array_map *skel;
+       int err, i, map_fd, iter_fd;
+       struct bpf_link *link;
+       char buf[64] = {};
+       int len, start;
+
+       skel = bpf_iter_bpf_array_map__open_and_load();
+       if (CHECK(!skel, "bpf_iter_bpf_array_map__open_and_load",
+                 "skeleton open_and_load failed\n"))
+               return;
+
+       map_fd = bpf_map__fd(skel->maps.arraymap1);
+       for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
+               val = i + 4;
+               expected_key += i;
+               expected_val += val;
+
+               if (i == 0)
+                       first_val = val;
+
+               err = bpf_map_update_elem(map_fd, &i, &val, BPF_ANY);
+               if (CHECK(err, "map_update", "map_update failed\n"))
+                       goto out;
+       }
+
+       opts.map_fd = map_fd;
+       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;
+
+       iter_fd = bpf_iter_create(bpf_link__fd(link));
+       if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))
+               goto free_link;
+
+       /* do some tests */
+       start = 0;
+       while ((len = read(iter_fd, buf + start, sizeof(buf) - start)) > 0)
+               start += len;
+       if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
+               goto close_iter;
+
+       /* test results */
+       res_first_key = *(__u32 *)buf;
+       res_first_val = *(__u64 *)(buf + sizeof(__u32));
+       if (CHECK(res_first_key != 0 || res_first_val != first_val,
+                 "bpf_seq_write",
+                 "seq_write failure: first key %u vs expected 0, "
+                 " first value %llu vs expected %llu\n",
+                 res_first_key, res_first_val, first_val))
+               goto close_iter;
+
+       if (CHECK(skel->bss->key_sum != expected_key,
+                 "key_sum", "got %u expected %u\n",
+                 skel->bss->key_sum, expected_key))
+               goto close_iter;
+       if (CHECK(skel->bss->val_sum != expected_val,
+                 "val_sum", "got %llu expected %llu\n",
+                 skel->bss->val_sum, expected_val))
+               goto close_iter;
+
+       for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
+               err = bpf_map_lookup_elem(map_fd, &i, &val);
+               if (CHECK(err, "map_lookup", "map_lookup failed\n"))
+                       goto out;
+               if (CHECK(i != val, "invalid_val",
+                         "got value %llu expected %u\n", val, i))
+                       goto out;
+       }
+
+close_iter:
+       close(iter_fd);
+free_link:
+       bpf_link__destroy(link);
+out:
+       bpf_iter_bpf_array_map__destroy(skel);
+}
+
+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;
+       int err, i, j, map_fd, iter_fd;
+       struct bpf_link *link;
+       char buf[64];
+       void *val;
+       int len;
+
+       val = malloc(8 * bpf_num_possible_cpus());
+
+       skel = bpf_iter_bpf_percpu_array_map__open();
+       if (CHECK(!skel, "bpf_iter_bpf_percpu_array_map__open",
+                 "skeleton open failed\n"))
+               return;
+
+       skel->rodata->num_cpus = bpf_num_possible_cpus();
+
+       err = bpf_iter_bpf_percpu_array_map__load(skel);
+       if (CHECK(!skel, "bpf_iter_bpf_percpu_array_map__load",
+                 "skeleton load failed\n"))
+               goto out;
+
+       /* update map values here */
+       map_fd = bpf_map__fd(skel->maps.arraymap1);
+       for (i = 0; i < bpf_map__max_entries(skel->maps.arraymap1); i++) {
+               expected_key += i;
+
+               for (j = 0; j < bpf_num_possible_cpus(); j++) {
+                       *(__u32 *)(val + j * 8) = i + j;
+                       expected_val += i + j;
+               }
+
+               err = bpf_map_update_elem(map_fd, &i, val, BPF_ANY);
+               if (CHECK(err, "map_update", "map_update failed\n"))
+                       goto out;
+       }
+
+       opts.map_fd = map_fd;
+       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;
+
+       iter_fd = bpf_iter_create(bpf_link__fd(link));
+       if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))
+               goto free_link;
+
+       /* do some tests */
+       while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
+               ;
+       if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))
+               goto close_iter;
+
+       /* test results */
+       if (CHECK(skel->bss->key_sum != expected_key,
+                 "key_sum", "got %u expected %u\n",
+                 skel->bss->key_sum, expected_key))
+               goto close_iter;
+       if (CHECK(skel->bss->val_sum != expected_val,
+                 "val_sum", "got %u expected %u\n",
+                 skel->bss->val_sum, expected_val))
+               goto close_iter;
+
+close_iter:
+       close(iter_fd);
+free_link:
+       bpf_link__destroy(link);
+out:
+       bpf_iter_bpf_percpu_array_map__destroy(skel);
+}
+
 void test_bpf_iter(void)
 {
        if (test__start_subtest("btf_id_or_null"))
@@ -678,4 +835,8 @@ void test_bpf_iter(void)
                test_bpf_hash_map();
        if (test__start_subtest("bpf_percpu_hash_map"))
                test_bpf_percpu_hash_map();
+       if (test__start_subtest("bpf_array_map"))
+               test_bpf_array_map();
+       if (test__start_subtest("bpf_percpu_array_map"))
+               test_bpf_percpu_array_map();
 }

diff --git a/tools/testing/selftests/bpf/progs/bpf_iter_bpf_array_map.c b/tools/testing/selftests/bpf/progs/bpf_iter_bpf_array_map.c
new file mode 100644 (file)
index 0000000..6286023
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/bpf_iter_bpf_array_map.c
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2020 Facebook */
+#include "bpf_iter.h"
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+char _license[] SEC("license") = "GPL";
+
+struct key_t {
+       int a;
+       int b;
+       int c;
+};
+
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 3);
+       __type(key, __u32);
+       __type(value, __u64);
+} arraymap1 SEC(".maps");
+
+__u32 key_sum = 0;
+__u64 val_sum = 0;
+
+SEC("iter/bpf_map_elem")
+int dump_bpf_array_map(struct bpf_iter__bpf_map_elem *ctx)
+{
+       __u32 *key = ctx->key;
+       __u64 *val = ctx->value;
+
+       if (key == (void *)0 || val == (void *)0)
+               return 0;
+
+       bpf_seq_write(ctx->meta->seq, key, sizeof(__u32));
+       bpf_seq_write(ctx->meta->seq, val, sizeof(__u64));
+       key_sum += *key;
+       val_sum += *val;
+       *val = *key;
+       return 0;
+}

diff --git a/tools/testing/selftests/bpf/progs/bpf_iter_bpf_percpu_array_map.c b/tools/testing/selftests/bpf/progs/bpf_iter_bpf_percpu_array_map.c
new file mode 100644 (file)
index 0000000..85fa710
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/bpf_iter_bpf_percpu_array_map.c
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2020 Facebook */
+#include "bpf_iter.h"
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+char _license[] SEC("license") = "GPL";
+
+struct key_t {
+       int a;
+       int b;
+       int c;
+};
+
+struct {
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, 3);
+       __type(key, __u32);
+       __type(value, __u32);
+} arraymap1 SEC(".maps");
+
+/* will set before prog run */
+volatile const __u32 num_cpus = 0;
+
+__u32 key_sum = 0, val_sum = 0;
+
+SEC("iter/bpf_map_elem")
+int dump_bpf_percpu_array_map(struct bpf_iter__bpf_map_elem *ctx)
+{
+       __u32 *key = ctx->key;
+       void *pptr = ctx->value;
+       __u32 step;
+       int i;
+
+       if (key == (void *)0 || pptr == (void *)0)
+               return 0;
+
+       key_sum += *key;
+
+       step = 8;
+       for (i = 0; i < num_cpus; i++) {
+               val_sum += *(__u32 *)pptr;
+               pptr += step;
+       }
+       return 0;
+}