Follows the same logic as the hashtable tests.

Signed-off-by: Pedro Tammela <pctamm...@mojatatu.com>
---
 .../bpf/map_tests/array_map_batch_ops.c       | 104 +++++++++++++-----
 1 file changed, 75 insertions(+), 29 deletions(-)

diff --git a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c 
b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c
index e42ea1195d18..f4d870da7684 100644
--- a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c
+++ b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c
@@ -9,10 +9,13 @@
 
 #include <test_maps.h>
 
+static int nr_cpus;
+
 static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
-                            int *values)
+                            __s64 *values, bool is_pcpu)
 {
-       int i, err;
+       int i, j, err;
+       int cpu_offset = 0;
        DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
                .elem_flags = 0,
                .flags = 0,
@@ -20,22 +23,41 @@ static void map_batch_update(int map_fd, __u32 max_entries, 
int *keys,
 
        for (i = 0; i < max_entries; i++) {
                keys[i] = i;
-               values[i] = i + 1;
+               if (is_pcpu) {
+                       cpu_offset = i * nr_cpus;
+                       for (j = 0; j < nr_cpus; j++)
+                               (values + cpu_offset)[j] = i + 1 + j;
+               } else {
+                       values[i] = i + 1;
+               }
        }
 
        err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);
        CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
 }
 
-static void map_batch_verify(int *visited, __u32 max_entries,
-                            int *keys, int *values)
+static void map_batch_verify(int *visited, __u32 max_entries, int *keys,
+                            __s64 *values, bool is_pcpu)
 {
-       int i;
+       int i, j;
+       int cpu_offset = 0;
 
        memset(visited, 0, max_entries * sizeof(*visited));
        for (i = 0; i < max_entries; i++) {
-               CHECK(keys[i] + 1 != values[i], "key/value checking",
-                     "error: i %d key %d value %d\n", i, keys[i], values[i]);
+               if (is_pcpu) {
+                       cpu_offset = i * nr_cpus;
+                       for (j = 0; j < nr_cpus; j++) {
+                               __s64 value = (values + cpu_offset)[j];
+                               CHECK(keys[i] + j + 1 != value,
+                                     "key/value checking",
+                                     "error: i %d j %d key %d value %lld\n", i,
+                                     j, keys[i], value);
+                       }
+               } else {
+                       CHECK(keys[i] + 1 != values[i], "key/value checking",
+                             "error: i %d key %d value %lld\n", i, keys[i],
+                             values[i]);
+               }
                visited[i] = 1;
        }
        for (i = 0; i < max_entries; i++) {
@@ -44,19 +66,21 @@ static void map_batch_verify(int *visited, __u32 
max_entries,
        }
 }
 
-void test_array_map_batch_ops(void)
+static void __test_map_lookup_and_update_batch(bool is_pcpu)
 {
        struct bpf_create_map_attr xattr = {
                .name = "array_map",
-               .map_type = BPF_MAP_TYPE_ARRAY,
+               .map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY :
+                                     BPF_MAP_TYPE_ARRAY,
                .key_size = sizeof(int),
-               .value_size = sizeof(int),
+               .value_size = sizeof(__s64),
        };
-       int map_fd, *keys, *values, *visited;
+       int map_fd, *keys, *visited;
        __u32 count, total, total_success;
        const __u32 max_entries = 10;
        __u64 batch = 0;
-       int err, step;
+       int err, step, value_size;
+       void *values;
        DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
                .elem_flags = 0,
                .flags = 0,
@@ -67,22 +91,23 @@ void test_array_map_batch_ops(void)
        CHECK(map_fd == -1,
              "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
 
-       keys = malloc(max_entries * sizeof(int));
-       values = malloc(max_entries * sizeof(int));
-       visited = malloc(max_entries * sizeof(int));
+       value_size = sizeof(__s64);
+       if (is_pcpu)
+               value_size *= nr_cpus;
+
+       keys = calloc(max_entries, sizeof(*keys));
+       values = calloc(max_entries, value_size);
+       visited = calloc(max_entries, sizeof(*visited));
        CHECK(!keys || !values || !visited, "malloc()", "error:%s\n",
              strerror(errno));
 
-       /* populate elements to the map */
-       map_batch_update(map_fd, max_entries, keys, values);
-
        /* test 1: lookup in a loop with various steps. */
        total_success = 0;
        for (step = 1; step < max_entries; step++) {
-               map_batch_update(map_fd, max_entries, keys, values);
-               map_batch_verify(visited, max_entries, keys, values);
+               map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
+               map_batch_verify(visited, max_entries, keys, values, is_pcpu);
                memset(keys, 0, max_entries * sizeof(*keys));
-               memset(values, 0, max_entries * sizeof(*values));
+               memset(values, 0, max_entries * value_size);
                batch = 0;
                total = 0;
                /* iteratively lookup/delete elements with 'step'
@@ -91,10 +116,10 @@ void test_array_map_batch_ops(void)
                count = step;
                while (true) {
                        err = bpf_map_lookup_batch(map_fd,
-                                               total ? &batch : NULL, &batch,
-                                               keys + total,
-                                               values + total,
-                                               &count, &opts);
+                                                  total ? &batch : NULL,
+                                                  &batch, keys + total,
+                                                  values + total * value_size,
+                                                  &count, &opts);
 
                        CHECK((err && errno != ENOENT), "lookup with steps",
                              "error: %s\n", strerror(errno));
@@ -108,7 +133,7 @@ void test_array_map_batch_ops(void)
                CHECK(total != max_entries, "lookup with steps",
                      "total = %u, max_entries = %u\n", total, max_entries);
 
-               map_batch_verify(visited, max_entries, keys, values);
+               map_batch_verify(visited, max_entries, keys, values, is_pcpu);
 
                total_success++;
        }
@@ -116,9 +141,30 @@ void test_array_map_batch_ops(void)
        CHECK(total_success == 0, "check total_success",
              "unexpected failure\n");
 
-       printf("%s:PASS\n", __func__);
-
        free(keys);
        free(values);
        free(visited);
 }
+
+static void array_map_batch_ops(void)
+{
+       __test_map_lookup_and_update_batch(false);
+       printf("test_%s:PASS\n", __func__);
+}
+
+static void array_percpu_map_batch_ops(void)
+{
+       __test_map_lookup_and_update_batch(true);
+       printf("test_%s:PASS\n", __func__);
+}
+
+void test_array_map_batch_ops(void)
+{
+       nr_cpus = libbpf_num_possible_cpus();
+
+       CHECK(nr_cpus < 0, "nr_cpus checking",
+             "error: get possible cpus failed");
+
+       array_map_batch_ops();
+       array_percpu_map_batch_ops();
+}
-- 
2.25.1

Reply via email to