selftests/bpf: Move verifier failure tests out of test_global_percpu_data
Subsystems (4)
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.
--- .../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
@@ -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
@@ -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
@@ -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
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
@@ -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
[email protected]
AI reviewRe: [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@@ -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
[email protected]
AI reviewRe: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons
In reply to Thiébaud WeksteenThis looks like a bug fix for light skeleton generation. Should this include a Fixes: tag?
Quoted 14 lines
commit
2f59d25442273a3dd4e46bd4a77ca4bbf1633e3cAuthor: Thiébaud Weksteen <[email protected]> Date: Fri Sep 4 13:19:12 2026 +1000bpftool: 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. viaSEC("?...")),bpf_object__load()silently skips loading it. bpftool still generates structbpf_prog_descfields 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_loaderis true with an error message, preventing the generation of broken light skeleton headers.Signed-off-by Thiébaud Weksteen <[email protected]>
This looks like a bug fix for light skeleton generation. Should this include a Fixes: tag?
---
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
Quentin Monnet
maintainerRe: [PATCH bpf-next 2/2] bpftool: Reject non-autoload programs for light skeletons
In reply to Thiébaud WeksteenQuoted 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. viaSEC("?...")),bpf_object__load()silently skips loading it. bpftool still generates structbpf_prog_descfields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).Explicitly reject non-autoloaded programs when
use_loaderis true with an error message, preventing the generation of broken light skeleton headers.Signed-off-by Thiébaud Weksteen <[email protected]>--- tools/bpf/bpftool/gen.c | 6 ++++++ 1 file changed, 6 insertions(+)tools/bpf/bpftool/gen.c +0
-0
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
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. viaSEC("?...")),bpf_object__load()silently skips loading it. bpftool still generates structbpf_prog_descfields and attach functions in the light skeleton header, leaving skel->progs.<name>.prog_fd uninitialized (0).Explicitly reject non-autoloaded programs when
use_loaderis true with an error message, preventing the generation of broken light skeleton headers.Signed-off-by Thiébaud Weksteen <[email protected]>--- tools/bpf/bpftool/gen.c | 6 ++++++ 1 file changed, 6 insertions(+)tools/bpf/bpftool/gen.c +1
-0@@ -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.
Quoted 10 lines · Thiébaud Weksteen
Commit
4c9241bd731a("selftests/bpf: Add tests to verify global percpu data") addedtest_global_percpu_data.ctoLSKELS_EXTRA. Later, in commit1ed2294b31fc("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmpandverifier_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
[...]
Quoted 8 lines · Leon Hwang
Quoted 6 lines · Thiébaud Weksteen
Commit
4c9241bd731a("selftests/bpf: Add tests to verify global percpu data") addedtest_global_percpu_data.ctoLSKELS_EXTRA. Later, in commit1ed2294b31fc("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmpandverifier_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,
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") addedtest_global_percpu_data.ctoLSKELS_EXTRA. Later, in commit1ed2294b31fc("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmpandverifier_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_datais set up as expected (fd > 0). I can write a newtest_global_percpu_data_iter_lskel, that is similar totest_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
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") addedtest_global_percpu_data.ctoLSKELS_EXTRA. Later, in commit1ed2294b31fc("selftests/bpf: Test verifier log for global percpu data") two verifier failure tests were added (verifier_strncmpandverifier_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_datais set up as expected (fd > 0). I can write a newtest_global_percpu_data_iter_lskel, that is similar totest_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.