selftests/bpf: Add C tests for kptr

This uses the __kptr and __kptr_ref macros as well, and tries to test
the stuff that is supposed to work, since we have negative tests in
test_verifier suite. Also include some code to test map-in-map support,
such that the inner_map_meta matches the kptr_off_tab of map added as
element.

Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220424214901.2743946-12-memxor@gmail.com

diff --git a/tools/testing/selftests/bpf/prog_tests/map_kptr.c b/tools/testing/selftests/bpf/prog_tests/map_kptr.c
new file mode 100644 (file)
index 0000000..9e2fbda
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/map_kptr.c
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <test_progs.h>
+
+#include "map_kptr.skel.h"
+
+void test_map_kptr(void)
+{
+       struct map_kptr *skel;
+       int key = 0, ret;
+       char buf[24];
+
+       skel = map_kptr__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "map_kptr__open_and_load"))
+               return;
+
+       ret = bpf_map_update_elem(bpf_map__fd(skel->maps.array_map), &key, buf, 0);
+       ASSERT_OK(ret, "array_map update");
+       ret = bpf_map_update_elem(bpf_map__fd(skel->maps.array_map), &key, buf, 0);
+       ASSERT_OK(ret, "array_map update2");
+
+       ret = bpf_map_update_elem(bpf_map__fd(skel->maps.hash_map), &key, buf, 0);
+       ASSERT_OK(ret, "hash_map update");
+       ret = bpf_map_delete_elem(bpf_map__fd(skel->maps.hash_map), &key);
+       ASSERT_OK(ret, "hash_map delete");
+
+       ret = bpf_map_update_elem(bpf_map__fd(skel->maps.hash_malloc_map), &key, buf, 0);
+       ASSERT_OK(ret, "hash_malloc_map update");
+       ret = bpf_map_delete_elem(bpf_map__fd(skel->maps.hash_malloc_map), &key);
+       ASSERT_OK(ret, "hash_malloc_map delete");
+
+       ret = bpf_map_update_elem(bpf_map__fd(skel->maps.lru_hash_map), &key, buf, 0);
+       ASSERT_OK(ret, "lru_hash_map update");
+       ret = bpf_map_delete_elem(bpf_map__fd(skel->maps.lru_hash_map), &key);
+       ASSERT_OK(ret, "lru_hash_map delete");
+
+       map_kptr__destroy(skel);
+}

diff --git a/tools/testing/selftests/bpf/progs/map_kptr.c b/tools/testing/selftests/bpf/progs/map_kptr.c
new file mode 100644 (file)
index 0000000..1b0e040
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/map_kptr.c
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <vmlinux.h>
+#include <bpf/bpf_tracing.h>
+#include <bpf/bpf_helpers.h>
+
+struct map_value {
+       struct prog_test_ref_kfunc __kptr *unref_ptr;
+       struct prog_test_ref_kfunc __kptr_ref *ref_ptr;
+};
+
+struct array_map {
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __type(key, int);
+       __type(value, struct map_value);
+       __uint(max_entries, 1);
+} array_map SEC(".maps");
+
+struct hash_map {
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __type(key, int);
+       __type(value, struct map_value);
+       __uint(max_entries, 1);
+} hash_map SEC(".maps");
+
+struct hash_malloc_map {
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __type(key, int);
+       __type(value, struct map_value);
+       __uint(max_entries, 1);
+       __uint(map_flags, BPF_F_NO_PREALLOC);
+} hash_malloc_map SEC(".maps");
+
+struct lru_hash_map {
+       __uint(type, BPF_MAP_TYPE_LRU_HASH);
+       __type(key, int);
+       __type(value, struct map_value);
+       __uint(max_entries, 1);
+} lru_hash_map SEC(".maps");
+
+#define DEFINE_MAP_OF_MAP(map_type, inner_map_type, name)       \
+       struct {                                                \
+               __uint(type, map_type);                         \
+               __uint(max_entries, 1);                         \
+               __uint(key_size, sizeof(int));                  \
+               __uint(value_size, sizeof(int));                \
+               __array(values, struct inner_map_type);         \
+       } name SEC(".maps") = {                                 \
+               .values = { [0] = &inner_map_type },            \
+       }
+
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_ARRAY_OF_MAPS, array_map, array_of_array_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_ARRAY_OF_MAPS, hash_map, array_of_hash_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_ARRAY_OF_MAPS, hash_malloc_map, array_of_hash_malloc_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_ARRAY_OF_MAPS, lru_hash_map, array_of_lru_hash_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_HASH_OF_MAPS, array_map, hash_of_array_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_HASH_OF_MAPS, hash_map, hash_of_hash_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_HASH_OF_MAPS, hash_malloc_map, hash_of_hash_malloc_maps);
+DEFINE_MAP_OF_MAP(BPF_MAP_TYPE_HASH_OF_MAPS, lru_hash_map, hash_of_lru_hash_maps);
+
+extern struct prog_test_ref_kfunc *bpf_kfunc_call_test_acquire(unsigned long *sp) __ksym;
+extern struct prog_test_ref_kfunc *
+bpf_kfunc_call_test_kptr_get(struct prog_test_ref_kfunc **p, int a, int b) __ksym;
+extern void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p) __ksym;
+
+static void test_kptr_unref(struct map_value *v)
+{
+       struct prog_test_ref_kfunc *p;
+
+       p = v->unref_ptr;
+       /* store untrusted_ptr_or_null_ */
+       v->unref_ptr = p;
+       if (!p)
+               return;
+       if (p->a + p->b > 100)
+               return;
+       /* store untrusted_ptr_ */
+       v->unref_ptr = p;
+       /* store NULL */
+       v->unref_ptr = NULL;
+}
+
+static void test_kptr_ref(struct map_value *v)
+{
+       struct prog_test_ref_kfunc *p;
+
+       p = v->ref_ptr;
+       /* store ptr_or_null_ */
+       v->unref_ptr = p;
+       if (!p)
+               return;
+       if (p->a + p->b > 100)
+               return;
+       /* store NULL */
+       p = bpf_kptr_xchg(&v->ref_ptr, NULL);
+       if (!p)
+               return;
+       if (p->a + p->b > 100) {
+               bpf_kfunc_call_test_release(p);
+               return;
+       }
+       /* store ptr_ */
+       v->unref_ptr = p;
+       bpf_kfunc_call_test_release(p);
+
+       p = bpf_kfunc_call_test_acquire(&(unsigned long){0});
+       if (!p)
+               return;
+       /* store ptr_ */
+       p = bpf_kptr_xchg(&v->ref_ptr, p);
+       if (!p)
+               return;
+       if (p->a + p->b > 100) {
+               bpf_kfunc_call_test_release(p);
+               return;
+       }
+       bpf_kfunc_call_test_release(p);
+}
+
+static void test_kptr_get(struct map_value *v)
+{
+       struct prog_test_ref_kfunc *p;
+
+       p = bpf_kfunc_call_test_kptr_get(&v->ref_ptr, 0, 0);
+       if (!p)
+               return;
+       if (p->a + p->b > 100) {
+               bpf_kfunc_call_test_release(p);
+               return;
+       }
+       bpf_kfunc_call_test_release(p);
+}
+
+static void test_kptr(struct map_value *v)
+{
+       test_kptr_unref(v);
+       test_kptr_ref(v);
+       test_kptr_get(v);
+}
+
+SEC("tc")
+int test_map_kptr(struct __sk_buff *ctx)
+{
+       struct map_value *v;
+       int i, key = 0;
+
+#define TEST(map)                                      \
+       v = bpf_map_lookup_elem(&map, &key);            \
+       if (!v)                                         \
+               return 0;                               \
+       test_kptr(v)
+
+       TEST(array_map);
+       TEST(hash_map);
+       TEST(hash_malloc_map);
+       TEST(lru_hash_map);
+
+#undef TEST
+       return 0;
+}
+
+SEC("tc")
+int test_map_in_map_kptr(struct __sk_buff *ctx)
+{
+       struct map_value *v;
+       int i, key = 0;
+       void *map;
+
+#define TEST(map_in_map)                                \
+       map = bpf_map_lookup_elem(&map_in_map, &key);   \
+       if (!map)                                       \
+               return 0;                               \
+       v = bpf_map_lookup_elem(map, &key);             \
+       if (!v)                                         \
+               return 0;                               \
+       test_kptr(v)
+
+       TEST(array_of_array_maps);
+       TEST(array_of_hash_maps);
+       TEST(array_of_hash_malloc_maps);
+       TEST(array_of_lru_hash_maps);
+       TEST(hash_of_array_maps);
+       TEST(hash_of_hash_maps);
+       TEST(hash_of_hash_malloc_maps);
+       TEST(hash_of_lru_hash_maps);
+
+#undef TEST
+       return 0;
+}
+
+char _license[] SEC("license") = "GPL";