bpf: Allow void return type for global subprogs
Subsystems (4)
Emil Tsalapatis
reviewerv3 cover bpf: Allow void return type for global subprogs
Global subprogs are currently not allowed to return void. Adjust verifier logic to allow global functions with a void return type. Exception callbacks are excluded from this change, and still require a scalar return type.
Also adjust existing selftests that were ensuring that global subprogs with void return types fail to verify. These tests should now load successfully.
v2 -> v3
(https://lore.kernel.org/bpf/[email protected]/)
- Allow freplace for global programs that return void and add selftests (Kumar)
v1 -> v2
(https://lore.kernel.org/bpf/[email protected]/)
- Only mark R0 as valid for non-void global functions (AI)
- Rename subprog_is_void to subprog_returns_void (Kumar)
- Add test that R0 is invalid after calling a void global (Alexei)
- Add check to ensure exception callbacks do not return void and associated selftest
Emil Tsalapatis (2):
bpf: Allow void global functions in the verifier
selftests: bpf: Add tests for void global subprogs
kernel/bpf/btf.c | 7 ++- kernel/bpf/verifier.c | 59 +++++++++++++++++-- .../selftests/bpf/prog_tests/fexit_bpf2bpf.c | 24 ++++++++ .../bpf/prog_tests/test_global_funcs.c | 2 + .../selftests/bpf/progs/exceptions_fail.c | 19 +++++- .../bpf/progs/freplace_int_with_void.c | 14 +++++ .../selftests/bpf/progs/freplace_void.c | 14 +++++ .../selftests/bpf/progs/test_global_func18.c | 23 ++++++++ .../selftests/bpf/progs/test_global_func7.c | 2 +- 9 files changed, 151 insertions(+), 13 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/freplace_int_with_void.c create mode 100644 tools/testing/selftests/bpf/progs/freplace_void.c create mode 100644 tools/testing/selftests/bpf/progs/test_global_func18.c
Signature · 1 line
2.49.0
Emil Tsalapatis
reviewerPATCH v3 1/2 bpf: Allow void global functions in the verifier
Global subprogs are currently not allowed to return void. Adjust verifier logic to allow global functions with a void return type.
--- kernel/bpf/btf.c | 7 ++- kernel/bpf/verifier.c | 59 +++++++++++++++++-- .../selftests/bpf/progs/exceptions_fail.c | 2 +- .../selftests/bpf/progs/test_global_func7.c | 2 +- 4 files changed, 59 insertions(+), 11 deletions(-)
kernel/bpf/btf.c +4 -3
@@ -7836,15 +7836,16 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog) tname, nargs, MAX_BPF_FUNC_REG_ARGS);return -EINVAL ; } -/* check that function returns int, exception cb also requires this */ +/* check that function is void or returns int, exception cb also requires this */ t =btf_type_by_id (btf, t->type);while (btf_type_is_modifier (t)) t =btf_type_by_id (btf, t->type); -if (!btf_type_is_int (t) && !btf_is_any_enum (t)) { +if (!btf_type_is_void (t) && !btf_type_is_int (t) && !btf_is_any_enum (t)) {if (!is_global)return -EINVAL ;bpf_log (log, -"Global function %s() doesn't return scalar. Only those are supported.\n" , +"Global function %s() return value not void or scalar. " +"Only those are supported.\n" , tname);return -EINVAL ; }
kernel/bpf/verifier.c +53 -6
90 lines not on this page · raw message
tools/testing/selftests/bpf/progs/exceptions_fail.c +1 -1
@@ -51,7 +51,7 @@ __noinline int exception_cb_ok_arg_small(int a) SEC("?tc") __exception_cb(exception_cb_bad_ret_type) -__failure __msg("Global function exception_cb_bad_ret_type() doesn't return scalar.") +__failure __msg("Global function exception_cb_bad_ret_type() return value not void or scalar.")int reject_exception_cb_type_1 (struct __sk_buff *ctx) {bpf_throw (0 );
tools/testing/selftests/bpf/progs/test_global_func7.c +1 -1
@@ -12,7 +12,7 @@ void foo(struct __sk_buff *skb) } SEC("tc") -__failure __msg("foo() doesn't return scalar") +__successint global_func7 (struct __sk_buff *skb) {foo (skb);
Signature · 1 line
2.49.0
Eduard Zingerman
maintainerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
[...]
Quoted 18 lines
kernel/bpf/verifier.c +10
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id))
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; + + type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +
Nit: I there there are a few unnecessary 'verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees that func->type and func_proto->type would be valid.
Quoted 6 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;
[...]
Quoted 18 lines
kernel/bpf/verifier.c +10
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 7 lines
kernel/bpf/verifier.c +4
-0@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else { +/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;
Suppose a global subprogram is verified and it calls bpf_throw(). check_return_code() is called from check_kfunc_call() in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?
Quoted 3 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used
[...]
Emil Tsalapatis
reviewerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
Quoted 1 line · Eduard Zingerman
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
Ack on the comments for 2/2. For here:
Quoted 27 lines
[...]
Quoted 24 lines
kernel/bpf/verifier.c +16
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id)) +return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; +
Quoted 9 lines
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +Nit: I there there are a few unnecessary '
verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees thatfunc->typeandfunc_proto->typewould be valid.
Ack, just to make sure I got it right at all the verifier_bug_if() are unnecessary. unnecessary because the BTF is already checked. There's no way we have an existing type with invalid fields. We also know the subprog btf ID is valid from check_btf_func_early that happens way before do_check_subprogs where subprog_returns_void is used.
Quoted 31 lines
Quoted 6 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;[...]
Quoted 22 lines
kernel/bpf/verifier.c +11
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else {
Quoted 9 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 3 lines
kernel/bpf/verifier.c +3
-0+/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;Suppose a global subprogram is verified and it calls
bpf_throw().check_return_code()is called fromcheck_kfunc_call()in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?
Due to the short-circuiting herea a void global program can bpf_throw() with no issue. This is what we want, correct? The return type we check in that case would always be that of the u64 cookie AFAICT.
Quoted 5 lines
Quoted 3 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used [...]
Eduard Zingerman
maintainerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
Quoted 41 lines · Emil Tsalapatis
Quoted 1 line · Eduard Zingerman
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
Ack on the comments for 2/2. For here:
Quoted 27 lines
[...]
Quoted 24 lines
kernel/bpf/verifier.c +16
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id)) +return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; +Quoted 9 lines
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +Nit: I there there are a few unnecessary '
verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees thatfunc->typeandfunc_proto->typewould be valid.
Quoted 5 lines
Ack, just to make sure I got it right at all the
verifier_bug_if()are unnecessary. unnecessary because the BTF is already checked. There's no way we have an existing type with invalid fields. We also know the subprog btf ID is valid fromcheck_btf_func_earlythat happens way beforedo_check_subprogswheresubprog_returns_voidis used.
Certainly not needed for 'func->type' and 'func_proto->type' access. For 'func_info[subprog].type_id', idk -- depends on how defensive you want to be, I'd skip it as well.
Quoted 42 lines
Quoted 32 lines
Quoted 7 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;[...]
Quoted 22 lines
kernel/bpf/verifier.c +11
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else {Quoted 9 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 3 lines
kernel/bpf/verifier.c +3
-0+/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;Suppose a global subprogram is verified and it calls
bpf_throw().check_return_code()is called fromcheck_kfunc_call()in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?
Quoted 3 lines
Due to the short-circuiting herea a void global program can
bpf_throw()with no issue. This is what we want, correct? The return type we check in that case would always be that of the u64 cookie AFAICT.
I mean the following situation:
SEC(<I want some special return code>)
int foo(...) {
... bar(...) ...;
return ...;
}
// global func
void bar(...) {
... bpf_throw(<bad return code>) ...
}In this case 'bar' would correspond to 'frame' in the check above and <bad return code> won't be checked.
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used [...]
Emil Tsalapatis
reviewerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
Quoted 111 lines · Eduard Zingerman
Quoted 41 lines · Emil Tsalapatis
Quoted 1 line · Eduard Zingerman
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
Ack on the comments for 2/2. For here:
Quoted 27 lines
[...]
Quoted 24 lines
kernel/bpf/verifier.c +16
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id)) +return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; +Quoted 9 lines
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +Nit: I there there are a few unnecessary '
verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees thatfunc->typeandfunc_proto->typewould be valid.Quoted 5 lines
Ack, just to make sure I got it right at all the
verifier_bug_if()are unnecessary. unnecessary because the BTF is already checked. There's no way we have an existing type with invalid fields. We also know the subprog btf ID is valid fromcheck_btf_func_earlythat happens way beforedo_check_subprogswheresubprog_returns_voidis used.Certainly not needed for '
func->type' and 'func_proto->type' access. For 'func_info[subprog].type_id', idk -- depends on how defensive you want to be, I'd skip it as well.Quoted 42 lines
Quoted 32 lines
Quoted 7 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;[...]
Quoted 22 lines
kernel/bpf/verifier.c +11
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else {Quoted 9 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 3 lines
kernel/bpf/verifier.c +3
-0+/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;Suppose a global subprogram is verified and it calls
bpf_throw().check_return_code()is called fromcheck_kfunc_call()in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?Quoted 3 lines
Due to the short-circuiting herea a void global program can
bpf_throw()with no issue. This is what we want, correct? The return type we check in that case would always be that of the u64 cookie AFAICT.I mean the following situation:
SEC(<I want some special return code>) int foo(...) { ... bar(...) ...; return ...; } // global func void bar(...) { ... bpf_throw(<bad return code>) ... }
Quoted 3 lines
In this case 'bar' would correspond to 'frame' in the check above and <bad return code> won't be checked.
I see, yes this spuriously passes. Since the check_error_code only runs for BPF_EXIT and bpf_throw, can we just check if we're inspecting bpf_throw()'s return value like so?
bool is_bpf_throw = regno == BPF_REG_1;
...
if (subprog_is_global(env, frame->subprogno) && subprog_returns_void(env, frame->subprogno)
&& !is_bpf_throw)
...
We only need to use this check in two places in check_error_code to solve the problem. With the fix we can also still throw from void global() functions.
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used [...]
Eduard Zingerman
maintainerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
Quoted 123 lines · Emil Tsalapatis
Quoted 111 lines · Eduard Zingerman
Quoted 41 lines · Emil Tsalapatis
Quoted 1 line · Eduard Zingerman
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
Ack on the comments for 2/2. For here:
Quoted 27 lines
[...]
Quoted 24 lines
kernel/bpf/verifier.c +16
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id)) +return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; +Quoted 9 lines
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +Nit: I there there are a few unnecessary '
verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees thatfunc->typeandfunc_proto->typewould be valid.Quoted 5 lines
Ack, just to make sure I got it right at all the
verifier_bug_if()are unnecessary. unnecessary because the BTF is already checked. There's no way we have an existing type with invalid fields. We also know the subprog btf ID is valid fromcheck_btf_func_earlythat happens way beforedo_check_subprogswheresubprog_returns_voidis used.Certainly not needed for '
func->type' and 'func_proto->type' access. For 'func_info[subprog].type_id', idk -- depends on how defensive you want to be, I'd skip it as well.Quoted 42 lines
Quoted 32 lines
Quoted 7 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;[...]
Quoted 22 lines
kernel/bpf/verifier.c +11
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else {Quoted 9 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 3 lines
kernel/bpf/verifier.c +3
-0+/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;Suppose a global subprogram is verified and it calls
bpf_throw().check_return_code()is called fromcheck_kfunc_call()in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?Quoted 3 lines
Due to the short-circuiting herea a void global program can
bpf_throw()with no issue. This is what we want, correct? The return type we check in that case would always be that of the u64 cookie AFAICT.I mean the following situation:
SEC(<I want some special return code>) int foo(...) { ... bar(...) ...; return ...; } // global func void bar(...) { ... bpf_throw(<bad return code>) ... }Quoted 3 lines
In this case 'bar' would correspond to 'frame' in the check above and <bad return code> won't be checked.
I see, yes this spuriously passes. Since the
check_error_codeonly runs forBPF_EXITandbpf_throw, can we just check if we're inspecting bpf_throw()'s return value like so?bool
is_bpf_throw= regno ==BPF_REG_1;
...
if (subprog_is_global(env, frame->subprogno)&&subprog_returns_void(env, frame->subprogno)
Quoted 6 lines
&& !is_bpf_throw)...
We only need to use this check in two places in
check_error_codeto solve the problem. With the fix we can also still throw from voidglobal()functions.
Would it be possible to split check_return_code() in two:
- check_return_code() that checks program return code
- check_throw_return_code() with throw specific logic, referring back to check_return_code() if necessary?
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used [...]
Emil Tsalapatis
reviewerRe: [PATCH bpf-next v3 1/2] bpf: Allow void global functions in the verifier
Quoted 127 lines · Eduard Zingerman
Quoted 126 lines · Emil Tsalapatis
Quoted 111 lines · Eduard Zingerman
Quoted 41 lines · Emil Tsalapatis
Quoted 1 line · Eduard Zingerman
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
Ack on the comments for 2/2. For here:
Quoted 27 lines
[...]
Quoted 24 lines
kernel/bpf/verifier.c +16
-0@@ -444,6 +444,29 @@ static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog)return aux && aux[subprog].linkage ==BTF_FUNC_GLOBAL ; } +static bool subprog_returns_void (struct bpf_verifier_env *env,int subprog) +{ +const struct btf_type *type, *func, *func_proto; +const struct btf *btf = env->prog->aux->btf; +u32 btf_id; + + btf_id = env->prog->aux->func_info[subprog].type_id; + + func =btf_type_by_id (btf, btf_id); +if (verifier_bug_if (!func, env,"btf_id %u not found" , btf_id)) +return false; + + func_proto =btf_type_by_id (btf, func->type); +if (verifier_bug_if (!func_proto, env,"btf_id %u not found" , func->type)) +return false; +Quoted 9 lines
kernel/bpf/verifier.c static bool subprog_is_global(const struct bpf_verifier_env *env, int subprog) · line 466
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+ type =btf_type_skip_modifiers (btf, func_proto->type,NULL ); +if (verifier_bug_if (!type, env,"btf_id %u not found" , func_proto->type)) +return false; +Nit: I there there are a few unnecessary '
verifier_bug_if()' checks here,
e.g. btf.c:btf_check_all_types() guarantees thatfunc->typeandfunc_proto->typewould be valid.Quoted 5 lines
Ack, just to make sure I got it right at all the
verifier_bug_if()are unnecessary. unnecessary because the BTF is already checked. There's no way we have an existing type with invalid fields. We also know the subprog btf ID is valid fromcheck_btf_func_earlythat happens way beforedo_check_subprogswheresubprog_returns_voidis used.Certainly not needed for '
func->type' and 'func_proto->type' access. For 'func_info[subprog].type_id', idk -- depends on how defensive you want to be, I'd skip it as well.Quoted 42 lines
Quoted 32 lines
Quoted 7 lines
kernel/bpf/verifier.c +3
-0+return btf_type_is_void (type); +} +static const char *subprog_name (const struct bpf_verifier_env *env,int subprog) {struct bpf_func_info *info;[...]
Quoted 22 lines
kernel/bpf/verifier.c +11
-0@@ -17812,6 +17837,16 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog || frame->in_exception_callback_fn) { + +/* +* If the actual program is an extension, let it +* return void - attaching will succeed only if the +* program being replaced also returns void, and since +* it has passed verification its actual type doesn't matter. +*/ +if (env->prog->type ==BPF_PROG_TYPE_EXT &&subprog_returns_void (env, frame->subprogno)) +return 0 ; +switch (prog_type) {case BPF_PROG_TYPE_LSM :if (prog->expected_attach_type ==BPF_LSM_CGROUP )@@ -17841,6 +17876,10 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const chardefault :break ; } + }else {Quoted 9 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env, int regno, const char · line 17882
Quoted 3 lines
kernel/bpf/verifier.c +3
-0+/* If this is a void global subprog, there is no return value. */ +if (subprog_is_global (env, frame->subprogno) &&subprog_returns_void (env, frame->subprogno)) +return 0 ;Suppose a global subprogram is verified and it calls
bpf_throw().check_return_code()is called fromcheck_kfunc_call()in such case with R1 as a parameter. This check acts on the return type of the program, will it miss proper return value check for the program?Quoted 3 lines
Due to the short-circuiting herea a void global program can
bpf_throw()with no issue. This is what we want, correct? The return type we check in that case would always be that of the u64 cookie AFAICT.I mean the following situation:
SEC(<I want some special return code>) int foo(...) { ... bar(...) ...; return ...; } // global func void bar(...) { ... bpf_throw(<bad return code>) ... }Quoted 3 lines
In this case 'bar' would correspond to 'frame' in the check above and <bad return code> won't be checked.
I see, yes this spuriously passes. Since the
check_error_codeonly runs forBPF_EXITandbpf_throw, can we just check if we're inspecting bpf_throw()'s return value like so?bool
is_bpf_throw= regno ==BPF_REG_1;
...
if (subprog_is_global(env, frame->subprogno)&&subprog_returns_void(env, frame->subprogno)&& !is_bpf_throw)...
Quoted 9 lines
Quoted 3 lines
We only need to use this check in two places in
check_error_codeto solve the problem. With the fix we can also still throw from voidglobal()functions.Would it be possible to split
check_return_code()in two:
-check_return_code()that checks program return code
-check_throw_return_code()with throw specific logic, referring back tocheck_return_code()if necessary?
I will do that, check_return_code will need some refactoring but the overall code will be cleaner (e.g., the retval_range() calculation can be factored out into a pure function). I will tack on the patches with the non-functional changes at the front of this series.
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
kernel/bpf/verifier.c +0
-0}/* eBPF calling convention is such that R0 is used [...]
Emil Tsalapatis
reviewerPATCH v3 2/2 selftests: bpf: Add tests for void global subprogs
In reply to Emil TsalapatisAdd additional testing for void global functions. The tests ensure that calls to void global functions properly keep R0 invalid. Also make sure that exception callbacks still require a return value.
--- .../selftests/bpf/prog_tests/fexit_bpf2bpf.c | 24 +++++++++++++++++++ .../bpf/prog_tests/test_global_funcs.c | 2 ++ .../selftests/bpf/progs/exceptions_fail.c | 19 ++++++++++++--- .../bpf/progs/freplace_int_with_void.c | 14 +++++++++++ .../selftests/bpf/progs/freplace_void.c | 14 +++++++++++ .../selftests/bpf/progs/test_global_func18.c | 23 ++++++++++++++++++ 6 files changed, 93 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/freplace_int_with_void.c create mode 100644 tools/testing/selftests/bpf/progs/freplace_void.c create mode 100644 tools/testing/selftests/bpf/progs/test_global_func18.c
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c +24 -0
@@ -347,6 +347,17 @@ static void test_func_sockmap_update(void) prog_name, false, NULL); } +static void test_func_replace_void (void ) +{ +const char *prog_name[] = { +"freplace/foo" , + }; +test_fexit_bpf2bpf_common ("./freplace_void.bpf.o" , +"./test_global_func7.bpf.o" , +ARRAY_SIZE (prog_name), + prog_name, false,NULL ); +} +static void test_obj_load_failure_common (const char *obj_file,const char *target_obj_file,const char *exp_msg)
@@ -432,6 +443,15 @@ static void test_func_replace_global_func(void) prog_name, false, NULL); } +static void test_func_replace_int_with_void (void ) +{ +/* Make sure we can't freplace with the wrong type */ +test_obj_load_failure_common ("freplace_int_with_void.bpf.o" , +"./test_global_func2.bpf.o" , +"Return type UNKNOWN of test_freplace_int_with_void()" +" doesn't match type INT of global_func2()" ); +} +static int find_prog_btf_id (const char *name,__u32 attach_prog_fd) {struct bpf_prog_info info = {};
@@ -597,4 +617,8 @@ void serial_test_fexit_bpf2bpf(void)test_fentry_to_cgroup_bpf ();if (test__start_subtest ("func_replace_progmap" ))test_func_replace_progmap (); +if (test__start_subtest ("freplace_int_with_void" )) +test_func_replace_int_with_void (); +if (test__start_subtest ("freplace_void" )) +test_func_replace_void (); }
tools/testing/selftests/bpf/prog_tests/test_global_funcs.c +2 -0
@@ -18,6 +18,7 @@#include "test_global_func15.skel.h" #include "test_global_func16.skel.h" #include "test_global_func17.skel.h" +#include "test_global_func18.skel.h" #include "test_global_func_ctx_args.skel.h" #include "bpf/libbpf_internal.h"
@@ -155,6 +156,7 @@ void test_test_global_funcs(void)RUN_TESTS (test_global_func15);RUN_TESTS (test_global_func16);RUN_TESTS (test_global_func17); +RUN_TESTS (test_global_func18);RUN_TESTS (test_global_func_ctx_args);if (test__start_subtest ("ctx_arg_rewrite" ))
tools/testing/selftests/bpf/progs/exceptions_fail.c +16 -3
@@ -29,11 +29,15 @@ struct { private(A) struct bpf_spin_lock lock; private(A) struct bpf_rb_root rbtree __contains(foo, node); -__noinline void *exception_cb_bad_ret_type(u64 cookie) +__noinline void *exception_cb_bad_ret_type1(u64 cookie) {return NULL ; } +__noinline void exception_cb_bad_ret_type2(u64 cookie) +{ +} + __noinline int exception_cb_bad_arg_0(void) {return 0 ;
@@ -50,8 +54,8 @@ __noinline int exception_cb_ok_arg_small(int a) } SEC("?tc") -__exception_cb (exception_cb_bad_ret_type) -__failure __msg("Global function exception_cb_bad_ret_type() return value not void or scalar.") +__exception_cb (exception_cb_bad_ret_type1) +__failure __msg("Global function exception_cb_bad_ret_type1() return value not void or scalar.")int reject_exception_cb_type_1 (struct __sk_buff *ctx) {bpf_throw (0 );
@@ -85,6 +89,15 @@ int reject_exception_cb_type_4(struct __sk_buff *ctx)return 0 ; } +SEC("?tc") +__exception_cb (exception_cb_bad_ret_type2) +__failure __msg("exception cb cannot return void") +int reject_exception_cb_type_5 (struct __sk_buff *ctx) +{ +bpf_throw (0 ); +return 0 ; +} +__noinline static int timer_cb(void *map, int *key, struct bpf_timer *timer) {
tools/testing/selftests/bpf/progs/freplace_int_with_void.c new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <linux/pkt_cls.h> +#include <bpf/bpf_helpers.h> + +volatile int data; + +SEC("freplace/global_func2") +void test_freplace_int_with_void (struct __sk_buff *skb) +{ + data =1 ; +} + +char _license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/progs/freplace_void.c new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> + +volatile int data; + +SEC("freplace/foo") +__weak +void test_freplace_void (struct __sk_buff *skb) +{ + data =1 ; +} + +char _license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/progs/test_global_func18.c new file +23 -0
@@ -0,0 +1,23 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include "bpf_misc.h" + +__weak +void foo (void ) +{ +} + +SEC("tc") +__failure __msg("!read_ok") +int global_func18(struct __sk_buff *skb) +{ +foo (); + + asmvolatile ( +"r1 = r0;" + ::: + ); + +return 0 ; +}
Signature · 1 line
2.49.0
Eduard Zingerman
maintainerRe: [PATCH bpf-next v3 2/2] selftests: bpf: Add tests for void global subprogs
On Mon, 2026-02-23 at 16:50 -0500, Emil Tsalapatis wrote:
[...]
Quoted 6 lines
tools/testing/selftests/bpf/progs/freplace_void.c new file +0
-0
tools/testing/selftests/bpf/progs/freplace_void.c line 8
Quoted 8 lines
tools/testing/selftests/bpf/progs/freplace_void.c new file +8
-0@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> + +volatile int data; + +SEC ("freplace/foo" ) +__weak
Nit: __weak not needed here.
tools/testing/selftests/bpf/progs/freplace_void.c line 11
Quoted 3 lines
tools/testing/selftests/bpf/progs/freplace_void.c new file +3
-0+void test_freplace_void (struct __sk_buff *skb) +{ + data =1 ;
Nit: 'data' is never validated, so there is no point in 'data'
definition and this statement.
tools/testing/selftests/bpf/progs/test_global_func18.c
Quoted 8 lines
tools/testing/selftests/bpf/progs/freplace_void.c new file +3
-0+} + +char _license[] SEC("license") = "GPL";tools/testing/selftests/bpf/progs/test_global_func18.c new file +0
-0
Nit: I'd put this to verifier_global_subprogs.c
Quoted 24 lines
tools/testing/selftests/bpf/progs/test_global_func18.c new file +23
-0@@ -0,0 +1,23 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include "bpf_misc.h" + +__weak +void foo (void ) +{ +} + +SEC("tc") +__failure __msg("!read_ok") +int global_func18(struct __sk_buff *skb) +{ +foo (); + + asmvolatile ( +"r1 = r0;" + ::: + ); + +return 0 ; +}