selftests: bpf: test batch lookup on array of maps with holes

Iterating through array of maps may encounter non existing keys. The
batch operation should not fail on when this happens.

Signed-off-by: Yan Zhai <yan@cloudflare.com>
Acked-by: Hou Tao <houtao1@huawei.com>
Link: https://lore.kernel.org/r/9007237b9606dc2ee44465a4447fe46e13f3bea6.1739171594.git.yan@cloudflare.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/map_tests/map_in_map_batch_ops.c b/tools/testing/selftests/bpf/map_tests/map_in_map_batch_ops.c
index 66191ae9863c1d4589ecf367cc9bfa4eac54399d..79c3ccadb962289fa9a38ad04dd40f2c2e0f294f 100644 (file)
--- a/tools/testing/selftests/bpf/map_tests/map_in_map_batch_ops.c
+++ b/tools/testing/selftests/bpf/map_tests/map_in_map_batch_ops.c
@@ -120,11 +120,12 @@ static void validate_fetch_results(int outer_map_fd,
 
 static void fetch_and_validate(int outer_map_fd,
                               struct bpf_map_batch_opts *opts,
-                              __u32 batch_size, bool delete_entries)
+                              __u32 batch_size, bool delete_entries,
+                              bool has_holes)
 {
-       __u32 *fetched_keys, *fetched_values, total_fetched = 0;
-       __u32 batch_key = 0, fetch_count, step_size;
-       int err, max_entries = OUTER_MAP_ENTRIES;
+       int err, max_entries = OUTER_MAP_ENTRIES - !!has_holes;
+       __u32 *fetched_keys, *fetched_values, total_fetched = 0, i;
+       __u32 batch_key = 0, fetch_count, step_size = batch_size;
        __u32 value_size = sizeof(__u32);
 
        /* Total entries needs to be fetched */
@@ -134,9 +135,8 @@ static void fetch_and_validate(int outer_map_fd,
              "Memory allocation failed for fetched_keys or fetched_values",
              "error=%s\n", strerror(errno));
 
-       for (step_size = batch_size;
-            step_size <= max_entries;
-            step_size += batch_size) {
+       /* hash map may not always return full batch */
+       for (i = 0; i < OUTER_MAP_ENTRIES; i++) {
                fetch_count = step_size;
                err = delete_entries
                      ? bpf_map_lookup_and_delete_batch(outer_map_fd,
@@ -155,6 +155,7 @@ static void fetch_and_validate(int outer_map_fd,
                if (err && errno == ENOSPC) {
                        /* Fetch again with higher batch size */
                        total_fetched = 0;
+                       step_size += batch_size;
                        continue;
                }
 
@@ -184,18 +185,19 @@ static void fetch_and_validate(int outer_map_fd,
 }
 
 static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,
-                                 enum bpf_map_type inner_map_type)
+                                 enum bpf_map_type inner_map_type,
+                                 bool has_holes)
 {
+       __u32 max_entries = OUTER_MAP_ENTRIES - !!has_holes;
        __u32 *outer_map_keys, *inner_map_fds;
-       __u32 max_entries = OUTER_MAP_ENTRIES;
        LIBBPF_OPTS(bpf_map_batch_opts, opts);
        __u32 value_size = sizeof(__u32);
        int batch_size[2] = {5, 10};
        __u32 map_index, op_index;
        int outer_map_fd, ret;
 
-       outer_map_keys = calloc(max_entries, value_size);
-       inner_map_fds = calloc(max_entries, value_size);
+       outer_map_keys = calloc(OUTER_MAP_ENTRIES, value_size);
+       inner_map_fds = calloc(OUTER_MAP_ENTRIES, value_size);
        CHECK((!outer_map_keys || !inner_map_fds),
              "Memory allocation failed for outer_map_keys or inner_map_fds",
              "error=%s\n", strerror(errno));
@@ -209,6 +211,24 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,
                        ((outer_map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS)
                         ? 9 : 1000) - map_index;
 
+       /* This condition is only meaningful for array of maps.
+        *
+        * max_entries == OUTER_MAP_ENTRIES - 1 if it is true. Say
+        * max_entries is short for n, then outer_map_keys looks like:
+        *
+        *   [n, n-1, ... 2, 1]
+        *
+        * We change it to
+        *
+        *   [n, n-1, ... 2, 0]
+        *
+        * So it will leave key 1 as a hole. It will serve to test the
+        * correctness when batch on an array: a "non-exist" key might be
+        * actually allocated and returned from key iteration.
+        */
+       if (has_holes)
+               outer_map_keys[max_entries - 1]--;
+
        /* batch operation - map_update */
        ret = bpf_map_update_batch(outer_map_fd, outer_map_keys,
                                   inner_map_fds, &max_entries, &opts);
@@ -219,15 +239,17 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,
        /* batch operation - map_lookup */
        for (op_index = 0; op_index < 2; ++op_index)
                fetch_and_validate(outer_map_fd, &opts,
-                                  batch_size[op_index], false);
+                                  batch_size[op_index], false,
+                                  has_holes);
 
        /* batch operation - map_lookup_delete */
        if (outer_map_type == BPF_MAP_TYPE_HASH_OF_MAPS)
                fetch_and_validate(outer_map_fd, &opts,
-                                  max_entries, true /*delete*/);
+                                  max_entries, true /*delete*/,
+                                  has_holes);
 
        /* close all map fds */
-       for (map_index = 0; map_index < max_entries; map_index++)
+       for (map_index = 0; map_index < OUTER_MAP_ENTRIES; map_index++)
                close(inner_map_fds[map_index]);
        close(outer_map_fd);
 
@@ -237,16 +259,20 @@ static void _map_in_map_batch_ops(enum bpf_map_type outer_map_type,
 
 void test_map_in_map_batch_ops_array(void)
 {
-       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);
        printf("%s:PASS with inner ARRAY map\n", __func__);
-       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, false);
        printf("%s:PASS with inner HASH map\n", __func__);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_ARRAY, true);
+       printf("%s:PASS with inner ARRAY map with holes\n", __func__);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH, true);
+       printf("%s:PASS with inner HASH map with holes\n", __func__);
 }
 
 void test_map_in_map_batch_ops_hash(void)
 {
-       _map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_ARRAY);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_ARRAY, false);
        printf("%s:PASS with inner ARRAY map\n", __func__);
-       _map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_HASH);
+       _map_in_map_batch_ops(BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_HASH, false);
        printf("%s:PASS with inner HASH map\n", __func__);
 }