bpf, selftests: Add test for different array inner map size

Extend the "diff_size" subtest to also include a non-inlined array map variant
where dynamic inner #elems are possible.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Yonghong Song <yhs@fb.com>
Link: https://lore.kernel.org/bpf/20201010234006.7075-5-daniel@iogearbox.net

diff --git a/tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c b/tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c
index 540fea4..76ebe4c 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c
@@ -55,10 +55,10 @@ static int kern_sync_rcu(void)
 
 static void test_lookup_update(void)
 {
-       int err, key = 0, val, i;
+       int map1_fd, map2_fd, map3_fd, map4_fd, map5_fd, map1_id, map2_id;
+       int outer_arr_fd, outer_hash_fd, outer_arr_dyn_fd;
        struct test_btf_map_in_map *skel;
-       int outer_arr_fd, outer_hash_fd;
-       int fd, map1_fd, map2_fd, map1_id, map2_id;
+       int err, key = 0, val, i, fd;
 
        skel = test_btf_map_in_map__open_and_load();
        if (CHECK(!skel, "skel_open", "failed to open&load skeleton\n"))
@@ -70,32 +70,45 @@ static void test_lookup_update(void)
 
        map1_fd = bpf_map__fd(skel->maps.inner_map1);
        map2_fd = bpf_map__fd(skel->maps.inner_map2);
+       map3_fd = bpf_map__fd(skel->maps.inner_map3);
+       map4_fd = bpf_map__fd(skel->maps.inner_map4);
+       map5_fd = bpf_map__fd(skel->maps.inner_map5);
+       outer_arr_dyn_fd = bpf_map__fd(skel->maps.outer_arr_dyn);
        outer_arr_fd = bpf_map__fd(skel->maps.outer_arr);
        outer_hash_fd = bpf_map__fd(skel->maps.outer_hash);
 
-       /* inner1 = input, inner2 = input + 1 */
-       map1_fd = bpf_map__fd(skel->maps.inner_map1);
+       /* inner1 = input, inner2 = input + 1, inner3 = input + 2 */
        bpf_map_update_elem(outer_arr_fd, &key, &map1_fd, 0);
-       map2_fd = bpf_map__fd(skel->maps.inner_map2);
        bpf_map_update_elem(outer_hash_fd, &key, &map2_fd, 0);
+       bpf_map_update_elem(outer_arr_dyn_fd, &key, &map3_fd, 0);
        skel->bss->input = 1;
        usleep(1);
-
        bpf_map_lookup_elem(map1_fd, &key, &val);
        CHECK(val != 1, "inner1", "got %d != exp %d\n", val, 1);
        bpf_map_lookup_elem(map2_fd, &key, &val);
        CHECK(val != 2, "inner2", "got %d != exp %d\n", val, 2);
+       bpf_map_lookup_elem(map3_fd, &key, &val);
+       CHECK(val != 3, "inner3", "got %d != exp %d\n", val, 3);
 
-       /* inner1 = input + 1, inner2 = input */
+       /* inner2 = input, inner1 = input + 1, inner4 = input + 2 */
        bpf_map_update_elem(outer_arr_fd, &key, &map2_fd, 0);
        bpf_map_update_elem(outer_hash_fd, &key, &map1_fd, 0);
+       bpf_map_update_elem(outer_arr_dyn_fd, &key, &map4_fd, 0);
        skel->bss->input = 3;
        usleep(1);
-
        bpf_map_lookup_elem(map1_fd, &key, &val);
        CHECK(val != 4, "inner1", "got %d != exp %d\n", val, 4);
        bpf_map_lookup_elem(map2_fd, &key, &val);
        CHECK(val != 3, "inner2", "got %d != exp %d\n", val, 3);
+       bpf_map_lookup_elem(map4_fd, &key, &val);
+       CHECK(val != 5, "inner4", "got %d != exp %d\n", val, 5);
+
+       /* inner5 = input + 2 */
+       bpf_map_update_elem(outer_arr_dyn_fd, &key, &map5_fd, 0);
+       skel->bss->input = 5;
+       usleep(1);
+       bpf_map_lookup_elem(map5_fd, &key, &val);
+       CHECK(val != 7, "inner5", "got %d != exp %d\n", val, 7);
 
        for (i = 0; i < 5; i++) {
                val = i % 2 ? map1_fd : map2_fd;
@@ -106,7 +119,13 @@ static void test_lookup_update(void)
                }
                err = bpf_map_update_elem(outer_arr_fd, &key, &val, 0);
                if (CHECK_FAIL(err)) {
-                       printf("failed to update hash_of_maps on iter #%d\n", i);
+                       printf("failed to update array_of_maps on iter #%d\n", i);
+                       goto cleanup;
+               }
+               val = i % 2 ? map4_fd : map5_fd;
+               err = bpf_map_update_elem(outer_arr_dyn_fd, &key, &val, 0);
+               if (CHECK_FAIL(err)) {
+                       printf("failed to update array_of_maps (dyn) on iter #%d\n", i);
                        goto cleanup;
                }
        }

diff --git a/tools/testing/selftests/bpf/progs/test_btf_map_in_map.c b/tools/testing/selftests/bpf/progs/test_btf_map_in_map.c
index 193fe01..c1e0c8c 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_btf_map_in_map.c
+++ b/tools/testing/selftests/bpf/progs/test_btf_map_in_map.c
@@ -41,6 +41,43 @@ struct outer_arr {
        .values = { (void *)&inner_map1, 0, (void *)&inner_map2 },
 };
 
+struct inner_map_sz3 {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(map_flags, BPF_F_INNER_MAP);
+       __uint(max_entries, 3);
+       __type(key, int);
+       __type(value, int);
+} inner_map3 SEC(".maps"),
+  inner_map4 SEC(".maps");
+
+struct inner_map_sz4 {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(map_flags, BPF_F_INNER_MAP);
+       __uint(max_entries, 5);
+       __type(key, int);
+       __type(value, int);
+} inner_map5 SEC(".maps");
+
+struct outer_arr_dyn {
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __uint(max_entries, 3);
+       __uint(key_size, sizeof(int));
+       __uint(value_size, sizeof(int));
+       __array(values, struct {
+               __uint(type, BPF_MAP_TYPE_ARRAY);
+               __uint(map_flags, BPF_F_INNER_MAP);
+               __uint(max_entries, 1);
+               __type(key, int);
+               __type(value, int);
+       });
+} outer_arr_dyn SEC(".maps") = {
+       .values = {
+               [0] = (void *)&inner_map3,
+               [1] = (void *)&inner_map4,
+               [2] = (void *)&inner_map5,
+       },
+};
+
 struct outer_hash {
        __uint(type, BPF_MAP_TYPE_HASH_OF_MAPS);
        __uint(max_entries, 5);
@@ -101,6 +138,12 @@ int handle__sys_enter(void *ctx)
        val = input + 1;
        bpf_map_update_elem(inner_map, &key, &val, 0);
 
+       inner_map = bpf_map_lookup_elem(&outer_arr_dyn, &key);
+       if (!inner_map)
+               return 1;
+       val = input + 2;
+       bpf_map_update_elem(inner_map, &key, &val, 0);
+
        return 0;
 }