bpftool: Skip non-autoload programs when generating light skeletons
Subsystems (4)
PATCH v3 1/3 bpftool: Skip non-autoload programs when generating light skeletons
When generating a light skeleton (bpftool gen skeleton -L), bpf_object__load() skips loading programs marked as non-autoload (e.g. SEC("?...")), so the generated loader program only records and populates file descriptors for autoloaded programs.
Previously, bpftool emitted struct bpf_prog_desc fields, link fields, and attach/detach/destroy functions for all programs in the BPF object, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields when non-autoload programs were present.
Furthermore, bpf_object__load() can update a program's autoload status during preparation (e.g. for struct_ops programs when resolving kernel BTF members or adjusting autoload based on map autocreate settings). Move bpf_object__gen_loader() and bpf_object__load() out of gen_trace() into do_skeleton() before counting programs and emitting struct fields so that struct field declarations and attach/detach/destroy functions all observe the final post-load autoload state.
Skip programs with !bpf_program__autoload(prog) when counting programs and generating progs/links struct fields as well as attach, detach, and destroy functions for light skeletons.
---
v2 -> v3:
- Move comment from gen_trace() to do_skeleton()
- Add comment to do_skeleton() why the loader is called early
v1 -> v2:
- Move bpf_object__gen_loader() and bpf_object__load() out of gen_trace()
.../bpf/bpftool/Documentation/bpftool-gen.rst | 4 +- tools/bpf/bpftool/gen.c | 76 ++++++++++++------- 2 files changed, 52 insertions(+), 28 deletions(-)
tools/bpf/bpftool/Documentation/bpftool-gen.rst +3 -1
@@ -184,7 +184,9 @@ OPTIONS -L, --use-loader For skeletons, generate a "light" skeleton (also known as "loader" skeleton). A light skeleton contains a loader eBPF program. It does not use - the majority of the libbpf infrastructure, and does not need libelf. + the majority of the libbpf infrastructure, and does not need libelf. BPF + programs marked as non-autoload (e.g., via **SEC("?...")**) are skipped and + not included in the generated skeleton. -S, --sign For skeletons, generate a signed skeleton. This option must be used with
tools/bpf/bpftool/gen.c +49 -27
171 lines not on this page · raw message
Signature · 1 line
2.55.0.1082.g2b9226bbc0-goog
PATCH v3 2/3 bpftool: Compute light skeleton ctx.sz without relying on links
When generating a light skeleton, gen_trace() unconditionally sets skel->ctx.sz using (char *)&skel->links - (char *)skel. However, if a BPF object has no programs and no struct_ops maps (prog_cnt + attach_map_cnt == 0), do_skeleton() omits the links struct, causing the generated skeleton header to fail compilation.
Compute skel->ctx.sz from the end of progs (if prog_cnt > 0), maps (if map_cnt > 0), or ctx instead of relying on skel->links. Also remove the unused opts.data_sz argument passed to codegen().
---
No changes since v2
tools/bpf/bpftool/gen.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
tools/bpf/bpftool/gen.c +11 -4
@@ -711,7 +711,7 @@ static void codegen_destroy(struct bpf_object *obj, const char *obj_name) }static int gen_trace (struct bpf_object *obj,const char *obj_name,const char *header_guard, -const struct gen_loader_opts *opts) +const struct gen_loader_opts *opts,size_t prog_cnt,size_t map_cnt) {struct bpf_load_and_run_opts sopts = {};char sig_buf[MAX_SIG_SIZE ];
@@ -742,9 +742,16 @@ static int gen_trace(struct bpf_object *obj, const char *obj_name, const char *h skel = (struct %1$s *)skel_alloc(sizeof(*skel)); \n\ if (!skel) \n\ goto cleanup; \n\ - skel->ctx.sz = (char *)&skel->links - (char *)skel; \n\ ", - obj_name, opts->data_sz); + obj_name); +if (prog_cnt) +printf ("\tskel->ctx.sz = (char *)&skel->progs - (char *)skel\n" +"\t\t + sizeof(skel->progs);\n" ); +else if (map_cnt) +printf ("\tskel->ctx.sz = (char *)&skel->maps - (char *)skel\n" +"\t\t + sizeof(skel->maps);\n" ); +else +printf ("\tskel->ctx.sz = sizeof(skel->ctx);\n" );bpf_object__for_each_map (map, obj) {const void *mmap_data =NULL ;size_t mmap_size =0 ;
@@ -1473,7 +1480,7 @@ static int do_skeleton(int argc, char **argv) goto out; }if (use_loader) { - err =gen_trace (obj, obj_name, header_guard, &gen_opts); + err =gen_trace (obj, obj_name, header_guard, &gen_opts, prog_cnt, map_cnt); goto out; }
Signature · 1 line
2.55.0.1082.g2b9226bbc0-goog
Re: [PATCH bpf-next v3 2/3] bpftool: Compute light skeleton ctx.sz without relying on links
2026-09-18 14:09 UTC+1000 ~ Thiébaud Weksteen <[email protected]>
Quoted 6 lines
When generating a light skeleton,
gen_trace()unconditionally setsskel->ctx.szusing (char *)&skel->links - (char *)skel. However, if a BPF object has no programs and nostruct_opsmaps (prog_cnt+attach_map_cnt== 0),do_skeleton()omits the links struct, causing the generated skeleton header to fail compilation.
Quoted 8 lines
Compute
skel->ctx.szfrom the end of progs (ifprog_cnt> 0), maps (ifmap_cnt> 0), or ctx instead of relying onskel->links. Also remove the unused opts.data_sz argument passed tocodegen().Fixes d510296d331a ("bpftool: Use syscall/loader program in "prog load" and "gen skeleton" command.")Signed-off-by Thiébaud Weksteen <[email protected]>---
No changes since v2
In that case you're welcome to keep my ack from v2 :)
PATCH v3 3/3 selftests/bpf: Add iter subtest using lskel in global_data_init
In reply to Thiébaud WeksteenIn test_global_percpu_data.c, dump_percpu_data is defined after two non-autoload SEC("?kprobe") programs (verifier_strncmp and verifier_snprintf). If bpftool does not skip non-autoload programs when generating light skeletons, dump_percpu_data.prog_fd is left invalid or unpopulated.
Factor out a test_global_percpu_data_iter_fd() helper that operates directly on prog/map file descriptors, and add an iter_lskel subtest to verify that dump_percpu_data is properly loaded and executes correctly when using the light skeleton.
---
v2 -> v3:
- Running the iter subtest against the lskel.
- Factor out test_global_percpu_data_iter_fd into a helper.
- Restore Fixes footers.
v1 -> v2:
- Accidentally dropped Fixes footers.
.../bpf/prog_tests/global_data_init.c | 92 ++++++++++++++----- 1 file changed, 69 insertions(+), 23 deletions(-)
tools/testing/selftests/bpf/prog_tests/global_data_init.c +69 -23
@@ -375,15 +375,43 @@ static void test_global_percpu_data_verifier_log(void)RUN_TESTS (test_global_percpu_data); } -static void test_global_percpu_data_iter (void ) +static void test_global_percpu_data_iter_fd (int prog_fd,int map_fd,int num_cpus, +bool *run_iter,__u32 *sum) { -DECLARE_LIBBPF_OPTS (bpf_iter_attach_opts, opts); -struct test_global_percpu_data *skel; +DECLARE_LIBBPF_OPTS (bpf_link_create_opts, opts);union bpf_iter_link_info linfo = {}; -struct bpf_link *link =NULL ; -int fd, num_cpus, len, err; +int link_fd, iter_fd, len;char buf[16 ]; + linfo.map.map_fd = map_fd; + opts.iter_info = &linfo; + opts.iter_info_len =sizeof (linfo); + + link_fd =bpf_link_create (prog_fd,0 ,BPF_TRACE_ITER , &opts); +if (!ASSERT_GE (link_fd,0 ,"bpf_link_create" )) +return ; + + iter_fd =bpf_iter_create (link_fd); +if (!ASSERT_GE (iter_fd,0 ,"bpf_iter_create" )) + goto out; + +while ((len =read (iter_fd, buf,sizeof (buf))) >0 ) { +/* no-op */ + } +ASSERT_EQ (len,0 ,"read iter" ); +ASSERT_TRUE (*run_iter,"run_iter" ); +ASSERT_EQ (*sum,0xc0de * num_cpus,"sum" ); + +close (iter_fd); +out: +close (link_fd); +} + +static void test_global_percpu_data_iter (void ) +{ +struct test_global_percpu_data *skel; +int num_cpus, err; + num_cpus =libbpf_num_possible_cpus ();if (!ASSERT_GT (num_cpus,0 ,"libbpf_num_possible_cpus" ))return ;
@@ -395,34 +423,50 @@ static void test_global_percpu_data_iter(void) skel->rodata->num_cpus = num_cpus; skel->rodata->num_off = offsetof(struct test_global_percpu_data__percpu , struct_data.nums[6]); - skel->rodata->elem_sz =roundup (sizeof (struct test_global_percpu_data__percpu ),8 ); + skel->rodata->elem_sz =roundup (sizeof (*skel->percpu),8 ); skel->percpu->struct_data.nums[6 ] =0xc0de ; err =test_global_percpu_data__load (skel);if (!ASSERT_OK (err,"test_global_percpu_data__load" )) goto out; - linfo.map.map_fd =bpf_map__fd (skel->maps.percpu); - opts.link_info = &linfo; - opts.link_info_len =sizeof (linfo); - link =bpf_program__attach_iter (skel->progs.dump_percpu_data, &opts); -if (!ASSERT_OK_PTR (link,"bpf_program__attach_iter" )) - goto out; +test_global_percpu_data_iter_fd (bpf_program__fd (skel->progs.dump_percpu_data), +bpf_map__fd (skel->maps.percpu), + num_cpus, &skel->bss->run_iter, + &skel->bss->sum); +out: +test_global_percpu_data__destroy (skel); +} - fd =bpf_iter_create (bpf_link__fd (link)); -if (!ASSERT_GE (fd,0 ,"bpf_iter_create" )) - goto out; +static void test_global_percpu_data_iter_lskel (void ) +{ +struct test_global_percpu_data_lskel *skel; +int num_cpus, err; -while ((len =read (fd, buf,sizeof (buf))) >0 ) -do { }while (0 ); -ASSERT_EQ (len,0 ,"read iter" ); -ASSERT_TRUE (skel->bss->run_iter,"run_iter" ); -ASSERT_EQ (skel->bss->sum,0xc0de * num_cpus,"sum" ); + num_cpus =libbpf_num_possible_cpus (); +if (!ASSERT_GT (num_cpus,0 ,"libbpf_num_possible_cpus" )) +return ; -close (fd); + skel =test_global_percpu_data_lskel__open (); +if (!ASSERT_OK_PTR (skel,"test_global_percpu_data_lskel__open" )) +return ; + + skel->rodata->num_cpus = num_cpus; + skel->rodata->num_off = offsetof(struct test_global_percpu_data_lskel__percpu , + struct_data.nums[6]); + skel->rodata->elem_sz =roundup (sizeof (*skel->percpu),8 ); + skel->percpu->struct_data.nums[6 ] =0xc0de ; + + err =test_global_percpu_data_lskel__load (skel); +if (!ASSERT_OK (err,"test_global_percpu_data_lskel__load" )) + goto out; + +test_global_percpu_data_iter_fd (skel->progs.dump_percpu_data.prog_fd, + skel->maps.percpu.map_fd, + num_cpus, &skel->bss->run_iter, + &skel->bss->sum); out: -bpf_link__destroy (link); -test_global_percpu_data__destroy (skel); +test_global_percpu_data_lskel__destroy (skel); }void test_global_percpu_data (void )
@@ -445,4 +489,6 @@ void test_global_percpu_data(void)test_global_percpu_data_verifier_log ();if (test__start_subtest ("iter" ))test_global_percpu_data_iter (); +if (test__start_subtest ("iter_lskel" )) +test_global_percpu_data_iter_lskel (); }
Signature · 1 line
2.55.0.1082.g2b9226bbc0-goog
[email protected]
AI reviewRe: [PATCH bpf-next v3 3/3] selftests/bpf: Add iter subtest using lskel in global_data_init
Are the Fixes: tags appropriate for this commit? This patch only adds new test coverage (a new iter_lskel subtest) and refactors existing test code (factoring out test_global_percpu_data_iter_fd()…
Quoted 6 lines
In
test_global_percpu_data.c,dump_percpu_datais defined after two non-autoloadSEC("?kprobe")programs (verifier_strncmpandverifier_snprintf). If bpftool does not skip non-autoload programs when generating light skeletons, dump_percpu_data.prog_fd is left invalid or unpopulated.
Quoted 8 lines
Factor out a
test_global_percpu_data_iter_fd()helper that operates directly on prog/map file descriptors, and add aniter_lskelsubtest to verify thatdump_percpu_datais properly loaded and executes correctly when using the light skeleton.Fixes 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data")Fixes 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data")Signed-off-by Thiébaud Weksteen <[email protected]>
Are the Fixes: tags appropriate for this commit? This patch only adds new test coverage (a new iter_lskel subtest) and refactors existing test code (factoring out test_global_percpu_data_iter_fd() with no behavioral change to the existing "iter" subtest). It doesn't fix anything that 4c9241bd731a or 1ed2294b31fc got wrong.
The bug being tested is in bpftool, introduced by d510296d331a ("bpftool: Use syscall/loader program in "prog load" and "gen skeleton" command.") and actually fixed by the two preceding patches in this series (202ee90dee368 and 843762e6f4665), both of which already carry the correct
There's also a backport concern. The Fixes: tags make this patch a candidate for AUTOSEL/stable pickup independently of 202ee90dee368 and 843762e6f4665. Since this is the last patch of the series, backporting it alone would land the new iter_lskel subtest in a tree with the unfixed bpftool, where skel->progs.dump_percpu_data.prog_fd is left at 0 and bpf_link_create(0, 0, BPF_TRACE_ITER, &opts) fails. The subtest would fail by construction.
Should the Fixes: tags be removed, or if they're intended to be kept, should the dependency on the two bpftool patches be stated via
Cc: <[email protected]> prerequisite lines?
---
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/35306404663
Leon Hwang
Acked-byRe: [PATCH bpf-next v3 3/3] selftests/bpf: Add iter subtest using lskel in global_data_init
Quoted 21 lines · On 2026/9/18 13:05, [email protected] wrote:
Quoted 6 lines
In
test_global_percpu_data.c,dump_percpu_datais defined after two non-autoloadSEC("?kprobe")programs (verifier_strncmpandverifier_snprintf). If bpftool does not skip non-autoload programs when generating light skeletons, dump_percpu_data.prog_fd is left invalid or unpopulated.Quoted 8 lines
Factor out a
test_global_percpu_data_iter_fd()helper that operates directly on prog/map file descriptors, and add aniter_lskelsubtest to verify thatdump_percpu_datais properly loaded and executes correctly when using the light skeleton.Fixes 4c9241bd731a ("selftests/bpf: Add tests to verify global percpu data")Fixes 1ed2294b31fc ("selftests/bpf: Test verifier log for global percpu data")Signed-off-by Thiébaud Weksteen <[email protected]>Are the Fixes: tags appropriate for this commit? This patch only adds new test coverage (a new
iter_lskelsubtest) and refactors existing test code (factoring outtest_global_percpu_data_iter_fd()with no behavioral change to the existing "iter" subtest). It doesn't fix anything that4c9241bd731aor1ed2294b31fcgot wrong.
Quoted 5 lines
The bug being tested is in bpftool, introduced by
d510296d331a("bpftool: Use syscall/loader program in "prog load" and "gen skeleton" command.") and actually fixed by the two preceding patches in this series (202ee90dee368and843762e6f4665), both of which already carry the correctFixes d510296d331a tag.
Agreed.
The Fixes: tags of this patch can be dropped.
Others lgtm:
Quoted 19 lines
There's also a backport concern. The Fixes: tags make this patch a candidate for AUTOSEL/stable pickup independently of
202ee90dee368and843762e6f4665. Since this is the last patch of the series, backporting it alone would land the newiter_lskelsubtest in a tree with the unfixed bpftool, whereskel->progs.dump_percpu_data.prog_fdis left at 0 andbpf_link_create(0, 0, BPF_TRACE_ITER, &opts)fails. The subtest would fail by construction.Should the Fixes: tags be removed, or if they're intended to be kept, should the dependency on the two bpftool patches be stated via
Cc: <[email protected]> prerequisite lines?---
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.mdCI run summary: https://github.com/kernel-patches/bpf/actions/runs/35306404663
2026-09-18 14:09 UTC+1000 ~ Thiébaud Weksteen <[email protected]>
Quoted 19 lines
When generating a light skeleton (bpftool gen skeleton -L),
bpf_object__load()skips loading programs marked as non-autoload (e.g.SEC("?...")), so the generated loader program only records and populates file descriptors for autoloaded programs.Previously, bpftool emitted struct
bpf_prog_descfields, link fields, and attach/detach/destroy functions for all programs in the BPF object, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields when non-autoload programs were present.Furthermore,
bpf_object__load()can update a program's autoload status during preparation (e.g. forstruct_opsprograms when resolving kernel BTF members or adjusting autoload based on map autocreate settings). Movebpf_object__gen_loader()andbpf_object__load()out ofgen_trace()intodo_skeleton()before counting programs and emitting struct fields so that struct field declarations and attach/detach/destroy functions all observe the final post-load autoload state.
Quoted 6 lines
Skip programs with !bpf_program__autoload(prog) when counting programs and generating progs/links struct fields as well as attach, detach, and destroy functions for light skeletons.
Fixes d510296d331a ("bpftool: Use syscall/loader program in "prog load" and "gen skeleton" command.")Signed-off-by Thiébaud Weksteen <[email protected]>
Thanks!
Quoted 20 lines · Thiébaud Weksteen
When generating a light skeleton (bpftool gen skeleton -L),
bpf_object__load()skips loading programs marked as non-autoload (e.g.SEC("?...")), so the generated loader program only records and populates file descriptors for autoloaded programs.Previously, bpftool emitted struct
bpf_prog_descfields, link fields, and attach/detach/destroy functions for all programs in the BPF object, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields when non-autoload programs were present.Furthermore,
bpf_object__load()can update a program's autoload status during preparation (e.g. forstruct_opsprograms when resolving kernel BTF members or adjusting autoload based on map autocreate settings). Movebpf_object__gen_loader()andbpf_object__load()out ofgen_trace()intodo_skeleton()before counting programs and emitting struct fields so that struct field declarations and attach/detach/destroy functions all observe the final post-load autoload state.
Quoted 3 lines
Skip programs with !bpf_program__autoload(prog) when counting programs and generating progs/links struct fields as well as attach, detach, and destroy functions for light skeletons.
This seems like error prone behavior to me. Wouldn't it be better to hard fail if the BPF object has non-autoloaded BPF programs instead, as clearly it's not meant to be used with a light skeleton that doesn't support such programs? So why not emit a meaningful error and exit?
Or I don't know, let's teach light skeleton how to support non-loadable programs maybe, not sure what that would take, but worth considering to bridge the gap?
pw-bot: cr
Quoted 14 lines
Fixes d510296d331a ("bpftool: Use syscall/loader program in "prog load" and "gen skeleton" command.")Signed-off-by Thiébaud Weksteen <[email protected]>---
v2 -> v3:
- Move comment fromgen_trace()todo_skeleton()
- Add comment todo_skeleton()why the loader is called early
v1 -> v2:
- Movebpf_object__gen_loader()andbpf_object__load()out ofgen_trace().../bpf/bpftool/Documentation/bpftool-gen.rst | 4 +- tools/bpf/bpftool/gen.c | 76 ++++++++++++------- 2 files changed, 52 insertions(+), 28 deletions(-)
[...]
Quoted 26 lines · Andrii Nakryiko
Quoted 20 lines · Thiébaud Weksteen
When generating a light skeleton (bpftool gen skeleton -L),
bpf_object__load()skips loading programs marked as non-autoload (e.g.SEC("?...")), so the generated loader program only records and populates file descriptors for autoloaded programs.Previously, bpftool emitted struct
bpf_prog_descfields, link fields, and attach/detach/destroy functions for all programs in the BPF object, causing the loader program to store subsequent program FDs into incorrect skeleton struct fields when non-autoload programs were present.Furthermore,
bpf_object__load()can update a program's autoload status during preparation (e.g. forstruct_opsprograms when resolving kernel BTF members or adjusting autoload based on map autocreate settings). Movebpf_object__gen_loader()andbpf_object__load()out ofgen_trace()intodo_skeleton()before counting programs and emitting struct fields so that struct field declarations and attach/detach/destroy functions all observe the final post-load autoload state.Quoted 3 lines
Skip programs with !bpf_program__autoload(prog) when counting programs and generating progs/links struct fields as well as attach, detach, and destroy functions for light skeletons.
Quoted 5 lines
This seems like error prone behavior to me. Wouldn't it be better to hard fail if the BPF object has non-autoloaded BPF programs instead, as clearly it's not meant to be used with a light skeleton that doesn't support such programs? So why not emit a meaningful error and exit?
Thanks for the feedback. This was my first approach [1]. I think it also makes sense. I can send an updated version that addresses Quentin's feedback ("goto out") if that is the overall preference.
[1] https://lore.kernel.org/bpf/[email protected]/
Quoted 4 lines
Or I don't know, let's teach light skeleton how to support non-loadable programs maybe, not sure what that would take, but worth considering to bridge the gap?
This is technically possible, but I'm not sure this is what we want:
it could be implemented by adding a field to struct bpf_prog_desc and change the behaviour of the loader depending on that field. The issue is that, for signed light skeleton, we probably want to ignore this field (for the same reason we are already ignoring initial_value; to keep the attested blob authoritative). In that case, we end up silently skipping any non-autoloaded program within a signed light skeleton. I prefer the hard fail option discussed above, or silently skipping for all kinds of light skeletons (this patch).
Thanks