selftests/bpf: Use non-autoloaded programs in few tests

anakryiko · Alexei Starovoitov · commit 0d7fefebea55 · 2022-04-19T13:48:20.000-07:00
Take advantage of new libbpf feature for declarative non-autoloaded BPF program SEC() definitions in few test that test single program at a time out of many available programs within the single BPF object. Signed-off-by: Andrii Nakryiko <andrii@kernel.org> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://lore.kernel.org/bpf/20220419002452.632125-2-andrii@kernel.org
diff --git a/tools/testing/selftests/bpf/prog_tests/helper_restricted.c b/tools/testing/selftests/bpf/prog_tests/helper_restricted.c
@@ -6,11 +6,10 @@
 void test_helper_restricted(void)
 {
 	int prog_i = 0, prog_cnt;
-	int duration = 0;
 
 	do {
 		struct test_helper_restricted *test;
-		int maybeOK;
+		int err;
 
 		test = test_helper_restricted__open();
 		if (!ASSERT_OK_PTR(test, "open"))
@@ -21,12 +20,11 @@ void test_helper_restricted(void)
 		for (int j = 0; j < prog_cnt; ++j) {
 			struct bpf_program *prog = *test->skeleton->progs[j].prog;
 
-			maybeOK = bpf_program__set_autoload(prog, prog_i == j);
-			ASSERT_OK(maybeOK, "set autoload");
+			bpf_program__set_autoload(prog, true);
 		}
 
-		maybeOK = test_helper_restricted__load(test);
-		CHECK(!maybeOK, test->skeleton->progs[prog_i].name, "helper isn't restricted");
+		err = test_helper_restricted__load(test);
+		ASSERT_ERR(err, "load_should_fail");
 
 		test_helper_restricted__destroy(test);
 	} while (++prog_i < prog_cnt);
diff --git a/tools/testing/selftests/bpf/prog_tests/reference_tracking.c b/tools/testing/selftests/bpf/prog_tests/reference_tracking.c
@@ -1,21 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 #include <test_progs.h>
 
-static void toggle_object_autoload_progs(const struct bpf_object *obj,
-					 const char *name_load)
-{
-	struct bpf_program *prog;
-
-	bpf_object__for_each_program(prog, obj) {
-		const char *name = bpf_program__name(prog);
-
-		if (!strcmp(name_load, name))
-			bpf_program__set_autoload(prog, true);
-		else
-			bpf_program__set_autoload(prog, false);
-	}
-}
-
 void test_reference_tracking(void)
 {
 	const char *file = "test_sk_lookup_kern.o";
@@ -39,6 +24,7 @@ void test_reference_tracking(void)
 		goto cleanup;
 
 	bpf_object__for_each_program(prog, obj_iter) {
+		struct bpf_program *p;
 		const char *name;
 
 		name = bpf_program__name(prog);
@@ -49,7 +35,12 @@ void test_reference_tracking(void)
 		if (!ASSERT_OK_PTR(obj, "obj_open_file"))
 			goto cleanup;
 
-		toggle_object_autoload_progs(obj, name);
+		/* all programs are not loaded by default, so just set
+		 * autoload to true for the single prog under test
+		 */
+		p = bpf_object__find_program_by_name(obj, name);
+		bpf_program__set_autoload(p, true);
+
 		/* Expect verifier failure if test name has 'err' */
 		if (strncmp(name, "err_", sizeof("err_") - 1) == 0) {
 			libbpf_print_fn_t old_print_fn;
diff --git a/tools/testing/selftests/bpf/prog_tests/test_strncmp.c b/tools/testing/selftests/bpf/prog_tests/test_strncmp.c
@@ -44,16 +44,12 @@ static void strncmp_full_str_cmp(struct strncmp_test *skel, const char *name,
 static void test_strncmp_ret(void)
 {
 	struct strncmp_test *skel;
-	struct bpf_program *prog;
 	int err, got;
 
 	skel = strncmp_test__open();
 	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
 		return;
 
-	bpf_object__for_each_program(prog, skel->obj)
-		bpf_program__set_autoload(prog, false);
-
 	bpf_program__set_autoload(skel->progs.do_strncmp, true);
 
 	err = strncmp_test__load(skel);
@@ -91,18 +87,13 @@ static void test_strncmp_ret(void)
 static void test_strncmp_bad_not_const_str_size(void)
 {
 	struct strncmp_test *skel;
-	struct bpf_program *prog;
 	int err;
 
 	skel = strncmp_test__open();
 	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
 		return;
 
-	bpf_object__for_each_program(prog, skel->obj)
-		bpf_program__set_autoload(prog, false);
-
-	bpf_program__set_autoload(skel->progs.strncmp_bad_not_const_str_size,
-				  true);
+	bpf_program__set_autoload(skel->progs.strncmp_bad_not_const_str_size, true);
 
 	err = strncmp_test__load(skel);
 	ASSERT_ERR(err, "strncmp_test load bad_not_const_str_size");
@@ -113,18 +104,13 @@ static void test_strncmp_bad_not_const_str_size(void)
 static void test_strncmp_bad_writable_target(void)
 {
 	struct strncmp_test *skel;
-	struct bpf_program *prog;
 	int err;
 
 	skel = strncmp_test__open();
 	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
 		return;
 
-	bpf_object__for_each_program(prog, skel->obj)
-		bpf_program__set_autoload(prog, false);
-
-	bpf_program__set_autoload(skel->progs.strncmp_bad_writable_target,
-				  true);
+	bpf_program__set_autoload(skel->progs.strncmp_bad_writable_target, true);
 
 	err = strncmp_test__load(skel);
 	ASSERT_ERR(err, "strncmp_test load bad_writable_target");
@@ -135,18 +121,13 @@ static void test_strncmp_bad_writable_target(void)
 static void test_strncmp_bad_not_null_term_target(void)
 {
 	struct strncmp_test *skel;
-	struct bpf_program *prog;
 	int err;
 
 	skel = strncmp_test__open();
 	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
 		return;
 
-	bpf_object__for_each_program(prog, skel->obj)
-		bpf_program__set_autoload(prog, false);
-
-	bpf_program__set_autoload(skel->progs.strncmp_bad_not_null_term_target,
-				  true);
+	bpf_program__set_autoload(skel->progs.strncmp_bad_not_null_term_target, true);
 
 	err = strncmp_test__load(skel);
 	ASSERT_ERR(err, "strncmp_test load bad_not_null_term_target");
diff --git a/tools/testing/selftests/bpf/progs/strncmp_test.c b/tools/testing/selftests/bpf/progs/strncmp_test.c
@@ -19,7 +19,7 @@ unsigned int no_const_str_size = STRNCMP_STR_SZ;
 
 char _license[] SEC("license") = "GPL";
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int do_strncmp(void *ctx)
 {
 	if ((bpf_get_current_pid_tgid() >> 32) != target_pid)
@@ -29,23 +29,23 @@ int do_strncmp(void *ctx)
 	return 0;
 }
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int strncmp_bad_not_const_str_size(void *ctx)
 {
 	/* The value of string size is not const, so will fail */
 	cmp_ret = bpf_strncmp(str, no_const_str_size, target);
 	return 0;
 }
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int strncmp_bad_writable_target(void *ctx)
 {
 	/* Compared target is not read-only, so will fail */
 	cmp_ret = bpf_strncmp(str, STRNCMP_STR_SZ, writable_target);
 	return 0;
 }
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int strncmp_bad_not_null_term_target(void *ctx)
 {
 	/* Compared target is not null-terminated, so will fail */
diff --git a/tools/testing/selftests/bpf/progs/test_helper_restricted.c b/tools/testing/selftests/bpf/progs/test_helper_restricted.c
@@ -56,63 +56,63 @@ static void spin_lock_work(void)
 	}
 }
 
-SEC("raw_tp/sys_enter")
+SEC("?raw_tp/sys_enter")
 int raw_tp_timer(void *ctx)
 {
 	timer_work();
 
 	return 0;
 }
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int tp_timer(void *ctx)
 {
 	timer_work();
 
 	return 0;
 }
 
-SEC("kprobe/sys_nanosleep")
+SEC("?kprobe/sys_nanosleep")
 int kprobe_timer(void *ctx)
 {
 	timer_work();
 
 	return 0;
 }
 
-SEC("perf_event")
+SEC("?perf_event")
 int perf_event_timer(void *ctx)
 {
 	timer_work();
 
 	return 0;
 }
 
-SEC("raw_tp/sys_enter")
+SEC("?raw_tp/sys_enter")
 int raw_tp_spin_lock(void *ctx)
 {
 	spin_lock_work();
 
 	return 0;
 }
 
-SEC("tp/syscalls/sys_enter_nanosleep")
+SEC("?tp/syscalls/sys_enter_nanosleep")
 int tp_spin_lock(void *ctx)
 {
 	spin_lock_work();
 
 	return 0;
 }
 
-SEC("kprobe/sys_nanosleep")
+SEC("?kprobe/sys_nanosleep")
 int kprobe_spin_lock(void *ctx)
 {
 	spin_lock_work();
 
 	return 0;
 }
 
-SEC("perf_event")
+SEC("?perf_event")
 int perf_event_spin_lock(void *ctx)
 {
 	spin_lock_work();
diff --git a/tools/testing/selftests/bpf/progs/test_sk_lookup_kern.c b/tools/testing/selftests/bpf/progs/test_sk_lookup_kern.c
@@ -52,7 +52,7 @@ static struct bpf_sock_tuple *get_tuple(void *data, __u64 nh_off,
 	return result;
 }
 
-SEC("tc")
+SEC("?tc")
 int sk_lookup_success(struct __sk_buff *skb)
 {
 	void *data_end = (void *)(long)skb->data_end;
@@ -78,7 +78,7 @@ int sk_lookup_success(struct __sk_buff *skb)
 	return sk ? TC_ACT_OK : TC_ACT_UNSPEC;
 }
 
-SEC("tc")
+SEC("?tc")
 int sk_lookup_success_simple(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -90,7 +90,7 @@ int sk_lookup_success_simple(struct __sk_buff *skb)
 	return 0;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_use_after_free(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -105,7 +105,7 @@ int err_use_after_free(struct __sk_buff *skb)
 	return family;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_modify_sk_pointer(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -120,7 +120,7 @@ int err_modify_sk_pointer(struct __sk_buff *skb)
 	return 0;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_modify_sk_or_null_pointer(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -134,7 +134,7 @@ int err_modify_sk_or_null_pointer(struct __sk_buff *skb)
 	return 0;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_no_release(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -143,7 +143,7 @@ int err_no_release(struct __sk_buff *skb)
 	return 0;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_release_twice(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -155,7 +155,7 @@ int err_release_twice(struct __sk_buff *skb)
 	return 0;
 }
 
-SEC("tc")
+SEC("?tc")
 int err_release_unchecked(struct __sk_buff *skb)
 {
 	struct bpf_sock_tuple tuple = {};
@@ -172,7 +172,7 @@ void lookup_no_release(struct __sk_buff *skb)
 	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
 }
 
-SEC("tc")
+SEC("?tc")
 int err_no_release_subcall(struct __sk_buff *skb)
 {
 	lookup_no_release(skb);

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ unsigned int no_const_str_size = STRNCMP_STR_SZ;`
`19`	`19`
`20`	`20`	`char _license[] SEC("license") = "GPL";`
`21`	`21`
`22`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`22`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`23`	`23`	`int do_strncmp(void *ctx)`
`24`	`24`	`{`
`25`	`25`	`if ((bpf_get_current_pid_tgid() >> 32) != target_pid)`
`@@ -29,23 +29,23 @@ int do_strncmp(void *ctx)`
`29`	`29`	`return 0;`
`30`	`30`	`}`
`31`	`31`
`32`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`32`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`33`	`33`	`int strncmp_bad_not_const_str_size(void *ctx)`
`34`	`34`	`{`
`35`	`35`	`/* The value of string size is not const, so will fail */`
`36`	`36`	`cmp_ret = bpf_strncmp(str, no_const_str_size, target);`
`37`	`37`	`return 0;`
`38`	`38`	`}`
`39`	`39`
`40`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`40`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`41`	`41`	`int strncmp_bad_writable_target(void *ctx)`
`42`	`42`	`{`
`43`	`43`	`/* Compared target is not read-only, so will fail */`
`44`	`44`	`cmp_ret = bpf_strncmp(str, STRNCMP_STR_SZ, writable_target);`
`45`	`45`	`return 0;`
`46`	`46`	`}`
`47`	`47`
`48`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`48`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`49`	`49`	`int strncmp_bad_not_null_term_target(void *ctx)`
`50`	`50`	`{`
`51`	`51`	`/* Compared target is not null-terminated, so will fail */`
Original file line number	Diff line number	Diff line change
`@@ -56,63 +56,63 @@ static void spin_lock_work(void)`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-SEC("raw_tp/sys_enter")`
	`59`	`+SEC("?raw_tp/sys_enter")`
`60`	`60`	`int raw_tp_timer(void *ctx)`
`61`	`61`	`{`
`62`	`62`	`timer_work();`
`63`	`63`
`64`	`64`	`return 0;`
`65`	`65`	`}`
`66`	`66`
`67`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`67`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`68`	`68`	`int tp_timer(void *ctx)`
`69`	`69`	`{`
`70`	`70`	`timer_work();`
`71`	`71`
`72`	`72`	`return 0;`
`73`	`73`	`}`
`74`	`74`
`75`		`-SEC("kprobe/sys_nanosleep")`
	`75`	`+SEC("?kprobe/sys_nanosleep")`
`76`	`76`	`int kprobe_timer(void *ctx)`
`77`	`77`	`{`
`78`	`78`	`timer_work();`
`79`	`79`
`80`	`80`	`return 0;`
`81`	`81`	`}`
`82`	`82`
`83`		`-SEC("perf_event")`
	`83`	`+SEC("?perf_event")`
`84`	`84`	`int perf_event_timer(void *ctx)`
`85`	`85`	`{`
`86`	`86`	`timer_work();`
`87`	`87`
`88`	`88`	`return 0;`
`89`	`89`	`}`
`90`	`90`
`91`		`-SEC("raw_tp/sys_enter")`
	`91`	`+SEC("?raw_tp/sys_enter")`
`92`	`92`	`int raw_tp_spin_lock(void *ctx)`
`93`	`93`	`{`
`94`	`94`	`spin_lock_work();`
`95`	`95`
`96`	`96`	`return 0;`
`97`	`97`	`}`
`98`	`98`
`99`		`-SEC("tp/syscalls/sys_enter_nanosleep")`
	`99`	`+SEC("?tp/syscalls/sys_enter_nanosleep")`
`100`	`100`	`int tp_spin_lock(void *ctx)`
`101`	`101`	`{`
`102`	`102`	`spin_lock_work();`
`103`	`103`
`104`	`104`	`return 0;`
`105`	`105`	`}`
`106`	`106`
`107`		`-SEC("kprobe/sys_nanosleep")`
	`107`	`+SEC("?kprobe/sys_nanosleep")`
`108`	`108`	`int kprobe_spin_lock(void *ctx)`
`109`	`109`	`{`
`110`	`110`	`spin_lock_work();`
`111`	`111`
`112`	`112`	`return 0;`
`113`	`113`	`}`
`114`	`114`
`115`		`-SEC("perf_event")`
	`115`	`+SEC("?perf_event")`
`116`	`116`	`int perf_event_spin_lock(void *ctx)`
`117`	`117`	`{`
`118`	`118`	`spin_lock_work();`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ static struct bpf_sock_tuple get_tuple(void data, __u64 nh_off,`
`52`	`52`	`return result;`
`53`	`53`	`}`
`54`	`54`
`55`		`-SEC("tc")`
	`55`	`+SEC("?tc")`
`56`	`56`	`int sk_lookup_success(struct __sk_buff *skb)`
`57`	`57`	`{`
`58`	`58`	`void data_end = (void )(long)skb->data_end;`
`@@ -78,7 +78,7 @@ int sk_lookup_success(struct __sk_buff *skb)`
`78`	`78`	`return sk ? TC_ACT_OK : TC_ACT_UNSPEC;`
`79`	`79`	`}`
`80`	`80`
`81`		`-SEC("tc")`
	`81`	`+SEC("?tc")`
`82`	`82`	`int sk_lookup_success_simple(struct __sk_buff *skb)`
`83`	`83`	`{`
`84`	`84`	`struct bpf_sock_tuple tuple = {};`
`@@ -90,7 +90,7 @@ int sk_lookup_success_simple(struct __sk_buff *skb)`
`90`	`90`	`return 0;`
`91`	`91`	`}`
`92`	`92`
`93`		`-SEC("tc")`
	`93`	`+SEC("?tc")`
`94`	`94`	`int err_use_after_free(struct __sk_buff *skb)`
`95`	`95`	`{`
`96`	`96`	`struct bpf_sock_tuple tuple = {};`
`@@ -105,7 +105,7 @@ int err_use_after_free(struct __sk_buff *skb)`
`105`	`105`	`return family;`
`106`	`106`	`}`
`107`	`107`
`108`		`-SEC("tc")`
	`108`	`+SEC("?tc")`
`109`	`109`	`int err_modify_sk_pointer(struct __sk_buff *skb)`
`110`	`110`	`{`
`111`	`111`	`struct bpf_sock_tuple tuple = {};`
`@@ -120,7 +120,7 @@ int err_modify_sk_pointer(struct __sk_buff *skb)`
`120`	`120`	`return 0;`
`121`	`121`	`}`
`122`	`122`
`123`		`-SEC("tc")`
	`123`	`+SEC("?tc")`
`124`	`124`	`int err_modify_sk_or_null_pointer(struct __sk_buff *skb)`
`125`	`125`	`{`
`126`	`126`	`struct bpf_sock_tuple tuple = {};`
`@@ -134,7 +134,7 @@ int err_modify_sk_or_null_pointer(struct __sk_buff *skb)`
`134`	`134`	`return 0;`
`135`	`135`	`}`
`136`	`136`
`137`		`-SEC("tc")`
	`137`	`+SEC("?tc")`
`138`	`138`	`int err_no_release(struct __sk_buff *skb)`
`139`	`139`	`{`
`140`	`140`	`struct bpf_sock_tuple tuple = {};`
`@@ -143,7 +143,7 @@ int err_no_release(struct __sk_buff *skb)`
`143`	`143`	`return 0;`
`144`	`144`	`}`
`145`	`145`
`146`		`-SEC("tc")`
	`146`	`+SEC("?tc")`
`147`	`147`	`int err_release_twice(struct __sk_buff *skb)`
`148`	`148`	`{`
`149`	`149`	`struct bpf_sock_tuple tuple = {};`
`@@ -155,7 +155,7 @@ int err_release_twice(struct __sk_buff *skb)`
`155`	`155`	`return 0;`
`156`	`156`	`}`
`157`	`157`
`158`		`-SEC("tc")`
	`158`	`+SEC("?tc")`
`159`	`159`	`int err_release_unchecked(struct __sk_buff *skb)`
`160`	`160`	`{`
`161`	`161`	`struct bpf_sock_tuple tuple = {};`
`@@ -172,7 +172,7 @@ void lookup_no_release(struct __sk_buff *skb)`
`172`	`172`	`bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);`
`173`	`173`	`}`
`174`	`174`
`175`		`-SEC("tc")`
	`175`	`+SEC("?tc")`
`176`	`176`	`int err_no_release_subcall(struct __sk_buff *skb)`
`177`	`177`	`{`
`178`	`178`	`lookup_no_release(skb);`