mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-30 22:26:55 +00:00
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
This commit is contained in:
Kumar Kartikeya Dwivedi
Alexei Starovoitov
parent
ef89654f2b
commit
2cbc469a6f
2 changed files with 227 additions and 0 deletions
37
tools/testing/selftests/bpf/prog_tests/map_kptr.c
Normal file
37
tools/testing/selftests/bpf/prog_tests/map_kptr.c
Normal file
|
|
@ -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);
|
||||
}
|
||||
190
tools/testing/selftests/bpf/progs/map_kptr.c
Normal file
190
tools/testing/selftests/bpf/progs/map_kptr.c
Normal file
|
|
@ -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";
|
||||
Loading…
Reference in a new issue