Skip to contentSkip to conversation

bpf: Allow void return type for global subprogs

PATCH Superseded Emil Tsalapatis 2 participants 10 messages Feb 23 – Feb 25

Subsystems (4)

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Emil Tsalapatis

author reviewer
#0 lore raw

v3 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

Cc Kumar Kartikeya Dwivedi <[email protected]>

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
author reviewer
#1 lore raw

PATCH 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
index 7708958e3fb8..51f8d3dece5d 100644
@@ -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
index 8a0fdff89927..d28ecc4ee2d0 100644
@@ -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
index f182febfde3c..9e59625c1c92 100644
@@ -12,7 +12,7 @@ void foo(struct __sk_buff *skb)
 }
 
 SEC("tc")
-__failure __msg("foo() doesn't return scalar")
+__success
 int global_func7(struct __sk_buff *skb)
 {
 	foo(skb);
Signature · 1 line
2.49.0
maintainer
#2 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 char
 		default:
 			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

[...]

author reviewer
#3 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 that func->type and func_proto->type would 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 char
 		default:
 			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 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?

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

[...]

maintainer
#4 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 that func->type and func_proto->type would 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 from check_btf_func_early that happens way before do_check_subprogs where subprog_returns_void is 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 char
 		default:
 			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 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

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

[...]

author reviewer
#5 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 that func->type and func_proto->type would 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 from check_btf_func_early that happens way before do_check_subprogs where subprog_returns_void is 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 char
 		default:
 			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 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

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

[...]

maintainer
#6 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 that func->type and func_proto->type would 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 from check_btf_func_early that happens way before do_check_subprogs where subprog_returns_void is 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 char
 		default:
 			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 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

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)

Quoted 6 lines
	&& !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.

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

[...]

author reviewer
#7 lore raw

Re: [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
index 0162f946032f..e997c3776fa7 100644
@@ -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 that func->type and func_proto->type would 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 from check_btf_func_early that happens way before do_check_subprogs where subprog_returns_void is 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 char
 		default:
 			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 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

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)

...

Quoted 9 lines
Quoted 3 lines

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.

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?

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

[...]

author reviewer
#8 lore raw

PATCH v3 2/2 selftests: bpf: Add tests for void global subprogs

In reply to Emil Tsalapatis

Add 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
index f29fc789c14b..23d933f1aec6 100644
@@ -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
index e905cbaf6b3d..45854cbcbfcf 100644
@@ -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
index d28ecc4ee2d0..691c16001952 100644
@@ -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
new file mode 100644
index 000000000000..8b6f5776cf0f
@@ -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
new file mode 100644
index 000000000000..76707b29dc6a
@@ -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
new file mode 100644
index 000000000000..3dafb0dc2342
@@ -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();
+
+	asm volatile(
+		"r1 = r0;"
+		:::
+	);
+
+	return 0;
+}
Signature · 1 line
2.49.0
maintainer
#9 lore raw

Re: [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
new file mode 100644
index 000000000000..76707b29dc6a

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
new file mode 100644
index 000000000000..3dafb0dc2342

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();
+
+	asm volatile(
+		"r1 = r0;"
+		:::
+	);
+
+	return 0;
+}