bpf: Reject offset refcount acquire arguments
Subsystems (4)
v4 cover bpf: Reject offset refcount acquire arguments
bpf_refcount_acquire() is modeled as returning a refcounted allocation base, but it currently accepts PTR_TO_BTF_ID | MEM_ALLOC arguments whose offset already points at an embedded graph node returned from a list or rbtree operation.
At runtime the kfunc starts from the supplied pointer and adds the type's refcount offset. With a graph-node pointer, that starts from base + node_off, while the verifier treats the returned pointer as the allocation base. Reject non-zero fixed-offset arguments to keep the runtime operation and the verifier model aligned.
Programs that pop graph nodes can still acquire a reference after normalizing the node pointer with container_of().
Patch 1 handles the zero fixed-offset requirement in the existing check_func_arg_reg_off() / __check_ptr_off_reg() path without consuming a bpf_type_flag bit.
Patch 2 adds a rejected direct list-node case.
Changes from v3:
- Add Eduard's Acked-by to patch 1.
- Drop the redundant rbtree selftest case; the list case exercises the same refcount-acquire fixed-offset rejection path.
- Trim the selftest commit message and remove the selftest Fixes tag.
Changes from v2:
- Avoid adding a new bpf_type_flag bit.
- Carry the refcount-acquire zero fixed-offset requirement with an internal check_func_arg_reg_off() parameter.
Changes from v1:
- Move zero fixed-offset enforcement into check_func_arg_reg_off() / __check_ptr_off_reg(), as suggested by Eduard.
- Drop the positive container_of() selftest case.
- Remove the stale bpf_obj_drop() after bpf_list_push_front(), since the pushed reference is consumed even when the verifier explores the error branch.
- Rebase to bpf-next master a975094bf98c.
v3: https://lore.kernel.org/bpf/[email protected]/
v2: https://lore.kernel.org/bpf/[email protected]/
v1: https://lore.kernel.org/bpf/[email protected]/
Yiyang Chen (2):
bpf: Reject offset refcount acquire arguments selftests/bpf: Cover refcount acquire node offsets
kernel/bpf/verifier.c | 32 +++++++++++------ .../bpf/progs/refcounted_kptr_fail.c | 34 +++++++++++++++++++ 2 files changed, 56 insertions(+), 10 deletions(-)
base-commit: a975094bf98ca97be9146f9d3b5681a6f9cf5ce3
Signature · 1 line
2.34.1
PATCH v4 1/2 bpf: Reject offset refcount acquire arguments
bpf_refcount_acquire() increments the refcount at the caller-supplied pointer plus the refcount field offset, then returns the caller-supplied pointer unchanged.
The verifier records the return value as a base pointer to the refcounted object.
bpf_list_pop_front() and bpf_rbtree_remove() can return embedded graph-node pointers as PTR_TO_BTF_ID | MEM_ALLOC with a fixed offset equal to the node field offset. Passing such a pointer directly to bpf_refcount_acquire() currently passes the refcounted-kptr type check.
That makes the runtime operation start from base + node_off while the verifier models the returned pointer as the object base.
Require refcount-acquire arguments to have zero fixed offset by carrying the requirement through check_func_arg_reg_off() to __check_ptr_off_reg(). Programs can still acquire a refcount from a graph-node-derived pointer after normalizing it with container_of().
--- kernel/bpf/verifier.c | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-)
kernel/bpf/verifier.c +22 -10
@@ -7990,9 +7990,10 @@ reg_find_field_offset(const struct bpf_reg_state *reg, s32 off, u32 fields)return field; } -static int check_func_arg_reg_off (struct bpf_verifier_env *env, -const struct bpf_reg_state *reg,argno_t argno, -enum bpf_arg_type arg_type) +static int __check_func_arg_reg_off (struct bpf_verifier_env *env, +const struct bpf_reg_state *reg,argno_t argno, +enum bpf_arg_type arg_type, +bool btf_id_fixed_off_ok) {u32 type = reg->type;
@@ -8049,12 +8050,11 @@ static int check_func_arg_reg_off(struct bpf_verifier_env *env,case PTR_TO_BTF_ID |MEM_ALLOC |NON_OWN_REF |MEM_RCU :/* When referenced PTR_TO_BTF_ID is passed to release function, * its fixed offset must be 0. In the other cases, fixed offset -* can be non-zero. This was already checked above. So pass -* fixed_off_ok as true to allow fixed offset for all other -* cases. var_off always must be 0 for PTR_TO_BTF_ID, hence we -* still need to do checks instead of returning. +* can be non-zero unless the caller requires otherwise. +* var_off always must be 0 for PTR_TO_BTF_ID, hence we still +* need to do checks instead of returning. */ -return __check_ptr_off_reg (env, reg, argno, true); +return __check_ptr_off_reg (env, reg, argno, btf_id_fixed_off_ok);case PTR_TO_CTX :/* * Allow fixed and variable offsets for syscall context, but
@@ -8070,6 +8070,13 @@ static int check_func_arg_reg_off(struct bpf_verifier_env *env, } } +static int check_func_arg_reg_off (struct bpf_verifier_env *env, +const struct bpf_reg_state *reg,argno_t argno, +enum bpf_arg_type arg_type) +{ +return __check_func_arg_reg_off (env, reg, argno, arg_type, true); +} +static int check_arg_const_str (struct bpf_verifier_env *env,struct bpf_reg_state *reg,argno_t argno) {
@@ -11941,6 +11948,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_enum bpf_arg_type arg_type =ARG_DONTCARE ;argno_t argno =argno_from_arg (i +1 );int regno =reg_from_argno (argno); +bool btf_id_fixed_off_ok = true;u32 ref_id, type_size;bool is_ret_buf_sz = false;int kf_arg_type;
@@ -12114,7 +12122,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_MEM :case KF_ARG_PTR_TO_MEM_SIZE :case KF_ARG_PTR_TO_CALLBACK : -case KF_ARG_PTR_TO_REFCOUNTED_KPTR :case KF_ARG_PTR_TO_CONST_STR :case KF_ARG_PTR_TO_WORKQUEUE :case KF_ARG_PTR_TO_TIMER :
@@ -12128,6 +12135,10 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_CTX : arg_type =ARG_PTR_TO_CTX ;break ; +case KF_ARG_PTR_TO_REFCOUNTED_KPTR : + arg_type =ARG_PTR_TO_BTF_ID ; + btf_id_fixed_off_ok = false; +break ;default :verifier_bug (env,"unknown kfunc arg type %d" , kf_arg_type);return -EFAULT ;
@@ -12135,7 +12146,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_if (regno == meta->release_regno) arg_type |=OBJ_RELEASE ; - ret =check_func_arg_reg_off (env, reg, argno, arg_type); + ret =__check_func_arg_reg_off (env, reg, argno, arg_type, + btf_id_fixed_off_ok);if (ret <0 )return ret;
Signature · 1 line
2.34.1
[email protected]
AI reviewThis isn't a bug, but does this call need to be split across two lines? The line length limit is 100 characters, and it looks like it would fit on a single line:
Quoted 4 lines
kernel/bpf/verifier.c +0
-0
[ ... ]
kernel/bpf/verifier.c static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_ · line 12150
Quoted 7 lines
kernel/bpf/verifier.c +2
-1@@ -12135,7 +12146,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_if (regno == meta->release_regno) arg_type |=OBJ_RELEASE ; - ret =check_func_arg_reg_off (env, reg, argno, arg_type); + ret =__check_func_arg_reg_off (env, reg, argno, arg_type, + btf_id_fixed_off_ok);
This isn't a bug, but does this call need to be split across two lines? The line length limit is 100 characters, and it looks like it would fit on a single line:
ret = __check_func_arg_reg_off(env, reg, argno, arg_type, btf_id_fixed_off_ok);
kernel/bpf/verifier.c static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_ · line 12152
Quoted 2 lines
kernel/bpf/verifier.c +0
-0if (ret <0 )return ret;
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/28007209948
Emil Tsalapatis
reviewerQuoted 9 lines · bot+bpf-ci
Quoted 4 lines
kernel/bpf/verifier.c +0
-0[ ... ]
Quoted 2 lines
kernel/bpf/verifier.c +0
-0@@ -12135,7 +12146,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_
Quoted 9 lines
kernel/bpf/verifier.c static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_ · line 12150
Quoted 5 lines
kernel/bpf/verifier.c +2
-1if (regno == meta->release_regno) arg_type |=OBJ_RELEASE ; - ret =check_func_arg_reg_off (env, reg, argno, arg_type); + ret =__check_func_arg_reg_off (env, reg, argno, arg_type, + btf_id_fixed_off_ok);This isn't a bug, but does this call need to be split across two lines? The line length limit is 100 characters, and it looks like it would fit on a single line:
Bot is right, we don't split diagnostics across lines.
Quoted 12 lines
ret = __check_func_arg_reg_off(env, reg, argno, arg_type, btf_id_fixed_off_ok);kernel/bpf/verifier.c static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_ · line 12152
Quoted 2 lines
kernel/bpf/verifier.c +0
-0if (ret <0 )return ret;---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.mdCI run summary: https://github.com/kernel-patches/bpf/actions/runs/28007209948
Quoted 15 lines · Yiyang Chen
bpf_refcount_acquire()increments the refcount at the caller-supplied pointer plus the refcount field offset, then returns the caller-supplied pointer unchanged.The verifier records the return value as a base pointer to the refcounted object.
bpf_list_pop_front()andbpf_rbtree_remove()can return embedded graph-node pointers asPTR_TO_BTF_ID|MEM_ALLOCwith a fixed offset equal to the node field offset. Passing such a pointer directly tobpf_refcount_acquire()currently passes the refcounted-kptr type check.That makes the runtime operation start from base +
node_offwhile the verifier models the returned pointer as the object base.
Quoted 8 lines
Require refcount-acquire arguments to have zero fixed offset by carrying the requirement through
check_func_arg_reg_off()to__check_ptr_off_reg(). Programs can still acquire a refcount from a graph-node-derived pointer after normalizing it withcontainer_of().Fixes 7c50b1cb76aca ("bpf: Add bpf_refcount_acquire kfunc")Signed-off-by Yiyang Chen <[email protected]>Acked-by Eduard Zingerman <[email protected]>
PATCH v4 2/2 selftests/bpf: Cover refcount acquire node offsets
In reply to Yiyang ChenAdd regression coverage for bpf_refcount_acquire() on graph-node-derived pointers.
The rejected case passes a popped list node pointer directly to bpf_refcount_acquire(), which must fail because the pointer carries a non-zero fixed offset.
--- .../bpf/progs/refcounted_kptr_fail.c | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+)
tools/testing/selftests/bpf/progs/refcounted_kptr_fail.c +34 -0
@@ -13,12 +13,20 @@ struct node_acquire {struct bpf_refcount refcount; }; +struct node_refcounted { +long key; +struct bpf_list_node list; +struct bpf_refcount refcount; +}; + extern void bpf_rcu_read_lock(void) __ksym; extern void bpf_rcu_read_unlock(void) __ksym;#define private (name) SEC(".data." #name) __hidden __attribute__((aligned(8))) private(A) struct bpf_spin_lock glock; private(A) struct bpf_rb_root groot __contains(node_acquire, node); +private(B) struct bpf_spin_lock lock; +private(B) struct bpf_list_head head __contains(node_refcounted, list);static bool less (struct bpf_rb_node *a,const struct bpf_rb_node *b) {
@@ -93,6 +101,32 @@ long rbtree_refcounted_node_ref_escapes_owning_input(void *ctx)return 0 ; } +SEC("?tc") +__failure __msg("dereference of modified ptr_ ptr R1") +long refcount_acquire_list_node_offset(void *ctx) +{ +struct node_refcounted *node, *base, *ref; +struct bpf_list_node *list_node; + + node =bpf_obj_new (typeof (*node)); +if (!node) +return 1 ; + +bpf_spin_lock (&lock); +bpf_list_push_front (&head, &node->list); + list_node =bpf_list_pop_front (&head); +bpf_spin_unlock (&lock); +if (!list_node) +return 2 ; + + base = container_of(list_node, struct node_refcounted, list); + ref =bpf_refcount_acquire (list_node); +if (ref) +bpf_obj_drop (ref); +bpf_obj_drop (base); +return 0 ; +} + SEC("?fentry.s/" SYS_PREFIX "sys_getpgid") __failure __msg("function calls are not allowed while holding a lock") int BPF_PROG(rbtree_fail_sleepable_lock_across_rcu,
Signature · 1 line
2.34.1
Re: [PATCH bpf-next v4 2/2] selftests/bpf: Cover refcount acquire node offsets
Quoted 8 lines · Yiyang Chen
Add regression coverage for
bpf_refcount_acquire()on graph-node-derived pointers.The rejected case passes a popped list node pointer directly to
bpf_refcount_acquire(), which must fail because the pointer carries a non-zero fixed offset.Signed-off-by Yiyang Chen <[email protected]>
Quoted 62 lines
--- .../bpf/progs/refcounted_kptr_fail.c | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+)tools/testing/selftests/bpf/progs/refcounted_kptr_fail.c +34
-0@@ -13,12 +13,20 @@ struct node_acquire {struct bpf_refcount refcount; }; +struct node_refcounted { +long key; +struct bpf_list_node list; +struct bpf_refcount refcount; +}; + extern void bpf_rcu_read_lock(void) __ksym; extern void bpf_rcu_read_unlock(void) __ksym;#define private (name) SEC(".data." #name) __hidden __attribute__((aligned(8))) private(A) struct bpf_spin_lock glock; private(A) struct bpf_rb_root groot __contains(node_acquire, node); +private(B) struct bpf_spin_lock lock; +private(B) struct bpf_list_head head __contains(node_refcounted, list);static bool less (struct bpf_rb_node *a,const struct bpf_rb_node *b) {@@ -93,6 +101,32 @@ long rbtree_refcounted_node_ref_escapes_owning_input(void *ctx)return 0 ; } +SEC("?tc") +__failure __msg("dereference of modified ptr_ ptr R1") +long refcount_acquire_list_node_offset(void *ctx) +{ +struct node_refcounted *node, *base, *ref; +struct bpf_list_node *list_node; + + node =bpf_obj_new (typeof (*node)); +if (!node) +return 1 ; + +bpf_spin_lock (&lock); +bpf_list_push_front (&head, &node->list); + list_node =bpf_list_pop_front (&head); +bpf_spin_unlock (&lock); +if (!list_node) +return 2 ; + + base = container_of(list_node, struct node_refcounted, list); + ref =bpf_refcount_acquire (list_node); +if (ref) +bpf_obj_drop (ref); +bpf_obj_drop (base); +return 0 ; +} + SEC("?fentry.s/" SYS_PREFIX "sys_getpgid") __failure __msg("function calls are not allowed while holding a lock") int BPF_PROG(rbtree_fail_sleepable_lock_across_rcu,
Re: [PATCH bpf-next v4 2/2] selftests/bpf: Cover refcount acquire node offsets
In reply to Yiyang ChenQuoted 8 lines · Yiyang Chen
Add regression coverage for
bpf_refcount_acquire()on graph-node-derived pointers.The rejected case passes a popped list node pointer directly to
bpf_refcount_acquire(), which must fail because the pointer carries a non-zero fixed offset.Signed-off-by Yiyang Chen <[email protected]>
This series was applied to bpf/bpf.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf.git (master)
by Alexei Starovoitov <[email protected]>:
Quoted 5 lines · On Tue, 23 Jun 2026 06:11:08 +0000 you wrote:
bpf_refcount_acquire()is modeled as returning a refcounted allocation base, but it currently acceptsPTR_TO_BTF_ID|MEM_ALLOCarguments whose offset already points at an embedded graph node returned from a list or rbtree operation.
Quoted 7 lines
At runtime the kfunc starts from the supplied pointer and adds the type's refcount offset. With a graph-node pointer, that starts from base +
node_off, while the verifier treats the returned pointer as the allocation base. Reject non-zero fixed-offset arguments to keep the runtime operation and the verifier model aligned.[...]
Here is the summary with links:
- [bpf-next,v4,1/2] bpf: Reject offset refcount acquire arguments
https://git.kernel.org/bpf/bpf/c/931a577fc79e - [bpf-next,v4,2/2] selftests/bpf: Cover refcount acquire node offsets https://git.kernel.org/bpf/bpf/c/0371fb57a0c9
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html