bpf: check attach_func_proto more carefully in check_return_code
Subsystems (4)
PATCH v2 1/1 bpf: check attach_func_proto more carefully in check_return_code
Syzkaller reports the following crash:
RIP: 0010:check_return_code kernel/bpf/verifier.c:10575 [inline] RIP: 0010:do_check kernel/bpf/verifier.c:12346 [inline] RIP: 0010:do_check_common+0xb3d2/0xd250 kernel/bpf/verifier.c:14610
With the following reproducer:
bpf$PROG_LOAD_XDP(0x5, &(0x7f00000004c0)={0xd, 0x3, &(0x7f0000000000)=ANY=[@ANYBLOB="1800000000000019000000000000000095"], &(0x7f0000000300)='GPL\x00', 0x0, 0x0, 0x0, 0x0, 0x0, '\x00', 0x0, 0x2b, 0xffffffffffffffff, 0x8, 0x0, 0x0, 0x10, 0x0}, 0x80)
Because we don't enforce expected_attach_type for XDP programs, we end up in hitting 'if (prog->expected_attach_type == BPF_LSM_CGROUP' part in check_return_code and follow up with testing prog->aux->attach_func_proto->type, but prog->aux->attach_func_proto is NULL.
Add explicit prog_type check for the "Note, BPF_LSM_CGROUP that attach ..." condition. Also, don't skip return code check for LSM/STRUCT_OPS.
The above actually brings an issue with existing selftest which tries to return EPERM from void inet_csk_clone. Fix the test (and move called_socket_clone to make sure it's not incremented in case of an error) and add a new one to explicitly verify this condition.
v2:
- Martin: don't add new helper, check prog_type instead
- Martin: check expected_attach_type as well at the function entry
- Update selftest to verify this condition
--- kernel/bpf/verifier.c | 2 ++ .../testing/selftests/bpf/prog_tests/lsm_cgroup.c | 12 ++++++++++++ tools/testing/selftests/bpf/progs/lsm_cgroup.c | 12 ++++++------ .../selftests/bpf/progs/lsm_cgroup_nonvoid.c | 14 ++++++++++++++ 4 files changed, 34 insertions(+), 6 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.c
kernel/bpf/verifier.c +2 -0
@@ -10445,6 +10445,7 @@ static int check_return_code(struct bpf_verifier_env *env)/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && + prog->expected_attach_type !=BPF_LSM_CGROUP && (prog_type ==BPF_PROG_TYPE_STRUCT_OPS || prog_type ==BPF_PROG_TYPE_LSM ) && !prog->aux->attach_func_proto->type)
@@ -10572,6 +10573,7 @@ static int check_return_code(struct bpf_verifier_env *env)if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" );if (prog->expected_attach_type ==BPF_LSM_CGROUP && + prog_type ==BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type)verbose (env,"Note, BPF_LSM_CGROUP that attach to void LSM hooks can't modify return value!\n" );return -EINVAL ;
tools/testing/selftests/bpf/prog_tests/lsm_cgroup.c +12 -0
@@ -6,6 +6,7 @@#include <bpf/btf.h> #include "lsm_cgroup.skel.h" +#include "lsm_cgroup_nonvoid.skel.h" #include "cgroup_helpers.h" #include "network_helpers.h"
@@ -293,9 +294,20 @@ static void test_lsm_cgroup_functional(void)lsm_cgroup__destroy (skel); } +static void test_lsm_cgroup_nonvoid (void ) +{ +struct lsm_cgroup_nonvoid *skel =NULL ; + + skel =lsm_cgroup_nonvoid__open_and_load (); +ASSERT_NULL (skel,"open succeeds" ); +lsm_cgroup_nonvoid__destroy (skel); +} +void test_lsm_cgroup (void ) {if (test__start_subtest ("functional" ))test_lsm_cgroup_functional (); +if (test__start_subtest ("nonvoid" )) +test_lsm_cgroup_nonvoid ();btf__free (btf); }
tools/testing/selftests/bpf/progs/lsm_cgroup.c +6 -6
@@ -156,25 +156,25 @@ int BPF_PROG(socket_clone, struct sock *newsk, const struct request_sock *req) {int prio =234 ; - called_socket_clone++; -if (!newsk)return 1 ;/* Accepted request sockets get a different priority. */ if (bpf_setsockopt (newsk,SOL_SOCKET ,SO_PRIORITY , &prio,sizeof (prio))) -return 0 ;/* EPERM */ +return 1 ;/* Make sure bpf_getsockopt is allowed and works. */ prio =0 ;if (bpf_getsockopt (newsk,SOL_SOCKET ,SO_PRIORITY , &prio,sizeof (prio))) -return 0 ;/* EPERM */ +return 1 ;if (prio !=234 ) -return 0 ;/* EPERM */ +return 1 ;/* Can access cgroup local storage. */ if (!test_local_storage ()) -return 0 ;/* EPERM */ +return 1 ; + + called_socket_clone++;return 1 ; }
tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.c new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +SEC("lsm_cgroup/inet_csk_clone") +int BPF_PROG (nonvoid_socket_clone ,struct sock *newsk,const struct request_sock *req) +{ +/* Can not return any errors from void LSM hooks. */ +return 0 ; +}
Signature · 1 line
2.37.0.rc0.161.g10f37bed90-goog
Quoted 45 lines · Stanislav Fomichev
Syzkaller reports the following crash:
RIP: 0010:check_return_code kernel/bpf/verifier.c:10575 [inline] RIP: 0010:do_check kernel/bpf/verifier.c:12346 [inline] RIP: 0010:do_check_common+0xb3d2/0xd250 kernel/bpf/verifier.c:14610With the following reproducer:
bpf$PROG_LOAD_XDP(0x5, &(0x7f00000004c0)={0xd,0x3, &(0x7f0000000000)=ANY=[@ANYBLOB="1800000000000019000000000000000095"], &(0x7f0000000300)='GPL\x00',0x0,0x0,0x0,0x0,0x0, '\x00',0x0,0x2b,0xffffffffffffffff,0x8,0x0,0x0,0x10,0x0},0x80)Because we don't enforce
expected_attach_typefor XDP programs, we end up in hitting 'if (prog->expected_attach_type==BPF_LSM_CGROUP' part incheck_return_codeand follow up with testingprog->aux->attach_func_proto->type, butprog->aux->attach_func_protois NULL.Add explicit
prog_typecheck for the "Note,BPF_LSM_CGROUPthat attach ..." condition. Also, don't skip return code check for LSM/STRUCT_OPS.The above actually brings an issue with existing selftest which tries to return EPERM from void
inet_csk_clone. Fix the test (and movecalled_socket_cloneto make sure it's not incremented in case of an error) and add a new one to explicitly verify this condition.v2:
- Martin: don't add new helper, checkprog_typeinstead
- Martin: checkexpected_attach_typeas well at the function entry
- Update selftest to verify this conditionFixes 69fd337a975c ("bpf: per-cgroup lsm flavor")Reported-by [email protected]Signed-off-by Stanislav Fomichev <[email protected]>--- kernel/bpf/verifier.c | 2 ++ .../testing/selftests/bpf/prog_tests/lsm_cgroup.c | 12 ++++++++++++ tools/testing/selftests/bpf/progs/lsm_cgroup.c | 12 ++++++------ .../selftests/bpf/progs/lsm_cgroup_nonvoid.c | 14 ++++++++++++++ 4 files changed, 34 insertions(+), 6 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.ckernel/bpf/verifier.c +0
-0
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env) · line 10448
Quoted 4 lines
kernel/bpf/verifier.c +1
-0@@ -10445,6 +10445,7 @@ static int check_return_code(struct bpf_verifier_env *env)/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && + prog->expected_attach_type != BPF_LSM_CGROUP &&
BPF_PROG_TYPE_STRUCT_OPS also uses the expected_attach_type, so the expected_attach_type check should only be done for LSM prog alone. Others lgtm.
Quoted 11 lines
kernel/bpf/verifier.c +1
-0(prog_type ==BPF_PROG_TYPE_STRUCT_OPS || prog_type ==BPF_PROG_TYPE_LSM ) && !prog->aux->attach_func_proto->type)@@ -10572,6 +10573,7 @@ static int check_return_code(struct bpf_verifier_env *env)if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" );if (prog->expected_attach_type ==BPF_LSM_CGROUP && + prog_type ==BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type)verbose (env,"Note, BPF_LSM_CGROUP that attach to void LSM hooks can't modify return value!\n" );return -EINVAL ;
Quoted 50 lines · Martin KaFai Lau
Quoted 7 lines · Stanislav Fomichev
Syzkaller reports the following crash:
RIP: 0010:check_return_code kernel/bpf/verifier.c:10575 [inline] RIP: 0010:do_check kernel/bpf/verifier.c:12346 [inline] RIP: 0010:do_check_common+0xb3d2/0xd250 kernel/bpf/verifier.c:14610With the following reproducer:
bpf$PROG_LOAD_XDP(0x5, &(0x7f00000004c0)={0xd,0x3,&(0x7f0000000000)=ANY=[@ANYBLOB="1800000000000019000000000000000095"], &(0x7f0000000300)='GPL\x00',
0x0,0x0,0x0,0x0,0x0, '\x00',0x0,0x2b,0xffffffffffffffff,0x8,0x0,0x0,0x10,0x0},0x80)Quoted 25 lines
Because we don't enforce
expected_attach_typefor XDP programs, we end up in hitting 'if (prog->expected_attach_type==BPF_LSM_CGROUP' part incheck_return_codeand follow up with testingprog->aux->attach_func_proto->type, butprog->aux->attach_func_protois NULL.Add explicit
prog_typecheck for the "Note,BPF_LSM_CGROUPthat attach ..." condition. Also, don't skip return code check for LSM/STRUCT_OPS.The above actually brings an issue with existing selftest which tries to return EPERM from void
inet_csk_clone. Fix the test (and movecalled_socket_cloneto make sure it's not incremented in case of an error) and add a new one to explicitly verify this condition.v2:
- Martin: don't add new helper, checkprog_typeinstead
- Martin: checkexpected_attach_typeas well at the function entry
- Update selftest to verify this conditionFixes 69fd337a975c ("bpf: per-cgroup lsm flavor")Reported-by [email protected]Signed-off-by Stanislav Fomichev <[email protected]>Quoted 7 lines
--- kernel/bpf/verifier.c | 2 ++ .../testing/selftests/bpf/prog_tests/lsm_cgroup.c | 12 ++++++++++++ tools/testing/selftests/bpf/progs/lsm_cgroup.c | 12 ++++++------ .../selftests/bpf/progs/lsm_cgroup_nonvoid.c | 14 ++++++++++++++ 4 files changed, 34 insertions(+), 6 deletions(-) create mode 100644
tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.ckernel/bpf/verifier.c static int check_return_code(struct
Quoted 6 lines
kernel/bpf/verifier.c +0
-0@@ -10445,6 +10445,7 @@ static int check_return_code(struct
bpf_verifier_env*env)Quoted 1 line
Quoted 6 lines
kernel/bpf/verifier.c
Quoted 3 lines
kernel/bpf/verifier.c +1
-0/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && + prog->expected_attach_type != BPF_LSM_CGROUP &&
BPF_PROG_TYPE_STRUCT_OPSalso uses theexpected_attach_type, so theexpected_attach_typecheck should only be done for LSM prog alone. Others lgtm.
In this case, something like the following should be sufficient?
kernel/bpf/verifier.c +7 -5
@@ -10445,11 +10445,13 @@ static int check_return_code(struct bpf_verifier_env *env)/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && - prog->expected_attach_type !=BPF_LSM_CGROUP && - (prog_type ==BPF_PROG_TYPE_STRUCT_OPS || - prog_type ==BPF_PROG_TYPE_LSM ) && - !prog->aux->attach_func_proto->type) -return 0 ; + !prog->aux->attach_func_proto->type) { +if (prog_type ==BPF_PROG_TYPE_STRUCT_OPS ) +return 0 ; +if (prog_type ==BPF_PROG_TYPE_LSM && + prog->expected_attach_type !=BPF_LSM_CGROUP ) +return 0 ; + }/* eBPF calling convention is such that R0 is used * to return the value from eBPF program.
Quoted 13 lines
kernel/bpf/verifier.c static int check_return_code(struct
Quoted 4 lines
kernel/bpf/verifier.c +0
-0(prog_type ==BPF_PROG_TYPE_STRUCT_OPS || prog_type ==BPF_PROG_TYPE_LSM ) && !prog->aux->attach_func_proto->type)@@ -10572,6 +10573,7 @@ static int check_return_code(struct
bpf_verifier_env*env)kernel/bpf/verifier.c static int check_return_code(struct · line 10578
Quoted 6 lines
kernel/bpf/verifier.c +1
-0if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" );if (prog->expected_attach_type ==BPF_LSM_CGROUP && + prog_type ==BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type) verbose(env, "Note, BPF_LSM_CGROUP that attach to void LSM hookscan't modify return value!\n");
Quoted 1 line
kernel/bpf/verifier.c +0
-0return -EINVAL ;
Quoted 67 lines · On Thu, Jul 07, 2022 at 12:18:33PM -0700, [email protected] wrote:
Quoted 52 lines · Martin KaFai Lau
Quoted 7 lines · Stanislav Fomichev
Syzkaller reports the following crash:
RIP: 0010:check_return_code kernel/bpf/verifier.c:10575 [inline] RIP: 0010:do_check kernel/bpf/verifier.c:12346 [inline] RIP: 0010:do_check_common+0xb3d2/0xd250 kernel/bpf/verifier.c:14610With the following reproducer:
bpf$PROG_LOAD_XDP(0x5, &(0x7f00000004c0)={0xd,0x3,&(0x7f0000000000)=ANY=[@ANYBLOB="1800000000000019000000000000000095"], &(0x7f0000000300)='GPL\x00',
0x0,0x0,0x0,0x0,0x0, '\x00',0x0,0x2b,0xffffffffffffffff,0x8,0x0,0x0,0x10,0x0},0x80)Quoted 25 lines
Because we don't enforce
expected_attach_typefor XDP programs, we end up in hitting 'if (prog->expected_attach_type==BPF_LSM_CGROUP' part incheck_return_codeand follow up with testingprog->aux->attach_func_proto->type, butprog->aux->attach_func_protois NULL.Add explicit
prog_typecheck for the "Note,BPF_LSM_CGROUPthat attach ..." condition. Also, don't skip return code check for LSM/STRUCT_OPS.The above actually brings an issue with existing selftest which tries to return EPERM from void
inet_csk_clone. Fix the test (and movecalled_socket_cloneto make sure it's not incremented in case of an error) and add a new one to explicitly verify this condition.v2:
- Martin: don't add new helper, checkprog_typeinstead
- Martin: checkexpected_attach_typeas well at the function entry
- Update selftest to verify this conditionFixes 69fd337a975c ("bpf: per-cgroup lsm flavor")Reported-by [email protected]Signed-off-by Stanislav Fomichev <[email protected]>Quoted 7 lines
--- kernel/bpf/verifier.c | 2 ++ .../testing/selftests/bpf/prog_tests/lsm_cgroup.c | 12 ++++++++++++ tools/testing/selftests/bpf/progs/lsm_cgroup.c | 12 ++++++------ .../selftests/bpf/progs/lsm_cgroup_nonvoid.c | 14 ++++++++++++++ 4 files changed, 34 insertions(+), 6 deletions(-) create mode 100644
tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.ckernel/bpf/verifier.c static int check_return_code(struct
Quoted 6 lines
kernel/bpf/verifier.c +0
-0@@ -10445,6 +10445,7 @@ static int check_return_code(struct
bpf_verifier_env*env)Quoted 1 line
Quoted 6 lines
kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env)
Quoted 3 lines
kernel/bpf/verifier.c +1
-0/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && + prog->expected_attach_type != BPF_LSM_CGROUP &&
BPF_PROG_TYPE_STRUCT_OPSalso uses theexpected_attach_type, so theexpected_attach_typecheck should only be done for LSM prog alone. Others lgtm.In this case, something like the following should be sufficient?
kernel/bpf/verifier.c +0
-0
kernel/bpf/verifier.c static int check_return_code(struct · line 10449
Quoted 10 lines
kernel/bpf/verifier.c +1
-5@@ -10445,11 +10445,13 @@ static int check_return_code(struct bpf_verifier_env *env)/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && - prog->expected_attach_type !=BPF_LSM_CGROUP && - (prog_type ==BPF_PROG_TYPE_STRUCT_OPS || - prog_type ==BPF_PROG_TYPE_LSM ) && - !prog->aux->attach_func_proto->type) -return 0 ; + !prog->aux->attach_func_proto->type) {
prog_type check has to be done first since prog->aux->attach_func_proto depends on the prog_type.
How about a small tweak on top of yours ?
/* LSM and struct_ops func-ptr's return type could be "void" */
if (!is_subprog) {
switch (prog_type) {
case BPF_PROG_TYPE_LSM:
if (prog->expected_attach_type == BPF_LSM_CGROUP)
/* cgroup prog needs to return 0 or 1 */
break;
fallthrough;
case BPF_PROG_TYPE_STRUCT_OPS:
if (!prog->aux->attach_func_proto->type)
return 0;
break;
default:
break;
}
}Quoted 23 lines
kernel/bpf/verifier.c +6
-0+if (prog_type ==BPF_PROG_TYPE_STRUCT_OPS ) +return 0 ; +if (prog_type ==BPF_PROG_TYPE_LSM && + prog->expected_attach_type !=BPF_LSM_CGROUP ) +return 0 ; + }/* eBPF calling convention is such that R0 is used * to return the value from eBPF program.
Quoted 13 lines
kernel/bpf/verifier.c static int check_return_code(struct
Quoted 4 lines
kernel/bpf/verifier.c +0
-0(prog_type ==BPF_PROG_TYPE_STRUCT_OPS || prog_type ==BPF_PROG_TYPE_LSM ) && !prog->aux->attach_func_proto->type)@@ -10572,6 +10573,7 @@ static int check_return_code(struct
bpf_verifier_env*env)kernel/bpf/verifier.c static int check_return_code(struct · line 10578
Quoted 6 lines
kernel/bpf/verifier.c +1
-0if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" );if (prog->expected_attach_type ==BPF_LSM_CGROUP && + prog_type ==BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type) verbose(env, "Note, BPF_LSM_CGROUP that attach to void LSM hookscan't modify return value!\n");
Quoted 1 line
kernel/bpf/verifier.c +0
-0return -EINVAL ;
Quoted 82 lines · Martin KaFai Lau
Quoted 67 lines · On Thu, Jul 07, 2022 at 12:18:33PM -0700, [email protected] wrote:
Quoted 52 lines · Martin KaFai Lau
Quoted 7 lines · Stanislav Fomichev
Syzkaller reports the following crash:
RIP: 0010:check_return_code kernel/bpf/verifier.c:10575 [inline] RIP: 0010:do_check kernel/bpf/verifier.c:12346 [inline] RIP: 0010:do_check_common+0xb3d2/0xd250 kernel/bpf/verifier.c:14610With the following reproducer:
bpf$PROG_LOAD_XDP(0x5, &(0x7f00000004c0)={0xd,0x3,&(0x7f0000000000)=ANY=[@ANYBLOB="1800000000000019000000000000000095"], &(0x7f0000000300)='GPL\x00',
0x0,0x0,0x0,0x0,0x0, '\x00',0x0,0x2b,0xffffffffffffffff,0x8,0x0,0x0,0x10,0x0},0x80)Quoted 25 lines
Because we don't enforce
expected_attach_typefor XDP programs, we end up in hitting 'if (prog->expected_attach_type==BPF_LSM_CGROUP' part incheck_return_codeand follow up with testingprog->aux->attach_func_proto->type, butprog->aux->attach_func_protois NULL.Add explicit
prog_typecheck for the "Note,BPF_LSM_CGROUPthat attach ..." condition. Also, don't skip return code check for LSM/STRUCT_OPS.The above actually brings an issue with existing selftest which tries to return EPERM from void
inet_csk_clone. Fix the test (and movecalled_socket_cloneto make sure it's not incremented in case of an error) and add a new one to explicitly verify this condition.v2:
- Martin: don't add new helper, checkprog_typeinstead
- Martin: checkexpected_attach_typeas well at the function entry
- Update selftest to verify this conditionFixes 69fd337a975c ("bpf: per-cgroup lsm flavor")Reported-by [email protected]Signed-off-by Stanislav Fomichev <[email protected]>Quoted 7 lines
--- kernel/bpf/verifier.c | 2 ++ .../testing/selftests/bpf/prog_tests/lsm_cgroup.c | 12 ++++++++++++ tools/testing/selftests/bpf/progs/lsm_cgroup.c | 12 ++++++------ .../selftests/bpf/progs/lsm_cgroup_nonvoid.c | 14 ++++++++++++++ 4 files changed, 34 insertions(+), 6 deletions(-) create mode 100644
tools/testing/selftests/bpf/progs/lsm_cgroup_nonvoid.ckernel/bpf/verifier.c static int check_return_code(struct
Quoted 6 lines
kernel/bpf/verifier.c +0
-0@@ -10445,6 +10445,7 @@ static int check_return_code(struct
bpf_verifier_env*env)Quoted 1 line
Quoted 6 lines
Quoted 3 lines
/* LSM and
struct_opsfunc-ptr's return type could be "void" */ if (!is_subprog &&
+prog->expected_attach_type!=BPF_LSM_CGROUP&&
BPF_PROG_TYPE_STRUCT_OPSalso uses theexpected_attach_type, so theexpected_attach_typecheck should only be done for LSM prog alone. Others lgtm.In this case, something like the following should be sufficient?
kernel/bpf/verifier.c +0
-0kernel/bpf/verifier.c static int check_return_code(struct · line 10449
Quoted 10 lines
kernel/bpf/verifier.c +1
-5@@ -10445,11 +10445,13 @@ static int check_return_code(struct bpf_verifier_env *env)/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog && - prog->expected_attach_type !=BPF_LSM_CGROUP && - (prog_type ==BPF_PROG_TYPE_STRUCT_OPS || - prog_type ==BPF_PROG_TYPE_LSM ) && - !prog->aux->attach_func_proto->type) -return 0 ; + !prog->aux->attach_func_proto->type) {
prog_typecheck has to be done first sinceprog->aux->attach_func_protodepends on theprog_type.
Quoted 1 line
How about a small tweak on top of yours ?
Looks good, thanks! Will test and resend sometime tomorrow.
Quoted 40 lines
/* LSM and struct_ops func-ptr's return type could be "void" */ if (!is_subprog) { switch (prog_type) { case BPF_PROG_TYPE_LSM: if (prog->expected_attach_type == BPF_LSM_CGROUP) /* cgroup prog needs to return 0 or 1 */ break; fallthrough; case BPF_PROG_TYPE_STRUCT_OPS: if (!prog->aux->attach_func_proto->type) return 0; break; default: break; } }Quoted 23 lines
kernel/bpf/verifier.c +6
-0+if (prog_type ==BPF_PROG_TYPE_STRUCT_OPS ) +return 0 ; +if (prog_type ==BPF_PROG_TYPE_LSM && + prog->expected_attach_type !=BPF_LSM_CGROUP ) +return 0 ; + }/* eBPF calling convention is such that R0 is used * to return the value from eBPF program.
Quoted 13 lines
kernel/bpf/verifier.c static int check_return_code(struct
Quoted 4 lines
(prog_type == BPF_PROG_TYPE_STRUCT_OPS || prog_type == BPF_PROG_TYPE_LSM) && !prog->aux->attach_func_proto->type)kernel/bpf/verifier.c +0
-0@@ -10572,6 +10573,7 @@ static int check_return_code(struct
bpf_verifier_env*env)kernel/bpf/verifier.c static int check_return_code(struct · line 10578
Quoted 6 lines
kernel/bpf/verifier.c +1
-0if (!tnum_in (range, reg->var_off)) {verbose_invalid_scalar (env, reg, &range,"program exit" ,"R0" );if (prog->expected_attach_type ==BPF_LSM_CGROUP && + prog_type ==BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type) verbose(env, "Note, BPF_LSM_CGROUP that attach to void LSM hookscan't modify return value!\n");
Quoted 1 line
kernel/bpf/verifier.c +0
-0return -EINVAL ;