bpf: Teach verifier that trusted PTR_TO_BTF_ID pointers are non-NULL
Subsystems (4)
PATCH 1/2 bpf: Teach verifier that trusted PTR_TO_BTF_ID pointers are non-NULL
In reg_type_not_null(), we currently assume that a pointer may be NULL if it has the PTR_MAYBE_NULL modifier, or if it doesn't belong to one of several base type of pointers that are never NULL-able. For example, PTR_TO_CTX, PTR_TO_MAP_VALUE, etc.
It turns out that in some cases, PTR_TO_BTF_ID can never be NULL as well, though we currently don't specify it. For example, if you had the following program:
SEC("tc")
long example_refcnt_fail(void *ctx)
{
struct bpf_cpumask *mask1, *mask2;
mask1 = bpf_cpumask_create();
mask2 = bpf_cpumask_create();
if (!mask1 || !mask2)
goto error_release;
bpf_cpumask_test_cpu(0, (const struct cpumask *)mask1);
bpf_cpumask_test_cpu(0, (const struct cpumask *)mask2);error_release:
if (mask1) bpf_cpumask_release(mask1); if (mask2) bpf_cpumask_release(mask2); return ret; }
The verifier will incorrectly fail to load the program, thinking (unintuitively) that we have a possibly-unreleased reference if the mask is NULL, because we (correctly) don't issue a bpf_cpumask_release() on the NULL path.
The reason the verifier gets confused is due to the fact that we don't explicitly tell the verifier that trusted PTR_TO_BTF_ID pointers can never be NULL. Basically, if we successfully get past the if check (meaning both pointers go from ptr_or_null_bpf_cpumask to ptr_bpf_cpumask), the verifier will correctly assume that the references need to be dropped on any possible branch that leads to program exit. However, it will _incorrectly_ think that the ptr == NULL branch is possible, and will erroneously detect it as a branch on which we failed to drop the reference.
The solution is of course to teach the verifier that trusted PTR_TO_BTF_ID pointers can never be NULL, so that it doesn't incorrectly think it's possible for the reference to be present on the ptr == NULL branch.
A follow-on patch will add a selftest that verifies this behavior.
--- kernel/bpf/verifier.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +7 -2
@@ -197,6 +197,7 @@ static int ref_set_non_owning(struct bpf_verifier_env *env, struct bpf_reg_state *reg);static void specialize_kfunc (struct bpf_verifier_env *env,u32 func_id,u16 offset,unsigned long *addr); +static bool is_trusted_reg (const struct bpf_reg_state *reg);static bool bpf_map_ptr_poisoned (const struct bpf_insn_aux_data *aux) {
@@ -439,8 +440,11 @@ static bool type_may_be_null(u32 type)return type &PTR_MAYBE_NULL ; } -static bool reg_type_not_null (enum bpf_reg_type type) +static bool reg_not_null (const struct bpf_reg_state *reg) { +enum bpf_reg_type type; + + type = reg->type;if (type_may_be_null (type))return false;
@@ -450,6 +454,7 @@ static bool reg_type_not_null(enum bpf_reg_type type) type ==PTR_TO_MAP_VALUE || type ==PTR_TO_MAP_KEY || type ==PTR_TO_SOCK_COMMON || + (type ==PTR_TO_BTF_ID &&is_trusted_reg (reg)) || type ==PTR_TO_MEM ; }
@@ -13157,7 +13162,7 @@ static int is_branch_taken(struct bpf_reg_state *reg, u64 val, u8 opcode, bool is_jmp32) {if (__is_pointer_value (false, reg)) { -if (!reg_type_not_null (reg->type)) +if (!reg_not_null (reg))return -1 ;/* If pointer is valid tests against zero will fail so we can
Signature · 1 line
2.40.1
PATCH 2/2 selftests/bpf: Add test for non-NULLable PTR_TO_BTF_IDs
In a recent patch, we taught the verifier that trusted PTR_TO_BTF_ID can never be NULL. This prevents the verifier from incorrectly failing to load certain programs where it gets confused and thinks a reference isn't dropped because it incorrectly assumes that a branch exists in which a NULL PTR_TO_BTF_ID pointer is never released.
This patch adds a testcase that verifies this cannot happen.
--- .../selftests/bpf/prog_tests/cpumask.c | 1 + .../selftests/bpf/progs/cpumask_success.c | 24 +++++++++++++++++++ 2 files changed, 25 insertions(+)
tools/testing/selftests/bpf/prog_tests/cpumask.c +1 -0
@@ -70,5 +70,6 @@ void test_cpumask(void)verify_success (cpumask_success_testcases[i]); } +RUN_TESTS (cpumask_success);RUN_TESTS (cpumask_failure); }
tools/testing/selftests/bpf/progs/cpumask_success.c +24 -0
@@ -5,6 +5,7 @@#include <bpf/bpf_tracing.h> #include <bpf/bpf_helpers.h> +#include "bpf_misc.h" #include "cpumask_common.h" char _license[] SEC("license") = "GPL";
@@ -426,3 +427,26 @@ int BPF_PROG(test_global_mask_rcu, struct task_struct *task, u64 clone_flags)return 0 ; } + +SEC("tp_btf/task_newtask") +__success +int BPF_PROG (test_refcount_null_tracking ,struct task_struct *task,u64 clone_flags) +{ +struct bpf_cpumask *mask1, *mask2; + + mask1 =bpf_cpumask_create (); + mask2 =bpf_cpumask_create (); + +if (!mask1 || !mask2) + goto free_masks_return; + +bpf_cpumask_test_cpu (0 , (const struct cpumask *)mask1); +bpf_cpumask_test_cpu (0 , (const struct cpumask *)mask2); + +free_masks_return: +if (mask1) +bpf_cpumask_release (mask1); +if (mask2) +bpf_cpumask_release (mask2); +return 0 ; +}
Signature · 1 line
2.40.1
Re: [PATCH bpf-next 2/2] selftests/bpf: Add test for non-NULLable PTR_TO_BTF_IDs
Quoted 9 lines · David Vernet
In a recent patch, we taught the verifier that trusted
PTR_TO_BTF_IDcan never be NULL. This prevents the verifier from incorrectly failing to load certain programs where it gets confused and thinks a reference isn't dropped because it incorrectly assumes that a branch exists in which a NULLPTR_TO_BTF_IDpointer is never released.This patch adds a testcase that verifies this cannot happen.
Signed-off-by David Vernet <[email protected]>
I hope someone else can look at the actual change. It looks good to me conceptually, but not sure what other parts it might affect.
Quoted 58 lines
--- .../selftests/bpf/prog_tests/cpumask.c | 1 + .../selftests/bpf/progs/cpumask_success.c | 24 +++++++++++++++++++ 2 files changed, 25 insertions(+)tools/testing/selftests/bpf/prog_tests/cpumask.c +1
-0@@ -70,5 +70,6 @@ void test_cpumask(void)verify_success (cpumask_success_testcases[i]); } +RUN_TESTS (cpumask_success);RUN_TESTS (cpumask_failure); }tools/testing/selftests/bpf/progs/cpumask_success.c +24
-0@@ -5,6 +5,7 @@#include <bpf/bpf_tracing.h> #include <bpf/bpf_helpers.h> +#include "bpf_misc.h" #include "cpumask_common.h" char _license[] SEC("license") = "GPL";@@ -426,3 +427,26 @@ int BPF_PROG(test_global_mask_rcu, struct task_struct *task, u64 clone_flags)return 0 ; } + +SEC("tp_btf/task_newtask") +__success +int BPF_PROG (test_refcount_null_tracking ,struct task_struct *task,u64 clone_flags) +{ +struct bpf_cpumask *mask1, *mask2; + + mask1 =bpf_cpumask_create (); + mask2 =bpf_cpumask_create (); + +if (!mask1 || !mask2) + goto free_masks_return; + +bpf_cpumask_test_cpu (0 , (const struct cpumask *)mask1); +bpf_cpumask_test_cpu (0 , (const struct cpumask *)mask2); + +free_masks_return: +if (mask1) +bpf_cpumask_release (mask1); +if (mask2) +bpf_cpumask_release (mask2); +return 0 ; +}Signature · 1 line
2.40.1
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 10 lines · On Fri, 2 Jun 2023 10:01:11 -0500 you wrote:
In
reg_type_not_null(), we currently assume that a pointer may be NULL if it has thePTR_MAYBE_NULLmodifier, or if it doesn't belong to one of several base type of pointers that are never NULL-able. For example,PTR_TO_CTX,PTR_TO_MAP_VALUE, etc.It turns out that in some cases,
PTR_TO_BTF_IDcan never be NULL as well, though we currently don't specify it. For example, if you had the following program:[...]
Here is the summary with links:
- [bpf-next,1/2] bpf: Teach verifier that trusted PTR_TO_BTF_ID pointers are non-NULL
https://git.kernel.org/bpf/bpf-next/c/51302c951c8f - [bpf-next,2/2] selftests/bpf: Add test for non-NULLable PTR_TO_BTF_IDs https://git.kernel.org/bpf/bpf-next/c/f904c67876c4
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html