Commit b83b936f authored by Leon Hwang's avatar Leon Hwang Committed by Andrii Nakryiko
Browse files

selftests/bpf: Add testcases for tailcall hierarchy fixing 



Add some test cases to confirm the tailcall hierarchy issue has been fixed.

On x64, the selftests result is:

cd tools/testing/selftests/bpf && ./test_progs -t tailcalls
327/18  tailcalls/tailcall_bpf2bpf_hierarchy_1:OK
327/19  tailcalls/tailcall_bpf2bpf_hierarchy_fentry:OK
327/20  tailcalls/tailcall_bpf2bpf_hierarchy_fexit:OK
327/21  tailcalls/tailcall_bpf2bpf_hierarchy_fentry_fexit:OK
327/22  tailcalls/tailcall_bpf2bpf_hierarchy_fentry_entry:OK
327/23  tailcalls/tailcall_bpf2bpf_hierarchy_2:OK
327/24  tailcalls/tailcall_bpf2bpf_hierarchy_3:OK
327     tailcalls:OK
Summary: 1/24 PASSED, 0 SKIPPED, 0 FAILED

On arm64, the selftests result is:

cd tools/testing/selftests/bpf && ./test_progs -t tailcalls
327/18  tailcalls/tailcall_bpf2bpf_hierarchy_1:OK
327/19  tailcalls/tailcall_bpf2bpf_hierarchy_fentry:OK
327/20  tailcalls/tailcall_bpf2bpf_hierarchy_fexit:OK
327/21  tailcalls/tailcall_bpf2bpf_hierarchy_fentry_fexit:OK
327/22  tailcalls/tailcall_bpf2bpf_hierarchy_fentry_entry:OK
327/23  tailcalls/tailcall_bpf2bpf_hierarchy_2:OK
327/24  tailcalls/tailcall_bpf2bpf_hierarchy_3:OK
327     tailcalls:OK
Summary: 1/24 PASSED, 0 SKIPPED, 0 FAILED

Acked-by: default avatarEduard Zingerman <eddyz87@gmail.com>
Signed-off-by: default avatarLeon Hwang <hffilwlqm@gmail.com>
Link: https://lore.kernel.org/r/20240714123902.32305-4-hffilwlqm@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
parent 66ff4d61

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

+320 −0
Original line number Diff line number Diff line
@@ -3,6 +3,8 @@ 
#include <test_progs.h>

#include <network_helpers.h>

#include "tailcall_poke.skel.h"

#include "tailcall_bpf2bpf_hierarchy2.skel.h"

#include "tailcall_bpf2bpf_hierarchy3.skel.h"





/* test_tailcall_1 checks basic functionality by patching multiple locations
@@ -1187,6 +1189,312 @@ static void test_tailcall_poke(void) 
	tailcall_poke__destroy(call);

}



static void test_tailcall_hierarchy_count(const char *which, bool test_fentry,

					  bool test_fexit,

					  bool test_fentry_entry)

{

	int err, map_fd, prog_fd, main_data_fd, fentry_data_fd, fexit_data_fd, i, val;

	struct bpf_object *obj = NULL, *fentry_obj = NULL, *fexit_obj = NULL;

	struct bpf_link *fentry_link = NULL, *fexit_link = NULL;

	struct bpf_program *prog, *fentry_prog;

	struct bpf_map *prog_array, *data_map;

	int fentry_prog_fd;

	char buff[128] = {};



	LIBBPF_OPTS(bpf_test_run_opts, topts,

		.data_in = buff,

		.data_size_in = sizeof(buff),

		.repeat = 1,

	);



	err = bpf_prog_test_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj,

				 &prog_fd);

	if (!ASSERT_OK(err, "load obj"))

		return;



	prog = bpf_object__find_program_by_name(obj, "entry");

	if (!ASSERT_OK_PTR(prog, "find entry prog"))

		goto out;



	prog_fd = bpf_program__fd(prog);

	if (!ASSERT_GE(prog_fd, 0, "prog_fd"))

		goto out;



	if (test_fentry_entry) {

		fentry_obj = bpf_object__open_file("tailcall_bpf2bpf_hierarchy_fentry.bpf.o",

						   NULL);

		if (!ASSERT_OK_PTR(fentry_obj, "open fentry_obj file"))

			goto out;



		fentry_prog = bpf_object__find_program_by_name(fentry_obj,

							       "fentry");

		if (!ASSERT_OK_PTR(prog, "find fentry prog"))

			goto out;



		err = bpf_program__set_attach_target(fentry_prog, prog_fd,

						     "entry");

		if (!ASSERT_OK(err, "set_attach_target entry"))

			goto out;



		err = bpf_object__load(fentry_obj);

		if (!ASSERT_OK(err, "load fentry_obj"))

			goto out;



		fentry_link = bpf_program__attach_trace(fentry_prog);

		if (!ASSERT_OK_PTR(fentry_link, "attach_trace"))

			goto out;



		fentry_prog_fd = bpf_program__fd(fentry_prog);

		if (!ASSERT_GE(fentry_prog_fd, 0, "fentry_prog_fd"))

			goto out;



		prog_array = bpf_object__find_map_by_name(fentry_obj, "jmp_table");

		if (!ASSERT_OK_PTR(prog_array, "find jmp_table"))

			goto out;



		map_fd = bpf_map__fd(prog_array);

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

			goto out;



		i = 0;

		err = bpf_map_update_elem(map_fd, &i, &fentry_prog_fd, BPF_ANY);

		if (!ASSERT_OK(err, "update jmp_table"))

			goto out;



		data_map = bpf_object__find_map_by_name(fentry_obj, ".bss");

		if (!ASSERT_FALSE(!data_map || !bpf_map__is_internal(data_map),

				  "find data_map"))

			goto out;



	} else {

		prog_array = bpf_object__find_map_by_name(obj, "jmp_table");

		if (!ASSERT_OK_PTR(prog_array, "find jmp_table"))

			goto out;



		map_fd = bpf_map__fd(prog_array);

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

			goto out;



		i = 0;

		err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

		if (!ASSERT_OK(err, "update jmp_table"))

			goto out;



		data_map = bpf_object__find_map_by_name(obj, ".bss");

		if (!ASSERT_FALSE(!data_map || !bpf_map__is_internal(data_map),

				  "find data_map"))

			goto out;

	}



	if (test_fentry) {

		fentry_obj = bpf_object__open_file("tailcall_bpf2bpf_fentry.bpf.o",

						   NULL);

		if (!ASSERT_OK_PTR(fentry_obj, "open fentry_obj file"))

			goto out;



		prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

		if (!ASSERT_OK_PTR(prog, "find fentry prog"))

			goto out;



		err = bpf_program__set_attach_target(prog, prog_fd,

						     "subprog_tail");

		if (!ASSERT_OK(err, "set_attach_target subprog_tail"))

			goto out;



		err = bpf_object__load(fentry_obj);

		if (!ASSERT_OK(err, "load fentry_obj"))

			goto out;



		fentry_link = bpf_program__attach_trace(prog);

		if (!ASSERT_OK_PTR(fentry_link, "attach_trace"))

			goto out;

	}



	if (test_fexit) {

		fexit_obj = bpf_object__open_file("tailcall_bpf2bpf_fexit.bpf.o",

						  NULL);

		if (!ASSERT_OK_PTR(fexit_obj, "open fexit_obj file"))

			goto out;



		prog = bpf_object__find_program_by_name(fexit_obj, "fexit");

		if (!ASSERT_OK_PTR(prog, "find fexit prog"))

			goto out;



		err = bpf_program__set_attach_target(prog, prog_fd,

						     "subprog_tail");

		if (!ASSERT_OK(err, "set_attach_target subprog_tail"))

			goto out;



		err = bpf_object__load(fexit_obj);

		if (!ASSERT_OK(err, "load fexit_obj"))

			goto out;



		fexit_link = bpf_program__attach_trace(prog);

		if (!ASSERT_OK_PTR(fexit_link, "attach_trace"))

			goto out;

	}



	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "tailcall");

	ASSERT_EQ(topts.retval, 1, "tailcall retval");



	main_data_fd = bpf_map__fd(data_map);

	if (!ASSERT_GE(main_data_fd, 0, "main_data_fd"))

		goto out;



	i = 0;

	err = bpf_map_lookup_elem(main_data_fd, &i, &val);

	ASSERT_OK(err, "tailcall count");

	ASSERT_EQ(val, 34, "tailcall count");



	if (test_fentry) {

		data_map = bpf_object__find_map_by_name(fentry_obj, ".bss");

		if (!ASSERT_FALSE(!data_map || !bpf_map__is_internal(data_map),

				  "find tailcall_bpf2bpf_fentry.bss map"))

			goto out;



		fentry_data_fd = bpf_map__fd(data_map);

		if (!ASSERT_GE(fentry_data_fd, 0,

				  "find tailcall_bpf2bpf_fentry.bss map fd"))

			goto out;



		i = 0;

		err = bpf_map_lookup_elem(fentry_data_fd, &i, &val);

		ASSERT_OK(err, "fentry count");

		ASSERT_EQ(val, 68, "fentry count");

	}



	if (test_fexit) {

		data_map = bpf_object__find_map_by_name(fexit_obj, ".bss");

		if (!ASSERT_FALSE(!data_map || !bpf_map__is_internal(data_map),

				  "find tailcall_bpf2bpf_fexit.bss map"))

			goto out;



		fexit_data_fd = bpf_map__fd(data_map);

		if (!ASSERT_GE(fexit_data_fd, 0,

				  "find tailcall_bpf2bpf_fexit.bss map fd"))

			goto out;



		i = 0;

		err = bpf_map_lookup_elem(fexit_data_fd, &i, &val);

		ASSERT_OK(err, "fexit count");

		ASSERT_EQ(val, 68, "fexit count");

	}



	i = 0;

	err = bpf_map_delete_elem(map_fd, &i);

	if (!ASSERT_OK(err, "delete_elem from jmp_table"))

		goto out;



	err = bpf_prog_test_run_opts(prog_fd, &topts);

	ASSERT_OK(err, "tailcall");

	ASSERT_EQ(topts.retval, 1, "tailcall retval");



	i = 0;

	err = bpf_map_lookup_elem(main_data_fd, &i, &val);

	ASSERT_OK(err, "tailcall count");

	ASSERT_EQ(val, 35, "tailcall count");



	if (test_fentry) {

		i = 0;

		err = bpf_map_lookup_elem(fentry_data_fd, &i, &val);

		ASSERT_OK(err, "fentry count");

		ASSERT_EQ(val, 70, "fentry count");

	}



	if (test_fexit) {

		i = 0;

		err = bpf_map_lookup_elem(fexit_data_fd, &i, &val);

		ASSERT_OK(err, "fexit count");

		ASSERT_EQ(val, 70, "fexit count");

	}



out:

	bpf_link__destroy(fentry_link);

	bpf_link__destroy(fexit_link);

	bpf_object__close(fentry_obj);

	bpf_object__close(fexit_obj);

	bpf_object__close(obj);

}



/* test_tailcall_bpf2bpf_hierarchy_1 checks that the count value of the tail

 * call limit enforcement matches with expectations when tailcalls are preceded

 * with two bpf2bpf calls.

 *

 *         subprog --tailcall-> entry

 * entry <

 *         subprog --tailcall-> entry

 */

static void test_tailcall_bpf2bpf_hierarchy_1(void)

{

	test_tailcall_hierarchy_count("tailcall_bpf2bpf_hierarchy1.bpf.o",

				      false, false, false);

}



/* test_tailcall_bpf2bpf_hierarchy_fentry checks that the count value of the

 * tail call limit enforcement matches with expectations when tailcalls are

 * preceded with two bpf2bpf calls, and the two subprogs are traced by fentry.

 */

static void test_tailcall_bpf2bpf_hierarchy_fentry(void)

{

	test_tailcall_hierarchy_count("tailcall_bpf2bpf_hierarchy1.bpf.o",

				      true, false, false);

}



/* test_tailcall_bpf2bpf_hierarchy_fexit checks that the count value of the tail

 * call limit enforcement matches with expectations when tailcalls are preceded

 * with two bpf2bpf calls, and the two subprogs are traced by fexit.

 */

static void test_tailcall_bpf2bpf_hierarchy_fexit(void)

{

	test_tailcall_hierarchy_count("tailcall_bpf2bpf_hierarchy1.bpf.o",

				      false, true, false);

}



/* test_tailcall_bpf2bpf_hierarchy_fentry_fexit checks that the count value of

 * the tail call limit enforcement matches with expectations when tailcalls are

 * preceded with two bpf2bpf calls, and the two subprogs are traced by both

 * fentry and fexit.

 */

static void test_tailcall_bpf2bpf_hierarchy_fentry_fexit(void)

{

	test_tailcall_hierarchy_count("tailcall_bpf2bpf_hierarchy1.bpf.o",

				      true, true, false);

}



/* test_tailcall_bpf2bpf_hierarchy_fentry_entry checks that the count value of

 * the tail call limit enforcement matches with expectations when tailcalls are

 * preceded with two bpf2bpf calls in fentry.

 */

static void test_tailcall_bpf2bpf_hierarchy_fentry_entry(void)

{

	test_tailcall_hierarchy_count("tc_dummy.bpf.o", false, false, true);

}



/* test_tailcall_bpf2bpf_hierarchy_2 checks that the count value of the tail

 * call limit enforcement matches with expectations:

 *

 *         subprog_tail0 --tailcall-> classifier_0 -> subprog_tail0

 * entry <

 *         subprog_tail1 --tailcall-> classifier_1 -> subprog_tail1

 */

static void test_tailcall_bpf2bpf_hierarchy_2(void)

{

	RUN_TESTS(tailcall_bpf2bpf_hierarchy2);

}



/* test_tailcall_bpf2bpf_hierarchy_3 checks that the count value of the tail

 * call limit enforcement matches with expectations:

 *

 *                                   subprog with jmp_table0 to classifier_0

 * entry --tailcall-> classifier_0 <

 *                                   subprog with jmp_table1 to classifier_0

 */

static void test_tailcall_bpf2bpf_hierarchy_3(void)

{

	RUN_TESTS(tailcall_bpf2bpf_hierarchy3);

}



void test_tailcalls(void)

{

	if (test__start_subtest("tailcall_1"))
@@ -1223,4 +1531,16 @@ void test_tailcalls(void) 
		test_tailcall_bpf2bpf_fentry_entry();

	if (test__start_subtest("tailcall_poke"))

		test_tailcall_poke();

	if (test__start_subtest("tailcall_bpf2bpf_hierarchy_1"))

		test_tailcall_bpf2bpf_hierarchy_1();

	if (test__start_subtest("tailcall_bpf2bpf_hierarchy_fentry"))

		test_tailcall_bpf2bpf_hierarchy_fentry();

	if (test__start_subtest("tailcall_bpf2bpf_hierarchy_fexit"))

		test_tailcall_bpf2bpf_hierarchy_fexit();

	if (test__start_subtest("tailcall_bpf2bpf_hierarchy_fentry_fexit"))

		test_tailcall_bpf2bpf_hierarchy_fentry_fexit();

	if (test__start_subtest("tailcall_bpf2bpf_hierarchy_fentry_entry"))

		test_tailcall_bpf2bpf_hierarchy_fentry_entry();

	test_tailcall_bpf2bpf_hierarchy_2();

	test_tailcall_bpf2bpf_hierarchy_3();

}

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

0 → 100644
+34 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include "bpf_legacy.h"



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 1);

	__uint(key_size, sizeof(__u32));

	__uint(value_size, sizeof(__u32));

} jmp_table SEC(".maps");



int count = 0;



static __noinline

int subprog_tail(struct __sk_buff *skb)

{

	bpf_tail_call_static(skb, &jmp_table, 0);

	return 0;

}



SEC("tc")

int entry(struct __sk_buff *skb)

{

	int ret = 1;



	count++;

	subprog_tail(skb);

	subprog_tail(skb);



	return ret;

}



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

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

0 → 100644
+70 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include "bpf_misc.h"



int classifier_0(struct __sk_buff *skb);

int classifier_1(struct __sk_buff *skb);



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 2);

	__uint(key_size, sizeof(__u32));

	__array(values, void (void));

} jmp_table SEC(".maps") = {

	.values = {

		[0] = (void *) &classifier_0,

		[1] = (void *) &classifier_1,

	},

};



int count0 = 0;

int count1 = 0;



static __noinline

int subprog_tail0(struct __sk_buff *skb)

{

	bpf_tail_call_static(skb, &jmp_table, 0);

	return 0;

}



__auxiliary

SEC("tc")

int classifier_0(struct __sk_buff *skb)

{

	count0++;

	subprog_tail0(skb);

	return 0;

}



static __noinline

int subprog_tail1(struct __sk_buff *skb)

{

	bpf_tail_call_static(skb, &jmp_table, 1);

	return 0;

}



__auxiliary

SEC("tc")

int classifier_1(struct __sk_buff *skb)

{

	count1++;

	subprog_tail1(skb);

	return 0;

}



__success

__retval(33)

SEC("tc")

int tailcall_bpf2bpf_hierarchy_2(struct __sk_buff *skb)

{

	volatile int ret = 0;



	subprog_tail0(skb);

	subprog_tail1(skb);



	asm volatile (""::"r+"(ret));

	return (count1 << 16) | count0;

}



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

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

0 → 100644
+62 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include "bpf_misc.h"



int classifier_0(struct __sk_buff *skb);



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 1);

	__uint(key_size, sizeof(__u32));

	__array(values, void (void));

} jmp_table0 SEC(".maps") = {

	.values = {

		[0] = (void *) &classifier_0,

	},

};



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 1);

	__uint(key_size, sizeof(__u32));

	__array(values, void (void));

} jmp_table1 SEC(".maps") = {

	.values = {

		[0] = (void *) &classifier_0,

	},

};



int count = 0;



static __noinline

int subprog_tail(struct __sk_buff *skb, void *jmp_table)

{

	bpf_tail_call_static(skb, jmp_table, 0);

	return 0;

}



__auxiliary

SEC("tc")

int classifier_0(struct __sk_buff *skb)

{

	count++;

	subprog_tail(skb, &jmp_table0);

	subprog_tail(skb, &jmp_table1);

	return count;

}



__success

__retval(33)

SEC("tc")

int tailcall_bpf2bpf_hierarchy_3(struct __sk_buff *skb)

{

	volatile int ret = 0;



	bpf_tail_call_static(skb, &jmp_table0, 0);



	asm volatile (""::"r+"(ret));

	return ret;

}



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

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

0 → 100644
+35 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright Leon Hwang */



#include "vmlinux.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 1);

	__uint(key_size, sizeof(__u32));

	__uint(value_size, sizeof(__u32));

} jmp_table SEC(".maps");



int count = 0;



static __noinline

int subprog_tail(void *ctx)

{

	bpf_tail_call_static(ctx, &jmp_table, 0);

	return 0;

}



SEC("fentry/dummy")

int BPF_PROG(fentry, struct sk_buff *skb)

{

	count++;

	subprog_tail(ctx);

	subprog_tail(ctx);



	return 0;

}





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