Commit e3dd4082 authored by Hou Tao's avatar Hou Tao Committed by Alexei Starovoitov
Browse files

selftests/bpf: Test outer map update operations in syscall program 



Syscall program is running with rcu_read_lock_trace being held, so if
bpf_map_update_elem() or bpf_map_delete_elem() invokes
synchronize_rcu_tasks_trace() when operating on an outer map, there will
be dead-lock, so add a test to guarantee that it is dead-lock free.

Signed-off-by: default avatarHou Tao <houtao1@huawei.com>
Link: https://lore.kernel.org/r/20231204140425.1480317-8-houtao@huaweicloud.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 1624918b

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

+28 −2
Original line number Diff line number Diff line
@@ -12,7 +12,7 @@ struct args { 
	int btf_fd;

};



void test_syscall(void)

static void test_syscall_load_prog(void)

{

	static char verifier_log[8192];

	struct args ctx = {
@@ -32,7 +32,7 @@ void test_syscall(void) 
	if (!ASSERT_OK_PTR(skel, "skel_load"))

		goto cleanup;



	prog_fd = bpf_program__fd(skel->progs.bpf_prog);

	prog_fd = bpf_program__fd(skel->progs.load_prog);

	err = bpf_prog_test_run_opts(prog_fd, &tattr);

	ASSERT_EQ(err, 0, "err");

	ASSERT_EQ(tattr.retval, 1, "retval");
@@ -53,3 +53,29 @@ void test_syscall(void) 
	if (ctx.btf_fd > 0)

		close(ctx.btf_fd);

}



static void test_syscall_update_outer_map(void)

{

	LIBBPF_OPTS(bpf_test_run_opts, opts);

	struct syscall *skel;

	int err, prog_fd;



	skel = syscall__open_and_load();

	if (!ASSERT_OK_PTR(skel, "skel_load"))

		goto cleanup;



	prog_fd = bpf_program__fd(skel->progs.update_outer_map);

	err = bpf_prog_test_run_opts(prog_fd, &opts);

	ASSERT_EQ(err, 0, "err");

	ASSERT_EQ(opts.retval, 1, "retval");

cleanup:

	syscall__destroy(skel);

}



void test_syscall(void)

{

	if (test__start_subtest("load_prog"))

		test_syscall_load_prog();

	if (test__start_subtest("update_outer_map"))

		test_syscall_update_outer_map();

}

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

+91 −5
Original line number Diff line number Diff line
@@ -6,9 +6,15 @@ 
#include <bpf/bpf_tracing.h>

#include <../../../tools/include/linux/filter.h>

#include <linux/btf.h>

#include <string.h>

#include <errno.h>



char _license[] SEC("license") = "GPL";



struct bpf_map {

	int id;

}  __attribute__((preserve_access_index));



struct args {

	__u64 log_buf;

	__u32 log_size;
@@ -27,6 +33,37 @@ struct args { 
	BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz), \

	BTF_INT_ENC(encoding, bits_offset, bits)



struct {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__type(key, int);

	__type(value, union bpf_attr);

	__uint(max_entries, 1);

} bpf_attr_array SEC(".maps");



struct inner_map_type {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__uint(key_size, 4);

	__uint(value_size, 4);

	__uint(max_entries, 1);

} inner_map SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);

	__type(key, int);

	__type(value, int);

	__uint(max_entries, 1);

	__array(values, struct inner_map_type);

} outer_array_map SEC(".maps") = {

	.values = {

		[0] = &inner_map,

	},

};



static inline __u64 ptr_to_u64(const void *ptr)

{

	return (__u64) (unsigned long) ptr;

}



static int btf_load(void)

{

	struct btf_blob {
@@ -58,7 +95,7 @@ static int btf_load(void) 
}



SEC("syscall")

int bpf_prog(struct args *ctx)

int load_prog(struct args *ctx)

{

	static char license[] = "GPL";

	static struct bpf_insn insns[] = {
@@ -94,8 +131,8 @@ int bpf_prog(struct args *ctx) 
	map_create_attr.max_entries = ctx->max_entries;

	map_create_attr.btf_fd = ret;



	prog_load_attr.license = (long) license;

	prog_load_attr.insns = (long) insns;

	prog_load_attr.license = ptr_to_u64(license);

	prog_load_attr.insns = ptr_to_u64(insns);

	prog_load_attr.log_buf = ctx->log_buf;

	prog_load_attr.log_size = ctx->log_size;

	prog_load_attr.log_level = 1;
@@ -107,8 +144,8 @@ int bpf_prog(struct args *ctx) 
	insns[3].imm = ret;



	map_update_attr.map_fd = ret;

	map_update_attr.key = (long) &key;

	map_update_attr.value = (long) &value;

	map_update_attr.key = ptr_to_u64(&key);

	map_update_attr.value = ptr_to_u64(&value);

	ret = bpf_sys_bpf(BPF_MAP_UPDATE_ELEM, &map_update_attr, sizeof(map_update_attr));

	if (ret < 0)

		return ret;
@@ -119,3 +156,52 @@ int bpf_prog(struct args *ctx) 
	ctx->prog_fd = ret;

	return 1;

}



SEC("syscall")

int update_outer_map(void *ctx)

{

	int zero = 0, ret = 0, outer_fd = -1, inner_fd = -1, err;

	const int attr_sz = sizeof(union bpf_attr);

	union bpf_attr *attr;



	attr = bpf_map_lookup_elem((struct bpf_map *)&bpf_attr_array, &zero);

	if (!attr)

		goto out;



	memset(attr, 0, attr_sz);

	attr->map_id = ((struct bpf_map *)&outer_array_map)->id;

	outer_fd = bpf_sys_bpf(BPF_MAP_GET_FD_BY_ID, attr, attr_sz);

	if (outer_fd < 0)

		goto out;



	memset(attr, 0, attr_sz);

	attr->map_type = BPF_MAP_TYPE_ARRAY;

	attr->key_size = 4;

	attr->value_size = 4;

	attr->max_entries = 1;

	inner_fd = bpf_sys_bpf(BPF_MAP_CREATE, attr, attr_sz);

	if (inner_fd < 0)

		goto out;



	memset(attr, 0, attr_sz);

	attr->map_fd = outer_fd;

	attr->key = ptr_to_u64(&zero);

	attr->value = ptr_to_u64(&inner_fd);

	err = bpf_sys_bpf(BPF_MAP_UPDATE_ELEM, attr, attr_sz);

	if (err)

		goto out;



	memset(attr, 0, attr_sz);

	attr->map_fd = outer_fd;

	attr->key = ptr_to_u64(&zero);

	err = bpf_sys_bpf(BPF_MAP_DELETE_ELEM, attr, attr_sz);

	if (err)

		goto out;

	ret = 1;

out:

	if (inner_fd >= 0)

		bpf_sys_close(inner_fd);

	if (outer_fd >= 0)

		bpf_sys_close(outer_fd);

	return ret;

}