selftests/bpf: Add a test for mmap-able map in map

Regular BPF hash map is not mmap-able from user space. However, map-in-map
with outer map of type BPF_MAP_TYPE_HASH_OF_MAPS and mmap-able array as
inner map can perform similar operations as a mmap-able hash map. This
can be used by applications that benefit from fast accesses to some local
data.

Add a selftest to show this use case.

Signed-off-by: Song Liu <song@kernel.org>
Link: https://lore.kernel.org/r/20240723051455.1589192-1-song@kernel.org
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c b/tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c
new file mode 100644 (file)
index 0000000..ce74577
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
+#include <test_progs.h>
+#include <sys/mman.h>
+#include "mmap_inner_array.skel.h"
+
+void test_mmap_inner_array(void)
+{
+       const long page_size = sysconf(_SC_PAGE_SIZE);
+       struct mmap_inner_array *skel;
+       int inner_array_fd, err;
+       void *tmp;
+       __u64 *val;
+
+       skel = mmap_inner_array__open_and_load();
+
+       if (!ASSERT_OK_PTR(skel, "open_and_load"))
+               return;
+
+       inner_array_fd = bpf_map__fd(skel->maps.inner_array);
+       tmp = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, inner_array_fd, 0);
+       if (!ASSERT_OK_PTR(tmp, "inner array mmap"))
+               goto out;
+       val = (void *)tmp;
+
+       err = mmap_inner_array__attach(skel);
+       if (!ASSERT_OK(err, "attach"))
+               goto out_unmap;
+
+       skel->bss->pid = getpid();
+       usleep(1);
+
+       /* pid is set, pid_match == true and outer_map_match == false */
+       ASSERT_TRUE(skel->bss->pid_match, "pid match 1");
+       ASSERT_FALSE(skel->bss->outer_map_match, "outer map match 1");
+       ASSERT_FALSE(skel->bss->done, "done 1");
+       ASSERT_EQ(*val, 0, "value match 1");
+
+       err = bpf_map__update_elem(skel->maps.outer_map,
+                                  &skel->bss->pid, sizeof(skel->bss->pid),
+                                  &inner_array_fd, sizeof(inner_array_fd),
+                                  BPF_ANY);
+       if (!ASSERT_OK(err, "update elem"))
+               goto out_unmap;
+       usleep(1);
+
+       /* outer map key is set, outer_map_match == true */
+       ASSERT_TRUE(skel->bss->pid_match, "pid match 2");
+       ASSERT_TRUE(skel->bss->outer_map_match, "outer map match 2");
+       ASSERT_TRUE(skel->bss->done, "done 2");
+       ASSERT_EQ(*val, skel->data->match_value, "value match 2");
+
+out_unmap:
+       munmap(tmp, page_size);
+out:
+       mmap_inner_array__destroy(skel);
+}

diff --git a/tools/testing/selftests/bpf/progs/mmap_inner_array.c b/tools/testing/selftests/bpf/progs/mmap_inner_array.c
new file mode 100644 (file)
index 0000000..90aacbc
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/mmap_inner_array.c
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+
+#include "bpf_misc.h"
+
+char _license[] SEC("license") = "GPL";
+
+struct inner_array_type {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(map_flags, BPF_F_MMAPABLE);
+       __type(key, __u32);
+       __type(value, __u64);
+       __uint(max_entries, 1);
+} inner_array SEC(".maps");
+
+struct {
+       __uint(type, BPF_MAP_TYPE_HASH_OF_MAPS);
+       __uint(key_size, 4);
+       __uint(value_size, 4);
+       __uint(max_entries, 1);
+       __array(values, struct inner_array_type);
+} outer_map SEC(".maps");
+
+int pid = 0;
+__u64 match_value = 0x13572468;
+bool done = false;
+bool pid_match = false;
+bool outer_map_match = false;
+
+SEC("fentry/" SYS_PREFIX "sys_nanosleep")
+int add_to_list_in_inner_array(void *ctx)
+{
+       __u32 curr_pid, zero = 0;
+       struct bpf_map *map;
+       __u64 *value;
+
+       curr_pid = (u32)bpf_get_current_pid_tgid();
+       if (done || curr_pid != pid)
+               return 0;
+
+       pid_match = true;
+       map = bpf_map_lookup_elem(&outer_map, &curr_pid);
+       if (!map)
+               return 0;
+
+       outer_map_match = true;
+       value = bpf_map_lookup_elem(map, &zero);
+       if (!value)
+               return 0;
+
+       *value = match_value;
+       done = true;
+       return 0;
+}