Skip to contentSkip to conversation

selftests/bpf: Move verifier failure tests out of test_global_percpu_data

PATCH In review Thiébaud Weksteen 5 participants 10 messages Sep 4 – Sep 8

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

PATCH 1/2 selftests/bpf: Move verifier failure tests out of test_global_percpu_data

Commit 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data") added test_global_percpu_data.c to LSKELS_EXTRA. Later, in commit 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmp and verifier_snprintf), both marked as non-autoload (SEC("?kprobe")).

When bpftool generates light skeletons, non-autoloaded programs are skipped during loading, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields (e.g. dump_percpu_data's FD was stored into verifier_strncmp's descriptor).

Move the two verifier failure tests to a dedicated test file, test_global_percpu_data_failure.c, and run them via RUN_TESTS in global_data_init.c. This leaves test_global_percpu_data.c with only autoloaded programs, ensuring the light skeleton can be generated cleanly and correctly.

Fixes 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data")
Fixes 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data")
---
 .../bpf/prog_tests/global_data_init.c         |  3 +-
 .../bpf/progs/test_global_percpu_data.c       | 23 --------------
 .../progs/test_global_percpu_data_failure.c   | 30 +++++++++++++++++++
 3 files changed, 32 insertions(+), 24 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/progs/test_global_percpu_data_failure.c
tools/testing/selftests/bpf/prog_tests/global_data_init.c +2 -1
index 7c539cbcf3a1..dbb7de534f7d 100644
@@ -3,6 +3,7 @@
 #include "bpf/libbpf_internal.h"
 #include "test_global_percpu_data.skel.h"
 #include "test_global_percpu_data.lskel.h"
+#include "test_global_percpu_data_failure.skel.h"
 
 void test_global_data_init(void)
 {
@@ -372,7 +373,7 @@ static void test_global_percpu_data_rdonly_direct_write(void)
 
 static void test_global_percpu_data_verifier_log(void)
 {
-	RUN_TESTS(test_global_percpu_data);
+	RUN_TESTS(test_global_percpu_data_failure);
 }
 
 static void test_global_percpu_data_iter(void)
tools/testing/selftests/bpf/progs/test_global_percpu_data.c +0 -23
index 2765cd46e9af..bc748df4a6cc 100644
@@ -42,29 +42,6 @@ int update_percpu_data(void *ctx)
 	return 0;
 }
 
-static const char fmt[] SEC(".percpu.fmt") = "data %d\n";
-
-SEC("?kprobe")
-__failure __msg("R{{[0-9]+}} points to percpu_array map which cannot be used as const string")
-int verifier_strncmp(void *ctx)
-{
-	return bpf_strncmp("test", 5, fmt);
-}
-
-SEC("?kprobe")
-__failure __msg("R{{[0-9]+}} points to percpu_array map which cannot be used as const string")
-int verifier_snprintf(void *ctx)
-{
-	u64 args[] = { data };
-	char buf[128];
-	int len;
-
-	len = bpf_snprintf(buf, sizeof(buf), fmt, args, sizeof(args));
-	if (len > 0)
-		bpf_printk("snprintf: %s\n", buf);
-	return 0;
-}
-
 volatile const __u32 num_cpus = 0;
 volatile const int num_off;
 volatile const int elem_sz;
tools/testing/selftests/bpf/progs/test_global_percpu_data_failure.c new file +30 -0
new file mode 100644
index 000000000000..3a823acb42d7
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <vmlinux.h>
+#include <bpf/bpf_helpers.h>
+#include "bpf_misc.h"
+
+int data SEC(".percpu") = -1;
+static const char fmt[] SEC(".percpu.fmt") = "data %d\n";
+
+SEC("?kprobe")
+__failure __msg("R{{[0-9]+}} points to percpu_array map which cannot be used as const string")
+int verifier_strncmp(void *ctx)
+{
+	return bpf_strncmp("test", 5, fmt);
+}
+
+SEC("?kprobe")
+__failure __msg("R{{[0-9]+}} points to percpu_array map which cannot be used as const string")
+int verifier_snprintf(void *ctx)
+{
+	u64 args[] = { data };
+	char buf[128];
+	int len;
+
+	len = bpf_snprintf(buf, sizeof(buf), fmt, args, sizeof(args));
+	if (len > 0)
+		bpf_printk("snprintf: %s\n", buf);
+	return 0;
+}
+
+char _license[] SEC("license") = "GPL";
Signature · 1 line
2.55.0.979.g7e5102b832-goog
#1 lore raw

PATCH 2/2 bpftool: Reject non-autoload programs for light skeletons

When generating a light skeleton (bpftool gen skeleton -L), there is no libbpf runtime object or bpf_program__set_autoload() API available to enable/disable the autoloading of programs. If a BPF program in the object has autoload disabled (e.g. via SEC("?...")), bpf_object__load() silently skips loading it. bpftool still generates struct bpf_prog_desc fields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).

Explicitly reject non-autoloaded programs when use_loader is true with an error message, preventing the generation of broken light skeleton headers.

---
 tools/bpf/bpftool/gen.c | 6 ++++++
 1 file changed, 6 insertions(+)
tools/bpf/bpftool/gen.c +6 -0
index a50540ef6521..1583150241c8 100644
@@ -1340,6 +1340,12 @@ static int do_skeleton(int argc, char **argv)
 	}
 	bpf_object__for_each_program(prog, obj) {
 		prog_cnt++;
+
+		if (use_loader && !bpf_program__autoload(prog)) {
+			p_err("program '%s' is marked as non-autoload, which is not supported for light skeletons",
+			      bpf_program__name(prog));
+			return -1;
+		}
 	}
 
 	get_header_guard(header_guard, obj_name, "SKEL_H");
Signature · 1 line
2.55.0.979.g7e5102b832-goog
#2 lore raw

Re: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Direct return on the error path for non-autoload programs leaks the file descriptor, memory…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Direct return on the error path for non-autoload programs leaks the file descriptor, memory mapping, and BPF object. --

commit 2f23ddc68c8f556d1272e5244820c6008be97512
Author: Thiébaud Weksteen <[email protected]>

bpftool: Reject non-autoload programs for light skeletons

When generating a light skeleton (bpftool gen skeleton -L), there is no libbpf runtime object or bpf_program__set_autoload() API available to enable/disable the autoloading of programs. This commit explicitly rejects non-autoloaded programs when use_loader is true with an error message to prevent generating broken light skeleton headers.

tools/bpf/bpftool/gen.c static int do_skeleton(int argc, char **argv) · line 1347

Quoted 13 lines
tools/bpf/bpftool/gen.c +5 -0
index a50540ef6521c..1583150241c88 100644
@@ -1340,6 +1340,12 @@ static int do_skeleton(int argc, char **argv)
 	}
 	bpf_object__for_each_program(prog, obj) {
 		prog_cnt++;
+
+		if (use_loader && !bpf_program__autoload(prog)) {
+			p_err("program '%s' is marked as non-autoload, which is not supported for light skeletons",
+			      bpf_program__name(prog));
+			return -1;

[Severity: Low]
Does this code leak the file descriptor, memory mapping, and BPF object?

Since this returns directly, it bypasses the established resource cleanup block (the out: and out_obj: labels) at the end of do_skeleton(), which would normally call bpf_object__close(obj), munmap(obj_data, mmap_sz), and close(fd).

Could this set err = -1 and use goto out; instead?

Quoted 4 lines
tools/bpf/bpftool/gen.c +1 -0
+		}
 	}
 
 	get_header_guard(header_guard, obj_name, "SKEL_H");
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
#3 lore raw

Re: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons

In reply to Thiébaud Weksteen
This looks like a bug fix for light skeleton generation. Should this include a Fixes: tag?
Quoted 14 lines

commit 2f59d25442273a3dd4e46bd4a77ca4bbf1633e3c

Author: Thiébaud Weksteen <[email protected]>
Date:   Fri Sep 4 13:19:12 2026 +1000

bpftool: Reject non-autoload programs for light skeletons

When generating a light skeleton (bpftool gen skeleton -L), there is no libbpf runtime object or bpf_program__set_autoload() API available to enable/disable the autoloading of programs. If a BPF program in the object has autoload disabled (e.g. via SEC("?...")), bpf_object__load() silently skips loading it. bpftool still generates struct bpf_prog_desc fields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).

Quoted 5 lines

Explicitly reject non-autoloaded programs when use_loader is true with an error message, preventing the generation of broken light skeleton headers.

This looks like a bug fix for light skeleton generation. Should this include a Fixes: tag?

Fixes d510296d331a ("bpftool: Use syscall/loader program in \"prog load\" and \"gen skeleton\" command.")

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/33833567672

maintainer
#4 lore raw

Re: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons

In reply to Thiébaud Weksteen
Quoted 22 lines · Thiébaud Weksteen

When generating a light skeleton (bpftool gen skeleton -L), there is no libbpf runtime object or bpf_program__set_autoload() API available to enable/disable the autoloading of programs. If a BPF program in the object has autoload disabled (e.g. via SEC("?...")), bpf_object__load() silently skips loading it. bpftool still generates struct bpf_prog_desc fields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).

Explicitly reject non-autoloaded programs when use_loader is true with an error message, preventing the generation of broken light skeleton headers.

---
 tools/bpf/bpftool/gen.c | 6 ++++++
 1 file changed, 6 insertions(+)
tools/bpf/bpftool/gen.c +0 -0
index a50540ef6521..1583150241c8 100644

tools/bpf/bpftool/gen.c static int do_skeleton(int argc, char **argv) · line 1347

Quoted 8 lines
tools/bpf/bpftool/gen.c +5 -0
@@ -1340,6 +1340,12 @@ static int do_skeleton(int argc, char **argv)
 	}
 	bpf_object__for_each_program(prog, obj) {
 		prog_cnt++;
+
+		if (use_loader && !bpf_program__autoload(prog)) {
+			p_err("program '%s' is marked as non-autoload, which is not supported for light skeletons",
+			      bpf_program__name(prog));
+			return -1;

Sashiko is correct, at this stage of the function, rather than returning directly, you'd need to "goto out".

tools/bpf/bpftool/gen.c static int do_skeleton(int argc, char **argv) · line 1348

Quoted 1 line
tools/bpf/bpftool/gen.c +1 -0
+		}

Thank you. Maybe consider adding a word about autoload/non-autoload in "bpftool gen" man page? My concern is that users who are not familiar with the notion will struggle to understand the error message.

Quentin

#5 lore raw

Re: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons

Quoted 28 lines · Quentin Monnet
Quoted 26 lines · Thiébaud Weksteen

When generating a light skeleton (bpftool gen skeleton -L), there is no libbpf runtime object or bpf_program__set_autoload() API available to enable/disable the autoloading of programs. If a BPF program in the object has autoload disabled (e.g. via SEC("?...")), bpf_object__load() silently skips loading it. bpftool still generates struct bpf_prog_desc fields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).

Explicitly reject non-autoloaded programs when use_loader is true with an error message, preventing the generation of broken light skeleton headers.

---
 tools/bpf/bpftool/gen.c | 6 ++++++
 1 file changed, 6 insertions(+)
tools/bpf/bpftool/gen.c +1 -0
index a50540ef6521..1583150241c8 100644
@@ -1340,6 +1340,12 @@ static int do_skeleton(int argc, char **argv)
      }
      bpf_object__for_each_program(prog, obj) {
              prog_cnt++;
+
Quoted 8 lines

tools/bpf/bpftool/gen.c static int do_skeleton(int argc, char **argv) · line 1347

Quoted 4 lines
tools/bpf/bpftool/gen.c +4 -0
+             if (use_loader && !bpf_program__autoload(prog)) {
+                     p_err("program '%s' is marked as non-autoload, which is not supported for light skeletons",
+                           bpf_program__name(prog));
+                     return -1;

Sashiko is correct, at this stage of the function, rather than returning directly, you'd need to "goto out".

Thanks for the review. I agree, I'm not sure how I missed that one.

Quoted 8 lines

tools/bpf/bpftool/gen.c static int do_skeleton(int argc, char **argv) · line 1348

Quoted 3 lines
tools/bpf/bpftool/gen.c +1 -0
+             }

Thank you. Maybe consider adding a word about autoload/non-autoload in "bpftool gen" man page? My concern is that users who are not familiar with the notion will struggle to understand the error message.

Ack. I'll send a new patch to skip over these programs instead, as suggested by Leon in the other patch ("selftests/bpf: Move verifier failure tests out of test_global_percpu_data"). Thanks.

#6 lore raw
In reply to Thiébaud Weksteen
Quoted 10 lines · Thiébaud Weksteen

Commit 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data") added test_global_percpu_data.c to LSKELS_EXTRA. Later, in commit 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmp and verifier_snprintf), both marked as non-autoload (SEC("?kprobe")).

When bpftool generates light skeletons, non-autoloaded programs are skipped during loading, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields (e.g. dump_percpu_data's FD was stored into verifier_strncmp's descriptor).

IIUC, patch 2 will fix the issue totally.

Better to add a subtest to verify both the issue and the fix?

Thanks,
Leon

Quoted 1 line

[...]

#7 lore raw
Quoted 8 lines · Leon Hwang
Quoted 6 lines · Thiébaud Weksteen

Commit 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data") added test_global_percpu_data.c to LSKELS_EXTRA. Later, in commit 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmp and verifier_snprintf), both marked as non-autoload (SEC("?kprobe")).

Quoted 8 lines
Quoted 4 lines

When bpftool generates light skeletons, non-autoloaded programs are skipped during loading, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields (e.g. dump_percpu_data's FD was stored into verifier_strncmp's descriptor).

IIUC, patch 2 will fix the issue totally.

Better to add a subtest to verify both the issue and the fix?

Thanks for the review. That's right, patch 2 will fix the issue:
bpftool will fail to build any program that is set up that way. That's why patch 1 is necessary; otherwise, the existing test would fail.

Just checking your suggestion: what I can do is add a new test to make sure that dump_percpu_data is set up as expected (fd > 0). I can write a new test_global_percpu_data_iter_lskel, that is similar to test_global_percpu_data_iter, but for lskel?

I can also write a test to ensure that bpftool fails when light skeletons are set up with autoload=false?

Thanks,

#8 lore raw
Quoted 22 lines · Thiébaud Weksteen
Quoted 8 lines · Leon Hwang
Quoted 6 lines · Thiébaud Weksteen

Commit 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data") added test_global_percpu_data.c to LSKELS_EXTRA. Later, in commit 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmp and verifier_snprintf), both marked as non-autoload (SEC("?kprobe")).

Quoted 8 lines
Quoted 4 lines

When bpftool generates light skeletons, non-autoloaded programs are skipped during loading, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields (e.g. dump_percpu_data's FD was stored into verifier_strncmp's descriptor).

IIUC, patch 2 will fix the issue totally.

Better to add a subtest to verify both the issue and the fix?

Thanks for the review. That's right, patch 2 will fix the issue:
bpftool will fail to build any program that is set up that way. That's why patch 1 is necessary; otherwise, the existing test would fail.

Quoted 8 lines

Just checking your suggestion: what I can do is add a new test to make sure that dump_percpu_data is set up as expected (fd > 0). I can write a new test_global_percpu_data_iter_lskel, that is similar to test_global_percpu_data_iter, but for lskel?

I can also write a test to ensure that bpftool fails when light skeletons are set up with autoload=false?

imo, the rejection of autoload=false prog when generating light skeleton is not friendly for users. Users should not care about mixing autoload=false progs with autoload=true progs, even for light skeletons.

The users-friendly way is to skip those autoload=false progs when generating light skeletons.

So, this is a bpftool issue. A selftest is unnecessary. You can verify both the issue and the fix manually. Probably, paste the verification result in the patch message.

Thanks,
Leon

#9 lore raw
Quoted 33 lines · Leon Hwang
Quoted 22 lines · Thiébaud Weksteen
Quoted 8 lines · Leon Hwang
Quoted 6 lines · Thiébaud Weksteen

Commit 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data") added test_global_percpu_data.c to LSKELS_EXTRA. Later, in commit 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmp and verifier_snprintf), both marked as non-autoload (SEC("?kprobe")).

Quoted 8 lines
Quoted 4 lines

When bpftool generates light skeletons, non-autoloaded programs are skipped during loading, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields (e.g. dump_percpu_data's FD was stored into verifier_strncmp's descriptor).

IIUC, patch 2 will fix the issue totally.

Better to add a subtest to verify both the issue and the fix?

Thanks for the review. That's right, patch 2 will fix the issue:
bpftool will fail to build any program that is set up that way. That's why patch 1 is necessary; otherwise, the existing test would fail.

Quoted 8 lines

Just checking your suggestion: what I can do is add a new test to make sure that dump_percpu_data is set up as expected (fd > 0). I can write a new test_global_percpu_data_iter_lskel, that is similar to test_global_percpu_data_iter, but for lskel?

I can also write a test to ensure that bpftool fails when light skeletons are set up with autoload=false?

Quoted 6 lines

imo, the rejection of autoload=false prog when generating light skeleton is not friendly for users. Users should not care about mixing autoload=false progs with autoload=true progs, even for light skeletons.

The users-friendly way is to skip those autoload=false progs when generating light skeletons.

Good point. I agree. I'll send a patch with this approach instead. Thanks.