Commit 2cbc469a authored by Kumar Kartikeya Dwivedi's avatar Kumar Kartikeya Dwivedi Committed by Alexei Starovoitov
Browse files

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: default avatarKumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220424214901.2743946-12-memxor@gmail.com
parent ef89654f

tools/testing/selftests/bpf/prog_tests/map_kptr.c

0 → 100644
+37 −0
Original line number Diff line number Diff line 
// 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);

}

tools/testing/selftests/bpf/progs/map_kptr.c

0 → 100644
+190 −0
Original line number Diff line number Diff line 
// 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";