Commit 0e1bf9ed authored by Eduard Zingerman's avatar Eduard Zingerman Committed by Alexei Starovoitov
Browse files

selftests/bpf: BPF test_prog selftests for bpf_loop inlining 



Two new test BPF programs for test_prog selftests checking bpf_loop
behavior. Both are corner cases for bpf_loop inlinig transformation:
 - check that bpf_loop behaves correctly when callback function is not
   a compile time constant
 - check that local function variables are not affected by allocating
   additional stack storage for registers spilled by loop inlining

Signed-off-by: default avatarEduard Zingerman <eddyz87@gmail.com>
Acked-by: default avatarSong Liu <songliubraving@fb.com>
Link: https://lore.kernel.org/r/20220620235344.569325-6-eddyz87@gmail.com


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

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

+62 −0
Original line number Diff line number Diff line
@@ -120,6 +120,64 @@ static void check_nested_calls(struct bpf_loop *skel) 
	bpf_link__destroy(link);

}



static void check_non_constant_callback(struct bpf_loop *skel)

{

	struct bpf_link *link =

		bpf_program__attach(skel->progs.prog_non_constant_callback);



	if (!ASSERT_OK_PTR(link, "link"))

		return;



	skel->bss->callback_selector = 0x0F;

	usleep(1);

	ASSERT_EQ(skel->bss->g_output, 0x0F, "g_output #1");



	skel->bss->callback_selector = 0xF0;

	usleep(1);

	ASSERT_EQ(skel->bss->g_output, 0xF0, "g_output #2");



	bpf_link__destroy(link);

}



static void check_stack(struct bpf_loop *skel)

{

	struct bpf_link *link = bpf_program__attach(skel->progs.stack_check);

	const int max_key = 12;

	int key;

	int map_fd;



	if (!ASSERT_OK_PTR(link, "link"))

		return;



	map_fd = bpf_map__fd(skel->maps.map1);



	if (!ASSERT_GE(map_fd, 0, "bpf_map__fd"))

		goto out;



	for (key = 1; key <= max_key; ++key) {

		int val = key;

		int err = bpf_map_update_elem(map_fd, &key, &val, BPF_NOEXIST);



		if (!ASSERT_OK(err, "bpf_map_update_elem"))

			goto out;

	}



	usleep(1);



	for (key = 1; key <= max_key; ++key) {

		int val;

		int err = bpf_map_lookup_elem(map_fd, &key, &val);



		if (!ASSERT_OK(err, "bpf_map_lookup_elem"))

			goto out;

		if (!ASSERT_EQ(val, key + 1, "bad value in the map"))

			goto out;

	}



out:

	bpf_link__destroy(link);

}



void test_bpf_loop(void)

{

	struct bpf_loop *skel;
@@ -140,6 +198,10 @@ void test_bpf_loop(void) 
		check_invalid_flags(skel);

	if (test__start_subtest("check_nested_calls"))

		check_nested_calls(skel);

	if (test__start_subtest("check_non_constant_callback"))

		check_non_constant_callback(skel);

	if (test__start_subtest("check_stack"))

		check_stack(skel);



	bpf_loop__destroy(skel);

}

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

+114 −0
Original line number Diff line number Diff line
@@ -11,11 +11,19 @@ struct callback_ctx { 
	int output;

};



struct {

	__uint(type, BPF_MAP_TYPE_HASH);

	__uint(max_entries, 32);

	__type(key, int);

	__type(value, int);

} map1 SEC(".maps");



/* These should be set by the user program */

u32 nested_callback_nr_loops;

u32 stop_index = -1;

u32 nr_loops;

int pid;

int callback_selector;



/* Making these global variables so that the userspace program

 * can verify the output through the skeleton
@@ -111,3 +119,109 @@ int prog_nested_calls(void *ctx) 


	return 0;

}



static int callback_set_f0(int i, void *ctx)

{

	g_output = 0xF0;

	return 0;

}



static int callback_set_0f(int i, void *ctx)

{

	g_output = 0x0F;

	return 0;

}



/*

 * non-constant callback is a corner case for bpf_loop inline logic

 */

SEC("fentry/" SYS_PREFIX "sys_nanosleep")

int prog_non_constant_callback(void *ctx)

{

	struct callback_ctx data = {};



	if (bpf_get_current_pid_tgid() >> 32 != pid)

		return 0;



	int (*callback)(int i, void *ctx);



	g_output = 0;



	if (callback_selector == 0x0F)

		callback = callback_set_0f;

	else

		callback = callback_set_f0;



	bpf_loop(1, callback, NULL, 0);



	return 0;

}



static int stack_check_inner_callback(void *ctx)

{

	return 0;

}



static int map1_lookup_elem(int key)

{

	int *val = bpf_map_lookup_elem(&map1, &key);



	return val ? *val : -1;

}



static void map1_update_elem(int key, int val)

{

	bpf_map_update_elem(&map1, &key, &val, BPF_ANY);

}



static int stack_check_outer_callback(void *ctx)

{

	int a = map1_lookup_elem(1);

	int b = map1_lookup_elem(2);

	int c = map1_lookup_elem(3);

	int d = map1_lookup_elem(4);

	int e = map1_lookup_elem(5);

	int f = map1_lookup_elem(6);



	bpf_loop(1, stack_check_inner_callback, NULL, 0);



	map1_update_elem(1, a + 1);

	map1_update_elem(2, b + 1);

	map1_update_elem(3, c + 1);

	map1_update_elem(4, d + 1);

	map1_update_elem(5, e + 1);

	map1_update_elem(6, f + 1);



	return 0;

}



/* Some of the local variables in stack_check and

 * stack_check_outer_callback would be allocated on stack by

 * compiler. This test should verify that stack content for these

 * variables is preserved between calls to bpf_loop (might be an issue

 * if loop inlining allocates stack slots incorrectly).

 */

SEC("fentry/" SYS_PREFIX "sys_nanosleep")

int stack_check(void *ctx)

{

	if (bpf_get_current_pid_tgid() >> 32 != pid)

		return 0;



	int a = map1_lookup_elem(7);

	int b = map1_lookup_elem(8);

	int c = map1_lookup_elem(9);

	int d = map1_lookup_elem(10);

	int e = map1_lookup_elem(11);

	int f = map1_lookup_elem(12);



	bpf_loop(1, stack_check_outer_callback, NULL, 0);



	map1_update_elem(7,  a + 1);

	map1_update_elem(8, b + 1);

	map1_update_elem(9, c + 1);

	map1_update_elem(10, d + 1);

	map1_update_elem(11, e + 1);

	map1_update_elem(12, f + 1);



	return 0;

}