Generate bpf_func_proto for kfunc
Subsystems (11)
v3 cover Generate bpf_func_proto for kfunc
Hi,
This is the second of three patch sets to unify kfunc and helper argument verification. It:
1) further aligns the kfunc and helper argument checks,
2) makes kfunc argument type classification depend solely on BTF, and
3) generates a bpf_func_proto for each kfunc.
With classification now a pure function of the kfunc's BTF, it is computed once at add-call time and cached in the generated bpf_func_proto, rather than re-derived on every verification of the call. Along the way it also fixes a few issues.
The next patch set will align the argument register compatibility checks and route helper and kfunc argument verification through a single shared function.
[1/3] https://lore.kernel.org/bpf/[email protected]/
Changelog
v2 -> v3:
- Drop a patch that introduces SCALAR_MAYBE_ZERO (Eduard)
- Drop patch make helper handle mem+size at mem arg, and instead make kfunc also handle mem+size at size
- patch 5: New patch replacing temporary mark_ptr_not_null_reg hack with refine_ptr_not_null_reg (Eduard)
- patch 8: Only allow global subprog to read poisoned stack slots (Eduard)
- patch 11: Test a precision gap when passing NULL to nullable-mem + size arg (Eduard)
- patch 15: Reorganize BTF_ID, MEM, MEM+SIZE classification for clarity (Eduard)
- patch 18: Emded bpf_func_proto in bpf_kfunc_desc and dynamically resize bpf_kfunc_desc_tab; Record saved_dst_prog_type early in bpf_prog_load to avoid introducing a fallback logic in resolve_prog_type (Eduard)
v1 -> v2:
- patch 2: use reg_arg_name() for the map-mismatch message; derive the object register correctly on both helper and kfunc paths
- patch 3: reject non-CONST_PTR_TO_MAP regs (base_type check) to fix map-value type confusion
- patch 15: also reject referenced regs with unsafe modifiers (e.g. MEM_PERCPU)
- patch 17: reject non-SCALAR_VALUE for KF_ARG_MEM_SIZE
Amery Hung (17):
bpf: Drop process_timer_func wrappers
bpf: Unify const map ptr argument checking for helpers and kfuncs
bpf: Split kfunc map argument into __const_map and __map
bpf: Pass kfunc meta to mem and mem_size check
bpf: Check helper and kfunc mem+size arguments identically selftests/bpf: Test map lookup result refinement
bpf: Check fixed-size mem args of helpers and kfuncs the same way
bpf: Rename ARG_CONST_SIZE{,_OR_ZERO} to ARG_MEM_SIZE{,_OR_ZERO}
bpf: Fold __szk const size handling into the scalar arg path selftests/bpf: Test __szk precision with a NULL nullable buffer
bpf: Classify kfunc mem_size args from BTF without register state
bpf: Handle NULL kfunc pointer args without a KF_ARG_PTR_TO_NULL type
bpf: Distinguish fixed- and variable-size kfunc mem args with
MEM_FIXED_SIZE
bpf: Classify kfunc pointer arguments from BTF, resolve type against
the register
bpf: Tag nullable kfunc pointer args with PTR_MAYBE_NULL
bpf: Classify scalar kfunc arguments from BTF
bpf: Generate kfunc argument prototype at add-call time
Eduard Zingerman (1):
bpf: Resolve map lookup result type at lookup time
Documentation/bpf/kfuncs.rst | 30 +- include/linux/bpf.h | 40 +- include/linux/bpf_verifier.h | 22 +- kernel/bpf/backtrack.c | 2 +- kernel/bpf/bpf_lsm.c | 4 +- kernel/bpf/btf.c | 2 +- kernel/bpf/cgroup.c | 8 +- kernel/bpf/helpers.c | 42 +- kernel/bpf/ringbuf.c | 2 +- kernel/bpf/stackmap.c | 10 +- kernel/bpf/syscall.c | 8 +- kernel/bpf/verifier.c | 830 ++++++++++-------- kernel/trace/bpf_trace.c | 62 +- net/core/filter.c | 116 +-- .../selftests/bpf/prog_tests/verifier.c | 4 + .../selftests/bpf/progs/cgrp_kfunc_failure.c | 2 +- .../testing/selftests/bpf/progs/dynptr_fail.c | 2 +- .../bpf/progs/mem_rdonly_untrusted.c | 2 +- .../selftests/bpf/progs/task_kfunc_failure.c | 2 +- .../selftests/bpf/progs/verifier_bounds.c | 2 +- .../progs/verifier_helper_access_var_len.c | 6 +- .../bpf/progs/verifier_helper_value_access.c | 2 +- .../selftests/bpf/progs/verifier_map_in_map.c | 2 +- .../bpf/progs/verifier_map_lookup_refine.c | 73 ++ .../bpf/progs/verifier_mem_size_reg.c | 28 + .../selftests/bpf/progs/verifier_vfs_reject.c | 6 +- tools/testing/selftests/bpf/verifier/calls.c | 6 +- 27 files changed, 766 insertions(+), 549 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/verifier_map_lookup_refine.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_mem_size_reg.c
Signature · 1 line
2.52.0
PATCH v3 1/18 bpf: Drop process_timer_func wrappers
Drop process_timer_{helper,kfunc}() since bpf_call_arg_meta is now shared by helper and kfunc. Call process_timer_func() directly.
--- kernel/bpf/verifier.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-)
kernel/bpf/verifier.c +2 -14
@@ -7224,18 +7224,6 @@ static int process_timer_func(struct bpf_verifier_env *env, struct bpf_reg_statereturn check_map_field_pointer (env, reg, argno,BPF_TIMER , map); } -static int process_timer_helper (struct bpf_verifier_env *env,struct bpf_reg_state *reg,argno_t argno, -struct bpf_call_arg_meta *meta) -{ -return process_timer_func (env, reg, argno, &meta->map); -} - -static int process_timer_kfunc (struct bpf_verifier_env *env,struct bpf_reg_state *reg,argno_t argno, -struct bpf_call_arg_meta *meta) -{ -return process_timer_func (env, reg, argno, &meta->map); -} -static int process_kptr_func (struct bpf_verifier_env *env,int regno,struct bpf_call_arg_meta *meta) {
@@ -8466,7 +8454,7 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, }break ;case ARG_PTR_TO_TIMER : - err =process_timer_helper (env, reg, argno, meta); + err =process_timer_func (env, reg, argno, &meta->map);if (err)return err;break ;
@@ -12515,7 +12503,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me reg_arg_name(env, argno));return -EINVAL ; } - ret =process_timer_kfunc (env, reg, argno, meta); + ret =process_timer_func (env, reg, argno, &meta->map);if (ret <0 )return ret;break ;
Signature · 1 line
2.52.0
PATCH v3 2/18 bpf: Unify const map ptr argument checking for helpers and kfuncs
In reply to Amery HungBoth the helper ARG_CONST_MAP_PTR and the kfunc KF_ARG_PTR_TO_MAP recorded the map pointer in meta->map and, when a map was already bound by a preceding timer/workqueue/task_work argument, rejected a mismatching map.
Factor the logic into a single process_map_ptr_arg() used by both paths. The bound-object name (timer, workqueue, or bpf_task_work) is derived from the bound map's btf_record, and the register numbers in the message are computed from the map argument position instead of being hard-coded.
--- kernel/bpf/verifier.c | 97 ++++++++++++++++++++----------------------- 1 file changed, 44 insertions(+), 53 deletions(-)
kernel/bpf/verifier.c +44 -53
@@ -8274,6 +8274,44 @@ static int get_constant_map_key(struct bpf_verifier_env *env,static bool can_elide_value_nullness (const struct bpf_map *map); +static int process_map_ptr_arg (struct bpf_verifier_env *env,struct bpf_reg_state *reg, +argno_t argno,struct bpf_call_arg_meta *meta) +{ +/* Use map_uid (which is unique id of inner map) to reject: +* inner_map1 = bpf_map_lookup_elem(outer_map, key1) +* inner_map2 = bpf_map_lookup_elem(outer_map, key2) +* if (inner_map1 && inner_map2) { +* timer = bpf_map_lookup_elem(inner_map1); +* if (timer) +* // mismatch would have been allowed +* bpf_timer_init(timer, inner_map2); +* } +* +* Comparing map_ptr is enough to distinguish normal and outer maps. +*/ +if (meta->map.ptr && + (meta->map.ptr != reg->map_ptr || meta->map.uid != reg->map_uid)) { +argno_t obj_argno =argno_from_reg (reg_from_argno (argno) -1 ); +struct btf_record *rec = meta->map.ptr->record; +const char *obj_name ="workqueue" ; + +if (rec->timer_off >=0 ) + obj_name ="timer" ; +else if (rec->task_work_off >=0 ) + obj_name ="bpf_task_work" ; + +verbose (env,"%s pointer in %s map_uid=%d " , + obj_name,reg_arg_name (env, obj_argno), meta->map.uid); +verbose (env,"doesn't match map pointer in %s map_uid=%d\n" , +reg_arg_name (env, argno), reg->map_uid); +return -EINVAL ; + } + + meta->map.ptr = reg->map_ptr; + meta->map.uid = reg->map_uid; +return 0 ; +} + static int check_func_arg(struct bpf_verifier_env *env, u32 arg, struct bpf_call_arg_meta *meta, const struct bpf_func_proto *fn,
@@ -8349,29 +8387,9 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg,switch (base_type (arg_type)) {case ARG_CONST_MAP_PTR :/* bpf_map_xxx(map_ptr) call: remember that map_ptr */ -if (meta->map.ptr) { -/* Use map_uid (which is unique id of inner map) to reject: -* inner_map1 = bpf_map_lookup_elem(outer_map, key1) -* inner_map2 = bpf_map_lookup_elem(outer_map, key2) -* if (inner_map1 && inner_map2) { -* timer = bpf_map_lookup_elem(inner_map1); -* if (timer) -* // mismatch would have been allowed -* bpf_timer_init(timer, inner_map2); -* } -* -* Comparing map_ptr is enough to distinguish normal and outer maps. -*/ -if (meta->map.ptr != reg->map_ptr || - meta->map.uid != reg->map_uid) { -verbose (env, -"timer pointer in R1 map_uid=%d doesn't match map pointer in R2 map_uid=%d\n" , - meta->map.uid, reg->map_uid); -return -EINVAL ; - } - } - meta->map.ptr = reg->map_ptr; - meta->map.uid = reg->map_uid; + err =process_map_ptr_arg (env, reg, argno, meta); +if (err) +return err;break ;case ARG_PTR_TO_MAP_KEY :/* bpf_map_xxx(..., map_ptr, ..., key) call:
@@ -12123,36 +12141,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me reg_arg_name(env, argno));return -EINVAL ; } -if (meta->map.ptr && (reg->map_ptr->record->wq_off >=0 || - reg->map_ptr->record->task_work_off >=0 )) { -/* Use map_uid (which is unique id of inner map) to reject: -* inner_map1 = bpf_map_lookup_elem(outer_map, key1) -* inner_map2 = bpf_map_lookup_elem(outer_map, key2) -* if (inner_map1 && inner_map2) { -* wq = bpf_map_lookup_elem(inner_map1); -* if (wq) -* // mismatch would have been allowed -* bpf_wq_init(wq, inner_map2); -* } -* -* Comparing map_ptr is enough to distinguish normal and outer maps. -*/ -if (meta->map.ptr != reg->map_ptr || - meta->map.uid != reg->map_uid) { -if (reg->map_ptr->record->task_work_off >=0 ) { -verbose (env, -"bpf_task_work pointer in R2 map_uid=%d doesn't match map pointer in R3 map_uid=%d\n" , - meta->map.uid, reg->map_uid); -return -EINVAL ; - } -verbose (env, -"workqueue pointer in R1 map_uid=%d doesn't match map pointer in R2 map_uid=%d\n" , - meta->map.uid, reg->map_uid); -return -EINVAL ; - } - } - meta->map.ptr = reg->map_ptr; - meta->map.uid = reg->map_uid; + ret =process_map_ptr_arg (env, reg, argno, meta); +if (ret <0 ) +return ret; fallthrough;case KF_ARG_PTR_TO_ALLOC_BTF_ID :case KF_ARG_PTR_TO_BTF_ID :
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH bpf-next v3 02/18] bpf: Unify const map ptr argument checking for helpers and kfuncs
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [Medium] Latent NULL Pointer Dereference in process_map_ptr_arg - [Low] Incorrect error reporting for…
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Medium] Latent NULL Pointer Dereference in process_map_ptr_arg
- [Low] Incorrect error reporting for non-adjacent object and map arguments
- [Low] Misleading error message when a map contains both a timer and a workqueue --
--- Patch [2]: [PATCH bpf-next v3 02/18] bpf: Unify const map ptr argument checking for helpers and kfuncs --- commit 28f78cdb3fca90eedfb38c316b9b1e6ce726d4a2
Author: Amery Hung <[email protected]>
bpf: Unify const map ptr argument checking for helpers and kfuncs
This patch refactors the verifier to use a single process_map_ptr_arg() function for validating constant map pointer arguments in both helpers and kfuncs. The new logic attempts to dynamically derive the bound object name from the map's BTF record and computes the register numbers relative to the map argument position.
Quoted 4 lines
kernel/bpf/verifier.c +0
-0
[ ... ]
Quoted 12 lines
kernel/bpf/verifier.c +8
-0@@ -8274,6 +8274,44 @@ static int get_constant_map_key(struct bpf_verifier_env *env,static bool can_elide_value_nullness (const struct bpf_map *map); +static int process_map_ptr_arg (struct bpf_verifier_env *env,struct bpf_reg_state *reg, +argno_t argno,struct bpf_call_arg_meta *meta) +{ +/* Use map_uid (which is unique id of inner map) to reject: +* inner_map1 = bpf_map_lookup_elem(outer_map, key1) +* inner_map2 = bpf_map_lookup_elem(outer_map, key2) +* if (inner_map1 && inner_map2) { +* timer = bpf_map_lookup_elem(inner_map1);
kernel/bpf/verifier.c static int get_constant_map_key(struct bpf_verifier_env *env, · line 8294
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+* if (timer) +* // mismatch would have been allowed +* bpf_timer_init(timer, inner_map2); +* } +* +* Comparing map_ptr is enough to distinguish normal and outer maps. +*/ +if (meta->map.ptr && + (meta->map.ptr != reg->map_ptr || meta->map.uid != reg->map_uid)) { +argno_t obj_argno =argno_from_reg (reg_from_argno (argno) -1 );
[Severity: Low]
Does this incorrectly assume the bound object strictly precedes the map argument in all function signatures?
If a custom module kfunc interleaves arguments (e.g., passing a flag between the object and the map) or if the map is passed on the stack, this arithmetic will yield the wrong register or a negative value. For instance, if the map is the first argument, it might calculate negative registers and print garbage like fp-1992 in the verifier log.
kernel/bpf/verifier.c static int get_constant_map_key(struct bpf_verifier_env *env, · line 8298
Quoted 4 lines
kernel/bpf/verifier.c +4
-0+struct btf_record *rec = meta->map.ptr->record; +const char *obj_name ="workqueue" ; + +if (rec->timer_off >=0 )
[Severity: Medium]
Can this unconditionally dereference rec when it is NULL?
If the verifier processes a kfunc that takes multiple map pointers (e.g., in a custom module), the first map passed is tracked in meta->map.ptr. If that first map is a simple array or hash map without any special BTF fields, its record will be NULL. When the verifier processes the second map argument and it mismatches, it will hit this check and crash due to a NULL pointer dereference.
[Severity: Low]
Will this produce misleading error messages if a map contains both a timer and a workqueue?
A BPF map value can validly contain both a bpf_timer and a bpf_wq, meaning its btf_record will have both timer_off >= 0 and wq_off >= 0 true.
If a user calls bpf_wq_init() but accidentally passes a mismatched map, this conditional guesses the object type purely from the map's record and prioritizes the timer field. It will incorrectly print an error about a timer pointer mismatch, which would mislead the user who was explicitly working with a workqueue.
Quoted 15 lines
kernel/bpf/verifier.c +15
-0+ obj_name ="timer" ; + else if (rec->task_work_off >= 0) + obj_name ="bpf_task_work" ; + +verbose (env,"%s pointer in %s map_uid=%d " , + obj_name,reg_arg_name (env, obj_argno), meta->map.uid); +verbose (env,"doesn't match map pointer in %s map_uid=%d\n" , +reg_arg_name (env, argno), reg->map_uid); +return -EINVAL ; + } + + meta->map.ptr = reg->map_ptr; + meta->map.uid = reg->map_uid; +return 0 ; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
PATCH v3 3/18 bpf: Split kfunc map argument into __const_map and __map
In reply to Amery HungKfuncs used a single '__map' suffix (KF_ARG_PTR_TO_MAP) for two different
things: a verifier-known map matched by map_uid against a bound timer/wq/task_work object (bpf_wq_init, bpf_task_work_schedule*), and an opaque 'struct bpf_map *' used only at runtime (bpf_arena_*), which may be a map fd or a PTR_TO_BTF_ID struct bpf_map (e.g. a bpf_map iterator's ctx->map).
That combined path only accepted the btf map form due to type confusion. The 'if (!reg->map_ptr)' check reads reg->map_ptr, which aliases reg->btf in the bpf_reg_state union. A PTR_TO_BTF_ID register always has a non-NULL reg->btf, so the guard silently passed and validation fell through to process_kf_arg_ptr_to_btf_id(). It also recorded PTR_TO_BTF_ID info in meta->map, which would be meaningless.
Split the annotation to avoid such type confusion and to align with helper:
- '__const_map' -> KF_ARG_CONST_MAP_PTR: verifier-known map, handled by process_map_ptr_arg() like helper ARG_CONST_MAP_PTR.
- '__map' -> KF_ARG_PTR_TO_BTF_ID: opaque struct bpf_map, validated by process_kf_arg_ptr_to_btf_id(). A map fd still matches via reg2btf_ids[CONST_PTR_TO_MAP], so bpf_arena_alloc_pages(&map) keeps working.
--- Documentation/bpf/kfuncs.rst | 30 +++++++++++++++++++++++- kernel/bpf/helpers.c | 16 ++++++------- kernel/bpf/verifier.c | 45 +++++++++++++++++++++--------------- 3 files changed, 64 insertions(+), 27 deletions(-)
Documentation/bpf/kfuncs.rst +29 -1
@@ -250,6 +250,34 @@ Or:: ... } +2.3.7 __const_map and __map Annotations +--------------------------------------- + +These annotations are used for ``struct bpf_map *`` arguments and distinguish a +verifier-known map from an opaque one. + +``__const_map`` indicates a map must be known at the verification time, i.e. a +concrete map fd the BPF program references directly. + +An example is given below:: + + __bpf_kfunc int bpf_wq_init(struct bpf_wq *wq, void *p__const_map, + unsigned int flags) + { + ... + } + +``__map`` indicates an opaque ``struct bpf_map *`` that may be resolved +at run time. The argument may take either a map fd or a ``PTR_TO_BTF_ID`` +``struct bpf_map`` pointer. + +An example is given below:: + + __bpf_kfunc void *bpf_arena_alloc_pages(void *p__map, ...) + { + ... + } + .. _BPF_kfunc_nodef: 2.4 Using an existing kernel function
@@ -411,7 +439,7 @@ Example declaration: .. code-block:: c __bpf_kfunc int bpf_task_work_schedule_signal(struct task_struct *task, struct bpf_task_work *tw, - void *map__map, bpf_task_work_callback_t callback, + void *map__const_map, bpf_task_work_callback_t callback, struct bpf_prog_aux *aux) { ... } Example usage in BPF program:
kernel/bpf/helpers.c +8 -8
@@ -3404,10 +3404,10 @@ __bpf_kfunc void bpf_throw(u64 cookie)WARN (1 ,"A call to BPF exception callback should never return\n" ); } -__bpf_kfunc int bpf_wq_init(struct bpf_wq *wq, void *p__map, unsigned int flags) +__bpf_kfunc int bpf_wq_init(struct bpf_wq *wq, void *p__const_map, unsigned int flags) {struct bpf_async_kern *async = (struct bpf_async_kern *)wq; -struct bpf_map *map = p__map; +struct bpf_map *map = p__const_map;BUILD_BUG_ON (sizeof (struct bpf_async_kern ) >sizeof (struct bpf_wq ));BUILD_BUG_ON (__alignof__(struct bpf_async_kern ) != __alignof__(struct bpf_wq ));
@@ -4643,17 +4643,17 @@ static int bpf_task_work_schedule(struct task_struct *task, struct bpf_task_work* mode * @task: Task struct for which callback should be scheduled * @tw: Pointer to struct bpf_task_work in BPF map value for internal bookkeeping -* @map__map: bpf_map that embeds struct bpf_task_work in the values +* @map__const_map: bpf_map that embeds struct bpf_task_work in the values * @callback: pointer to BPF subprogram to call * @aux: pointer to bpf_prog_aux of the caller BPF program, implicitly set by the verifier * * Return: 0 if task work has been scheduled successfully, negative error code otherwise */ __bpf_kfunc int bpf_task_work_schedule_signal(struct task_struct *task, struct bpf_task_work *tw, -void *map__map,bpf_task_work_callback_t callback, +void *map__const_map,bpf_task_work_callback_t callback,struct bpf_prog_aux *aux) { -return bpf_task_work_schedule (task, tw, map__map, callback, aux,TWA_SIGNAL ); +return bpf_task_work_schedule (task, tw, map__const_map, callback, aux,TWA_SIGNAL ); }/**
@@ -4661,17 +4661,17 @@ __bpf_kfunc int bpf_task_work_schedule_signal(struct task_struct *task, struct b* mode * @task: Task struct for which callback should be scheduled * @tw: Pointer to struct bpf_task_work in BPF map value for internal bookkeeping -* @map__map: bpf_map that embeds struct bpf_task_work in the values +* @map__const_map: bpf_map that embeds struct bpf_task_work in the values * @callback: pointer to BPF subprogram to call * @aux: pointer to bpf_prog_aux of the caller BPF program, implicitly set by the verifier * * Return: 0 if task work has been scheduled successfully, negative error code otherwise */ __bpf_kfunc int bpf_task_work_schedule_resume(struct task_struct *task, struct bpf_task_work *tw, -void *map__map,bpf_task_work_callback_t callback, +void *map__const_map,bpf_task_work_callback_t callback,struct bpf_prog_aux *aux) { -return bpf_task_work_schedule (task, tw, map__map, callback, aux,TWA_RESUME ); +return bpf_task_work_schedule (task, tw, map__const_map, callback, aux,TWA_RESUME ); } static int make_file_dynptr(struct file *file, u32 flags, bool may_sleep,
kernel/bpf/verifier.c +27 -18
85 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH v3 4/18 bpf: Pass kfunc meta to mem and mem_size check
In reply to Amery Hungkfunc now shares the same bpf_call_arg_meta with helpers. Pass kfunc's own meta to check_mem_reg() and check_kfunc_mem_size() instead of NULL or a temporary meta on the stack.
--- kernel/bpf/verifier.c | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-)
kernel/bpf/verifier.c +10 -12
@@ -6924,7 +6924,7 @@ static int check_mem_size_reg(struct bpf_verifier_env *env, }static int check_mem_reg (struct bpf_verifier_env *env,struct bpf_reg_state *reg, -argno_t argno,u32 mem_size) +argno_t argno,u32 mem_size,struct bpf_call_arg_meta *meta) {bool may_be_null =type_may_be_null (reg->type);struct bpf_reg_state saved_reg;
@@ -6950,8 +6950,8 @@ static int check_mem_reg(struct bpf_verifier_env *env, struct bpf_reg_state *regint size =base_type (reg->type) ==PTR_TO_STACK ? -(int )mem_size : mem_size; - err =check_helper_mem_access (env, reg, argno, size,BPF_READ , true,NULL ); - err = err ?:check_helper_mem_access (env, reg, argno, size,BPF_WRITE , true,NULL ); + err =check_helper_mem_access (env, reg, argno, size,BPF_READ , true, meta); + err = err ?:check_helper_mem_access (env, reg, argno, size,BPF_WRITE , true, meta);if (may_be_null) *reg = saved_reg;
@@ -6994,22 +6994,20 @@ static int process_const_alloc_mem_size(struct bpf_verifier_env *env, struct bpf }static int check_kfunc_mem_size_reg (struct bpf_verifier_env *env,struct bpf_reg_state *mem_reg, -struct bpf_reg_state *size_reg,argno_t mem_argno,argno_t size_argno) +struct bpf_reg_state *size_reg,argno_t mem_argno, +argno_t size_argno,struct bpf_call_arg_meta *meta) {bool may_be_null =type_may_be_null (mem_reg->type);struct bpf_reg_state saved_reg; -struct bpf_call_arg_meta meta;int err; -memset (&meta,0 ,sizeof (meta)); -if (may_be_null) { saved_reg = *mem_reg;mark_ptr_not_null_reg (mem_reg); } - err =check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_READ , true, &meta); - err = err ?:check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_WRITE , true, &meta); + err =check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_READ , true, meta); + err = err ?:check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_WRITE , true, meta);if (may_be_null) *mem_reg = saved_reg;
@@ -9258,7 +9256,7 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog, ret =check_func_arg_reg_off (env, reg, argno,ARG_DONTCARE );if (ret <0 )return ret; -if (check_mem_reg (env, reg, argno, arg->mem_size)) +if (check_mem_reg (env, reg, argno, arg->mem_size,NULL ))return -EINVAL ;if (!(arg->arg_type &PTR_MAYBE_NULL ) && (type_may_be_null (reg->type) ||bpf_register_is_null (reg))) {
@@ -12405,7 +12403,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_tname, PTR_ERR(resolve_ret));return -EINVAL ; } - ret =check_mem_reg (env, reg, argno, type_size); + ret =check_mem_reg (env, reg, argno, type_size, meta);if (ret <0 )return ret;break ;
@@ -12419,7 +12417,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meif (!bpf_register_is_null (buff_reg) || !is_kfunc_arg_nullable (meta->btf, buff_arg)) { ret =check_kfunc_mem_size_reg (env, buff_reg, size_reg, - argno, next_argno); + argno, next_argno, meta);if (ret <0 ) {verbose (env,"%s and " ,reg_arg_name (env, argno)); verbose(env, "%s memory, len pair leads to invalid memory access\n",
Signature · 1 line
2.52.0
PATCH v3 5/18 bpf: Resolve map lookup result type at lookup time
In reply to Amery HungFrom: Eduard Zingerman <[email protected]>
bpf_map_lookup_elem() is typed to return PTR_TO_MAP_VALUE for every map, but for some map kinds the looked up value is actually a different object: an inner map, a socket or an xsk socket. Until now this reinterpretation happened once the pointer was converted from its NULL-able form to a concrete value.
Such reinterpretation logic placement led to mark_ptr_not_null_reg() being called for a temporary register copy in check_mem_reg() and check_kfunc_mem_size_reg() (check_mem_size_reg() was buggy because of not calling it). The temporary copy was necessary to pass reinterpreted parameters as nullable helper and kfunc arguments.
Avoid this complication by refining map lookup result type right away.
The test case verifier_map_in_map/on_the_inner_map_pointer needs an update because the verifier now prints a concrete NULL-able type for the lookup.
--- kernel/bpf/verifier.c | 79 +++++++------------ .../selftests/bpf/progs/verifier_map_in_map.c | 2 +- 2 files changed, 31 insertions(+), 50 deletions(-)
kernel/bpf/verifier.c +30 -49
@@ -1854,32 +1854,34 @@ static void __mark_dynptr_reg(struct bpf_reg_state *reg, enum bpf_dynptr_type ty reg->dynptr.first_slot = first_slot; } -static void mark_ptr_not_null_reg (struct bpf_reg_state *reg) +/* +* Refine the return type of the bpf_map_lookup_elem() for special map types: +* map-in-map, xskmap, sockmap and sockhash. +*/ +static void refine_map_lookup_value (struct bpf_reg_state *reg) { -if (base_type (reg->type) ==PTR_TO_MAP_VALUE ) { -const struct bpf_map *map = reg->map_ptr; +enum bpf_type_flag maybe_null = reg->type &PTR_MAYBE_NULL ; +const struct bpf_map *map = reg->map_ptr; -if (map->inner_map_meta) { - reg->type =CONST_PTR_TO_MAP ; - reg->map_ptr = map->inner_map_meta; -/* transfer reg's id which is unique for every map_lookup_elem -* as UID of the inner map. -*/ -if (btf_record_has_field (map->inner_map_meta->record, -BPF_TIMER |BPF_WORKQUEUE |BPF_TASK_WORK )) { - reg->map_uid = reg->id; - } - }else if (map->map_type ==BPF_MAP_TYPE_XSKMAP ) { - reg->type =PTR_TO_XDP_SOCK ; - }else if (map->map_type ==BPF_MAP_TYPE_SOCKMAP || - map->map_type ==BPF_MAP_TYPE_SOCKHASH ) { - reg->type =PTR_TO_SOCKET ; - }else { - reg->type =PTR_TO_MAP_VALUE ; - } -return ; +if (map->inner_map_meta) { + reg->type =CONST_PTR_TO_MAP | maybe_null; + reg->map_ptr = map->inner_map_meta; +/* transfer reg's id which is unique for every map_lookup_elem +* as UID of the inner map. +*/ +if (btf_record_has_field (map->inner_map_meta->record, +BPF_TIMER |BPF_WORKQUEUE |BPF_TASK_WORK )) + reg->map_uid = reg->id; + }else if (map->map_type ==BPF_MAP_TYPE_XSKMAP ) { + reg->type =PTR_TO_XDP_SOCK | maybe_null; + }else if (map->map_type ==BPF_MAP_TYPE_SOCKMAP || + map->map_type ==BPF_MAP_TYPE_SOCKHASH ) { + reg->type =PTR_TO_SOCKET | maybe_null; } +} +static void mark_ptr_not_null_reg (struct bpf_reg_state *reg) +{ reg->type &= ~PTR_MAYBE_NULL ; }
@@ -6926,8 +6928,6 @@ static int check_mem_size_reg(struct bpf_verifier_env *env,static int check_mem_reg (struct bpf_verifier_env *env,struct bpf_reg_state *reg,argno_t argno,u32 mem_size,struct bpf_call_arg_meta *meta) { -bool may_be_null =type_may_be_null (reg->type); -struct bpf_reg_state saved_reg;int err;if (bpf_register_is_null (reg))
@@ -6939,23 +6939,11 @@ static int check_mem_reg(struct bpf_verifier_env *env, struct bpf_reg_state *regreturn -EACCES ; } -/* Assuming that the register contains a value check if the memory -* access is safe. Temporarily save and restore the register's state as -* the conversion shouldn't be visible to a caller. -*/ -if (may_be_null) { - saved_reg = *reg; -mark_ptr_not_null_reg (reg); - } -int size =base_type (reg->type) ==PTR_TO_STACK ? -(int )mem_size : mem_size; err =check_helper_mem_access (env, reg, argno, size,BPF_READ , true, meta); err = err ?:check_helper_mem_access (env, reg, argno, size,BPF_WRITE , true, meta); -if (may_be_null) - *reg = saved_reg; -return err; }
@@ -6997,21 +6985,11 @@ static int check_kfunc_mem_size_reg(struct bpf_verifier_env *env, struct bpf_reg struct bpf_reg_state *size_reg, argno_t mem_argno, argno_t size_argno, struct bpf_call_arg_meta *meta) { - bool may_be_null = type_may_be_null(mem_reg->type); -struct bpf_reg_state saved_reg; int err; -if (may_be_null) { - saved_reg = *mem_reg; -mark_ptr_not_null_reg (mem_reg); - } - err =check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_READ , true, meta); err = err ?:check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_WRITE , true, meta); -if (may_be_null) - *mem_reg = saved_reg; -return err; }
@@ -10522,10 +10500,12 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn regs[BPF_REG_0 ].map_ptr = meta.map.ptr; regs[BPF_REG_0 ].map_uid = meta.map.uid; regs[BPF_REG_0 ].type =PTR_TO_MAP_VALUE | ret_flag; -if (!type_may_be_null (ret_flag) && +if (type_may_be_null (ret_flag) ||btf_record_has_field (meta.map.ptr->record,BPF_SPIN_LOCK |BPF_RES_SPIN_LOCK )) { regs[BPF_REG_0 ].id = ++env->id_gen; } +/* requires regs[BPF_REG_0].id to be set because of the map-in-map case */ +refine_map_lookup_value (®s[BPF_REG_0 ]);break ;case RET_PTR_TO_SOCKET :mark_reg_known_zero (env, regs,BPF_REG_0 );
@@ -10623,7 +10603,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnreturn -EINVAL ; } -if (type_may_be_null (regs[BPF_REG_0 ].type)) +if (type_may_be_null (regs[BPF_REG_0 ].type) && !regs[BPF_REG_0 ].id) regs[BPF_REG_0 ].id = ++env->id_gen; if (is_ptr_cast_function(func_id) &&
@@ -12370,7 +12350,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mereturn ret;break ;case KF_ARG_CONST_MAP_PTR : -if (base_type (reg->type) !=CONST_PTR_TO_MAP ) { +if (base_type (reg->type) !=CONST_PTR_TO_MAP || +type_may_be_null (reg->type)) {verbose (env,"pointer in %s isn't map pointer\n" ,reg_arg_name (env, argno));return -EINVAL ;
tools/testing/selftests/bpf/progs/verifier_map_in_map.c +1 -1
@@ -154,7 +154,7 @@ l0_%=: r0 = 0; \ SEC("socket") __description("forgot null checking on the inner map pointer") -__failure __msg("R1 type=map_value_or_null expected=map_ptr") +__failure __msg("R1 type=map_ptr_or_null expected=map_ptr") __failure_unpriv__naked void on_the_inner_map_pointer (void ) {
Signature · 1 line
2.52.0
PATCH v3 6/18 bpf: Check helper and kfunc mem+size arguments identically
In reply to Amery HungHelper ARG_CONST_SIZE and kfunc KF_ARG_PTR_TO_MEM_SIZE memory arguments already share check_mem_size_reg(), but the kfunc path reached it through a thin wrapper, check_kfunc_mem_size_reg(). The wrapper existed only to invoke check_mem_size_reg() twice. Once for BPF_READ and once for BPF_WRITE because a kfunc mem argument may be both read and written, whereas a helper argument carries a single access direction.
Let check_mem_size_reg() take a bitmask of access directions (widening access_type to u32) and perform each requested access, then pass BPF_READ | BPF_WRITE from the kfunc call site. This removes the check_kfunc_mem_size_reg() wrapper so helper and kfunc mem+size arguments run through exactly the same code.
--- kernel/bpf/verifier.c | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-)
kernel/bpf/verifier.c +13 -18
@@ -6871,11 +6871,11 @@ static int check_helper_mem_access(struct bpf_verifier_env *env, struct bpf_reg_static int check_mem_size_reg (struct bpf_verifier_env *env,struct bpf_reg_state *mem_reg,struct bpf_reg_state *size_reg,argno_t mem_argno, -argno_t size_argno,enum bpf_access_type access_type, +argno_t size_argno,u32 access_type,bool zero_size_allowed,struct bpf_call_arg_meta *meta) { -int err; +int err =0 ;/* This is used to refine r0 return value bounds for helpers * that enforce this value as an upper bound on return values.
@@ -6912,8 +6912,14 @@ static int check_mem_size_reg(struct bpf_verifier_env *env, reg_arg_name(env, size_argno));return -EACCES ; } - err =check_helper_mem_access (env, mem_reg, mem_argno,reg_umax (size_reg), - access_type, zero_size_allowed, meta); + +if (access_type &BPF_READ ) + err =check_helper_mem_access (env, mem_reg, mem_argno,reg_umax (size_reg), +BPF_READ , zero_size_allowed, meta); +if (!err && access_type &BPF_WRITE ) + err =check_helper_mem_access (env, mem_reg, mem_argno,reg_umax (size_reg), +BPF_WRITE , zero_size_allowed, meta); +if (!err) {int regno =reg_from_argno (size_argno);
@@ -6922,6 +6928,7 @@ static int check_mem_size_reg(struct bpf_verifier_env *env,else err =mark_stack_arg_precision (env,arg_idx_from_argno (size_argno)); } +return err; }
@@ -6981,18 +6988,6 @@ static int process_const_alloc_mem_size(struct bpf_verifier_env *env, struct bpfreturn 0 ; } -static int check_kfunc_mem_size_reg (struct bpf_verifier_env *env,struct bpf_reg_state *mem_reg, -struct bpf_reg_state *size_reg,argno_t mem_argno, -argno_t size_argno,struct bpf_call_arg_meta *meta) -{ -int err; - - err =check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_READ , true, meta); - err = err ?:check_mem_size_reg (env, mem_reg, size_reg, mem_argno, size_argno,BPF_WRITE , true, meta); - -return err; -} -enum {PROCESS_SPIN_LOCK = (1 <<0 ),PROCESS_RES_LOCK = (1 <<1 ),
@@ -12397,8 +12392,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meargno_t next_argno =argno_from_arg (i +2 );if (!bpf_register_is_null (buff_reg) || !is_kfunc_arg_nullable (meta->btf, buff_arg)) { - ret =check_kfunc_mem_size_reg (env, buff_reg, size_reg, - argno, next_argno, meta); + ret =check_mem_size_reg (env, buff_reg, size_reg, argno, next_argno, +BPF_READ |BPF_WRITE , true, meta);if (ret <0 ) {verbose (env,"%s and " ,reg_arg_name (env, argno)); verbose(env, "%s memory, len pair leads to invalid memory access\n",
Signature · 1 line
2.52.0
PATCH v3 7/18 selftests/bpf: Test map lookup result refinement
In reply to Amery HungA map-of-maps lookup value is refined to a map pointer (map_ptr_or_null) at lookup time by refine_map_lookup_value(). Test that it is rejected wherever a raw map value would be read as bytes, so the inner map descriptor cannot leak.
--- .../selftests/bpf/prog_tests/verifier.c | 2 + .../bpf/progs/verifier_map_lookup_refine.c | 73 +++++++++++++++++++ 2 files changed, 75 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_map_lookup_refine.c
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
@@ -61,6 +61,7 @@#include "verifier_loops1.skel.h" #include "verifier_lwt.skel.h" #include "verifier_map_in_map.skel.h" +#include "verifier_map_lookup_refine.skel.h" #include "verifier_map_ptr.skel.h" #include "verifier_map_ptr_mixing.skel.h" #include "verifier_map_ret_val.skel.h"
@@ -215,6 +216,7 @@ void test_verifier_liveness_exp(void) { RUN(verifier_liveness_exp); }void test_verifier_loops1 (void ) {RUN (verifier_loops1); }void test_verifier_lwt (void ) {RUN (verifier_lwt); }void test_verifier_map_in_map (void ) {RUN (verifier_map_in_map); } +void test_verifier_map_lookup_refine (void ) {RUN (verifier_map_lookup_refine); }void test_verifier_map_ptr (void ) {RUN (verifier_map_ptr); }void test_verifier_map_ptr_mixing (void ) {RUN (verifier_map_ptr_mixing); }void test_verifier_map_ret_val (void ) {RUN (verifier_map_ret_val); }
tools/testing/selftests/bpf/progs/verifier_map_lookup_refine.c new file +73 -0
73 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH v3 8/18 bpf: Check fixed-size mem args of helpers and kfuncs the same way
In reply to Amery HungFixed-size memory arguments went through two paths: helpers called check_helper_mem_access() directly, while kfuncs and global subprogs used check_mem_reg(). Route the helper MEM_FIXED_SIZE case through check_mem_reg() too so all three share the same check.
This also fixes a bug in the helper path. When passing a NULL to PTR_MAYBE_NULL | ARG_PTR_TO_FIXED_SIZE_MEM argument, the program would be falsely rejected by check_helper_mem_access(). This is not triggerable since there is no such kind of helper. Also, note that check_reg_type() still make sure NULL cannot be passed to an argument not marked with PTR_MAYBE_NULL.
It also tightens the poisoned-stack-slot check. check_mem_reg() encoded "a STACK_POISON slot may be read" as a negative access size for any PTR_TO_STACK argument, but that is only sound for global subprogs, where static stack liveness proved the callee body does not read those slots (2cb27158adb3 ("bpf: poison dead stack slots")). Since check_mem_reg() is also used for kfuncs, kfuncs accidentally inherited it and could read a poisoned (dead, possibly uninitialized) stack slot. Restrict the negative size to global subprogs (meta == NULL) so kfuncs, like helpers, require the whole argument initialized.
--- kernel/bpf/verifier.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)
kernel/bpf/verifier.c +17 -11
@@ -6669,7 +6669,7 @@ static int check_stack_range_initialized(*/ bool clobber = type ==BPF_WRITE ;/* -* Negative access_size signals global subprog/kfunc arg check where +* Negative access_size signals global subprog arg check where * STACK_POISON slots are acceptable. static stack liveness * might have determined that subprog doesn't read them, * but BTF based global subprog validation isn't accurate enough.
@@ -6933,9 +6933,10 @@ static int check_mem_size_reg(struct bpf_verifier_env *env, }static int check_mem_reg (struct bpf_verifier_env *env,struct bpf_reg_state *reg, -argno_t argno,u32 mem_size,struct bpf_call_arg_meta *meta) +argno_t argno,u32 mem_size,enum bpf_access_type access_type, +struct bpf_call_arg_meta *meta) { -int err; +int size, err =0 ;if (bpf_register_is_null (reg))return 0 ;
@@ -6946,10 +6947,16 @@ static int check_mem_reg(struct bpf_verifier_env *env, struct bpf_reg_state *regreturn -EACCES ; } -int size =base_type (reg->type) ==PTR_TO_STACK ? -(int )mem_size : mem_size; +/* +* Only a global subprog (meta == NULL) may read poisoned stack slots: +* its static stack liveness proved the callee body skips them. +*/ + size = (!meta &&base_type (reg->type) ==PTR_TO_STACK ) ? -(int )mem_size : mem_size; - err =check_helper_mem_access (env, reg, argno, size,BPF_READ , true, meta); - err = err ?:check_helper_mem_access (env, reg, argno, size,BPF_WRITE , true, meta); +if (access_type &BPF_READ ) + err =check_helper_mem_access (env, reg, argno, size,BPF_READ , true, meta); +if (!err && (access_type &BPF_WRITE )) + err =check_helper_mem_access (env, reg, argno, size,BPF_WRITE , true, meta);return err; }
@@ -8455,9 +8462,8 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg,* next is_mem_size argument below. */ if (arg_type &MEM_FIXED_SIZE ) { - err =check_helper_mem_access (env, reg, argno, fn->arg_size[arg], - arg_type &MEM_WRITE ?BPF_WRITE :BPF_READ , - false, meta); + err =check_mem_reg (env, reg,argno_from_reg (regno), fn->arg_size[arg], + arg_type &MEM_WRITE ?BPF_WRITE :BPF_READ , meta);if (err)return err;if (arg_type &MEM_ALIGNED )
@@ -9229,7 +9235,7 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog, ret =check_func_arg_reg_off (env, reg, argno,ARG_DONTCARE );if (ret <0 )return ret; -if (check_mem_reg (env, reg, argno, arg->mem_size,NULL )) +if (check_mem_reg (env, reg, argno, arg->mem_size,BPF_READ |BPF_WRITE ,NULL ))return -EINVAL ;if (!(arg->arg_type &PTR_MAYBE_NULL ) && (type_may_be_null (reg->type) ||bpf_register_is_null (reg))) {
@@ -12379,7 +12385,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_tname, PTR_ERR(resolve_ret));return -EINVAL ; } - ret =check_mem_reg (env, reg, argno, type_size, meta); + ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta);if (ret <0 )return ret;break ;
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH bpf-next v3 08/18] bpf: Check fixed-size mem args of helpers and kfuncs the same way
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
New issues:
- [High] Kfuncs taking uninitialized memory arguments via the __uninit annotation are falsely rejected when passed uninitialized stack slots.
Pre-existing issues:
- [Critical] The verifier fails to check if the size argument for KF_ARG_PTR_TO_MEM_SIZE kfuncs is a scalar, allowing BPF programs to pass kernel pointers as size arguments, leading to an out-of-bounds access. --
--- Patch [8]: [PATCH bpf-next v3 08/18] bpf: Check fixed-size mem args of helpers and kfuncs the same way --- commit bcee13ba62b78a9328164e2486f3c31a7fddb8a0
Author: Amery Hung <[email protected]>
bpf: Check fixed-size mem args of helpers and kfuncs the same way
Fixed-size memory arguments went through two paths: helpers called check_helper_mem_access() directly, while kfuncs and global subprogs used check_mem_reg(). Route the helper MEM_FIXED_SIZE case through check_mem_reg() too so all three share the same check.
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_call_arg_me · line 12388
Quoted 6 lines
kernel/bpf/verifier.c +1
-1@@ -12379,7 +12385,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_tname, PTR_ERR(resolve_ret));return -EINVAL ; } - ret =check_mem_reg (env, reg, argno, type_size, meta); + ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta);
[Severity: High]
Does this change break BPF programs that pass uninitialized stack slots to kfuncs using the __uninit annotation?
Because check_mem_reg() is now unconditionally called with BPF_READ | BPF_WRITE here, it seems to mandate initialization for __uninit kfunc arguments as well, which should only require BPF_WRITE.
Quoted 15 lines
kernel/bpf/verifier.c +0
-0if (ret <0 )return ret;break ;kernel/bpf/verifier.c +0
-0case KF_ARG_PTR_TO_MEM_SIZE : {struct bpf_reg_state *buff_reg = reg;const struct btf_param *buff_arg = &args[i];struct bpf_reg_state *size_reg =get_func_arg_reg (caller, regs, i +1 );const struct btf_param *size_arg = &args[i +1 ];argno_t next_argno =argno_from_arg (i +2 );if (!bpf_register_is_null (buff_reg) || !is_kfunc_arg_nullable (meta->btf, buff_arg)) { ret =check_mem_size_reg (env, buff_reg, size_reg, argno, next_argno,BPF_READ |BPF_WRITE , true, meta);if (ret <0 ) {
[ ... ]
kernel/bpf/verifier.c
Quoted 5 lines
kernel/bpf/verifier.c +0
-0}/* Skip next '__sz' or '__szk' argument */ i++;break ;
[Severity: Critical]
This isn't a bug introduced by this patch, but does the verifier fail to enforce that the size argument is a scalar for KF_ARG_PTR_TO_MEM_SIZE?
The loop uses i++ to skip the next iteration, which completely bypasses the btf_type_is_scalar validation for the size argument. check_mem_size_reg() also assumes the register is a SCALAR_VALUE without verifying it.
If a BPF program passes a pointer register (like PTR_TO_STACK with a zero offset) as the size argument, reg_umax evaluates to 0, which passes the verifier's size checks. At runtime, the full kernel pointer address could be used as the size, potentially allowing an out-of-bounds memory access.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Re: [PATCH bpf-next v3 08/18] bpf: Check fixed-size mem args of helpers and kfuncs the same way
Quoted 39 lines · On Sat, Aug 1, 2026 at 1:17 AM <[email protected]> wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
New issues:
- [High] Kfuncs taking uninitialized memory arguments via the__uninitannotation are falsely rejected when passed uninitialized stack slots.Pre-existing issues:
- [Critical] The verifier fails to check if the size argument forKF_ARG_PTR_TO_MEM_SIZEkfuncs is a scalar, allowing BPF programs to pass kernel pointers as size arguments, leading to an out-of-bounds access. ----- Patch [8]: [PATCH bpf-next v3 08/18] bpf: Check fixed-size mem args of helpers and kfuncs the same way --- commit
bcee13ba62b78a9328164e2486f3c31a7fddb8a0
Author: Amery Hung <[email protected]>bpf: Check fixed-size mem args of helpers and kfuncs the same way
Fixed-size memory arguments went through two paths: helpers called
check_helper_mem_access()directly, while kfuncs and global subprogs usedcheck_mem_reg(). Route the helperMEM_FIXED_SIZEcase throughcheck_mem_reg()too so all three share the same check.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_call_arg_me · line 12388
Quoted 6 lines
kernel/bpf/verifier.c +1
-1@@ -12379,7 +12385,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_tname, PTR_ERR(resolve_ret));return -EINVAL ; } - ret =check_mem_reg (env, reg, argno, type_size, meta); + ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta);[Severity: High]
Does this change break BPF programs that pass uninitialized stack slots to kfuncs using the__uninitannotation?
Quoted 3 lines
Because
check_mem_reg()is now unconditionally called withBPF_READ|BPF_WRITEhere, it seems to mandate initialization for__uninitkfunc arguments as well, which should only requireBPF_WRITE.
First of all, this is not a change introduced by this patch. kfunc already calls check_helper_mem_access() with BPF_READ and then BPF_WRITE.
This is also not an issue unless a a new unpreviledged kfunc that takes __uninit arg is introduced. There are two kinds of existing kfuncs with __uninit arg: bpf_dynptr_from_xxx() and scx_bpf_cid_topo(). The former, while being unpreviledged kfuncs, checks their __uninit dynptr argument through process_dynptr_func(), which directly calls check_mem_access() to simulate byte-by-byte write. The later is a previledged kfunc, which means check_stack_range_initialized() will see env->allow_uninit_stack = true and allow reading uninit stack slot on BPF_READ and then mark the stack slot as STACK_MISC on BPF_WRITE.
Quoted 19 lines
Quoted 16 lines
kernel/bpf/verifier.c +0
-0if (ret <0 )return ret;break ;case KF_ARG_PTR_TO_MEM_SIZE: { struct bpf_reg_state *buff_reg = reg; const struct btf_param *buff_arg = &args[i]; struct bpf_reg_state *size_reg = get_func_arg_reg(caller, regs, i + 1); const struct btf_param *size_arg = &args[i + 1]; argno_t next_argno = argno_from_arg(i + 2); if (!bpf_register_is_null(buff_reg) || !is_kfunc_arg_nullable(meta->btf, buff_arg)) { ret = check_mem_size_reg(env, buff_reg, size_reg, argno, next_argno, BPF_READ | BPF_WRITE, true, meta); if (ret < 0) {[ ... ]
Quoted 2 lines
}
Quoted 7 lines
Quoted 3 lines
/* Skip next '__sz' or '__szk' argument */ i++; break;[Severity: Critical]
This isn't a bug introduced by this patch, but does the verifier fail to enforce that the size argument is a scalar forKF_ARG_PTR_TO_MEM_SIZE?
Not a pre-existing bug. Currently get_kfunc_ptr_arg_type() does mandate the register passed to __sz or __szk args to be scalar.
Quoted 12 lines
The loop uses i++ to skip the next iteration, which completely bypasses the
btf_type_is_scalarvalidation for the size argument.check_mem_size_reg()also assumes the register is aSCALAR_VALUEwithout verifying it.If a BPF program passes a pointer register (like
PTR_TO_STACKwith a zero offset) as the size argument,reg_umaxevaluates to 0, which passes the verifier's size checks. At runtime, the full kernel pointer address could be used as the size, potentially allowing an out-of-bounds memory access.--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
PATCH v3 9/18 bpf: Rename ARG_CONST_SIZE{,_OR_ZERO} to ARG_MEM_SIZE{,_OR_ZERO}
In reply to Amery HungARG_CONST_SIZE does not require a constant: check_mem_size_reg() accepts any bounded scalar and verifies the memory access against its maximum (reg_umax). Rename ARG_CONST_SIZE and ARG_CONST_SIZE_OR_ZERO to ARG_MEM_SIZE and ARG_MEM_SIZE_OR_ZERO to reflect that. ARG_CONST_ALLOC_ SIZE_OR_ZERO, which does require a constant, is left unchanged.
Pure rename, no functional change.
--- include/linux/bpf.h | 4 +- include/linux/bpf_verifier.h | 2 +- kernel/bpf/backtrack.c | 2 +- kernel/bpf/bpf_lsm.c | 4 +- kernel/bpf/btf.c | 2 +- kernel/bpf/cgroup.c | 8 +- kernel/bpf/helpers.c | 26 ++-- kernel/bpf/ringbuf.c | 2 +- kernel/bpf/stackmap.c | 10 +- kernel/bpf/syscall.c | 4 +- kernel/bpf/verifier.c | 11 +- kernel/trace/bpf_trace.c | 62 +++++----- net/core/filter.c | 116 +++++++++--------- .../bpf/progs/mem_rdonly_untrusted.c | 2 +- .../selftests/bpf/progs/verifier_bounds.c | 2 +- .../progs/verifier_helper_access_var_len.c | 6 +- .../bpf/progs/verifier_helper_value_access.c | 2 +- 17 files changed, 132 insertions(+), 133 deletions(-)
include/linux/bpf.h +2 -2
@@ -888,8 +888,8 @@ enum bpf_arg_type {ARG_PTR_TO_MEM ,/* pointer to valid memory (stack, packet, map value) */ ARG_PTR_TO_ARENA , -ARG_CONST_SIZE ,/* number of bytes accessed from memory */ -ARG_CONST_SIZE_OR_ZERO ,/* number of bytes accessed from memory or 0 */ +ARG_MEM_SIZE ,/* number of bytes accessed from memory */ +ARG_MEM_SIZE_OR_ZERO ,/* number of bytes accessed from memory or 0 */ ARG_PTR_TO_CTX ,/* pointer to context */ ARG_ANYTHING, /* any (initialized) argument is ok */
include/linux/bpf_verifier.h +1 -1
@@ -15,7 +15,7 @@* ensures that umax_value + (int)off + (int)size cannot overflow a u64. */ #define BPF_MAX_VAR_OFF (1 << 29) -/* Maximum variable size permitted for ARG_CONST_SIZE[_OR_ZERO]. This ensures +/* Maximum variable size permitted for ARG_MEM_SIZE[_OR_ZERO]. This ensures * that converting umax_value to int cannot overflow. */ #define BPF_MAX_VAR_SIZ (1 << 29)
kernel/bpf/backtrack.c +1 -1
@@ -636,7 +636,7 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, int subseq_idx,* r5 += 1 * ... * call bpf_perf_event_output#25 -* where .arg5_type = ARG_CONST_SIZE_OR_ZERO +* where .arg5_type = ARG_MEM_SIZE_OR_ZERO * * and this case: * r6 = 1
kernel/bpf/bpf_lsm.c +2 -2
@@ -186,7 +186,7 @@ static const struct bpf_func_proto bpf_ima_inode_hash_proto = { .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &bpf_ima_inode_hash_btf_ids[0], .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, .allowed = bpf_ima_inode_hash_allowed, };
@@ -205,7 +205,7 @@ static const struct bpf_func_proto bpf_ima_file_hash_proto = { .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &bpf_ima_file_hash_btf_ids[0], .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, .allowed = bpf_ima_inode_hash_allowed, };
kernel/bpf/btf.c +1 -1
@@ -8709,7 +8709,7 @@ const struct bpf_func_proto bpf_btf_find_by_name_kind_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg2_type = ARG_CONST_SIZE, + .arg2_type = ARG_MEM_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_ANYTHING, };
kernel/bpf/cgroup.c +4 -4
@@ -2305,7 +2305,7 @@ static const struct bpf_func_proto bpf_sysctl_get_name_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_WRITE, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, .arg4_type = ARG_ANYTHING, };
@@ -2347,7 +2347,7 @@ static const struct bpf_func_proto bpf_sysctl_get_current_value_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, }; BPF_CALL_3(bpf_sysctl_get_new_value, struct bpf_sysctl_kern *, ctx, char *, buf,
@@ -2367,7 +2367,7 @@ static const struct bpf_func_proto bpf_sysctl_get_new_value_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, }; BPF_CALL_3(bpf_sysctl_set_new_value, struct bpf_sysctl_kern *, ctx,
@@ -2393,7 +2393,7 @@ static const struct bpf_func_proto bpf_sysctl_set_new_value_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, }; static const struct bpf_func_proto *
kernel/bpf/helpers.c +13 -13
@@ -278,7 +278,7 @@ const struct bpf_func_proto bpf_get_current_comm_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_UNINIT_MEM, - .arg2_type = ARG_CONST_SIZE, + .arg2_type = ARG_MEM_SIZE, };#if defined(CONFIG_QUEUED_SPINLOCKS ) || defined(CONFIG_BPF_ARCH_SPINLOCK )
@@ -539,7 +539,7 @@ const struct bpf_func_proto bpf_strtol_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg2_type = ARG_CONST_SIZE, + .arg2_type = ARG_MEM_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | MEM_UNINIT | MEM_WRITE | MEM_ALIGNED, .arg4_size = sizeof(s64),
@@ -567,7 +567,7 @@ const struct bpf_func_proto bpf_strtoul_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg2_type = ARG_CONST_SIZE, + .arg2_type = ARG_MEM_SIZE, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | MEM_UNINIT | MEM_WRITE | MEM_ALIGNED, .arg4_size = sizeof(u64),
@@ -583,7 +583,7 @@ static const struct bpf_func_proto bpf_strncmp_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg2_type = ARG_CONST_SIZE, + .arg2_type = ARG_MEM_SIZE, .arg3_type = ARG_PTR_TO_CONST_STR, };
@@ -627,7 +627,7 @@ const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto = { .arg1_type = ARG_ANYTHING, .arg2_type = ARG_ANYTHING, .arg3_type = ARG_PTR_TO_UNINIT_MEM, - .arg4_type = ARG_CONST_SIZE, + .arg4_type = ARG_MEM_SIZE, };static const struct bpf_func_proto bpf_get_raw_smp_processor_id_proto = {
@@ -653,7 +653,7 @@ const struct bpf_func_proto bpf_event_output_data_proto = { .arg2_type = ARG_CONST_MAP_PTR, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg5_type = ARG_CONST_SIZE_OR_ZERO, + .arg5_type = ARG_MEM_SIZE_OR_ZERO, }; BPF_CALL_3(bpf_copy_from_user, void *, dst, u32, size,
@@ -675,7 +675,7 @@ const struct bpf_func_proto bpf_copy_from_user_proto = { .might_sleep = true, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_UNINIT_MEM, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_ANYTHING, };
@@ -706,7 +706,7 @@ const struct bpf_func_proto bpf_copy_from_user_task_proto = { .might_sleep = true, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_UNINIT_MEM, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_BTF_ID, .arg4_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK],
@@ -1093,10 +1093,10 @@ const struct bpf_func_proto bpf_snprintf_proto = { .gpl_only = true, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM_OR_NULL | MEM_WRITE, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_PTR_TO_CONST_STR, .arg4_type = ARG_PTR_TO_MEM | PTR_MAYBE_NULL | MEM_RDONLY, - .arg5_type = ARG_CONST_SIZE_OR_ZERO, + .arg5_type = ARG_MEM_SIZE_OR_ZERO, };static void *map_key_from_value (struct bpf_map *map,void *value,u32 *arr_idx)
@@ -1888,7 +1888,7 @@ static const struct bpf_func_proto bpf_dynptr_from_mem_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_UNINIT_MEM, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_DYNPTR | DYNPTR_TYPE_LOCAL | MEM_UNINIT | MEM_WRITE, };
@@ -1943,7 +1943,7 @@ static const struct bpf_func_proto bpf_dynptr_read_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_UNINIT_MEM, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_PTR_TO_DYNPTR, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING,
@@ -2004,7 +2004,7 @@ static const struct bpf_func_proto bpf_dynptr_write_proto = { .arg1_type = ARG_PTR_TO_DYNPTR, .arg2_type = ARG_ANYTHING, .arg3_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg4_type = ARG_CONST_SIZE_OR_ZERO, + .arg4_type = ARG_MEM_SIZE_OR_ZERO, .arg5_type = ARG_ANYTHING, };
kernel/bpf/ringbuf.c +1 -1
@@ -634,7 +634,7 @@ const struct bpf_func_proto bpf_ringbuf_output_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_CONST_MAP_PTR, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
kernel/bpf/stackmap.c +5 -5
@@ -781,7 +781,7 @@ const struct bpf_func_proto bpf_get_stack_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
@@ -797,7 +797,7 @@ const struct bpf_func_proto bpf_get_stack_sleepable_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
@@ -831,7 +831,7 @@ const struct bpf_func_proto bpf_get_task_stack_proto = { .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK], .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
@@ -848,7 +848,7 @@ const struct bpf_func_proto bpf_get_task_stack_sleepable_proto = { .arg1_type = ARG_PTR_TO_BTF_ID, .arg1_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK], .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
@@ -911,7 +911,7 @@ const struct bpf_func_proto bpf_get_stack_proto_pe = { .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_UNINIT_MEM, - .arg3_type = ARG_CONST_SIZE_OR_ZERO, + .arg3_type = ARG_MEM_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, };
kernel/bpf/syscall.c +2 -2
@@ -6544,7 +6544,7 @@ static const struct bpf_func_proto bpf_sys_bpf_proto = { .ret_type = RET_INTEGER, .arg1_type = ARG_ANYTHING, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_MEM_SIZE, }; const struct bpf_func_proto * __weak
@@ -6591,7 +6591,7 @@ static const struct bpf_func_proto bpf_kallsyms_lookup_name_proto = { .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg2_type = ARG_CONST_SIZE_OR_ZERO, + .arg2_type = ARG_MEM_SIZE_OR_ZERO, .arg3_type = ARG_ANYTHING, .arg4_type = ARG_PTR_TO_FIXED_SIZE_MEM | MEM_UNINIT | MEM_WRITE | MEM_ALIGNED, .arg4_size = sizeof(u64),
kernel/bpf/verifier.c +5 -6
@@ -7704,8 +7704,7 @@ static int process_iter_next_call(struct bpf_verifier_env *env, int insn_idx,static bool arg_type_is_mem_size (enum bpf_arg_type type) { -return type ==ARG_CONST_SIZE || - type ==ARG_CONST_SIZE_OR_ZERO ; +return type ==ARG_MEM_SIZE || type ==ARG_MEM_SIZE_OR_ZERO ; }static bool arg_type_is_raw_mem (enum bpf_arg_type type)
@@ -7851,8 +7850,8 @@ static const struct bpf_reg_types dynptr_types = {static const struct bpf_reg_types *compatible_reg_types[__BPF_ARG_TYPE_MAX] = { [ARG_PTR_TO_MAP_KEY ] = &mem_types, [ARG_PTR_TO_MAP_VALUE ] = &mem_types, - [ARG_CONST_SIZE ] = &scalar_types, - [ARG_CONST_SIZE_OR_ZERO ] = &scalar_types, + [ARG_MEM_SIZE ] = &scalar_types, + [ARG_MEM_SIZE_OR_ZERO ] = &scalar_types, [ARG_CONST_ALLOC_SIZE_OR_ZERO ] = &scalar_types, [ARG_CONST_MAP_PTR ] = &const_map_ptr_types, [ARG_PTR_TO_CTX ] = &context_types,
@@ -8470,13 +8469,13 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, err =check_ptr_alignment (env, reg,0 , fn->arg_size[arg], true); }break ; -case ARG_CONST_SIZE : +case ARG_MEM_SIZE : err =check_mem_size_reg (env,reg_state (env, regno -1 ), reg,argno_from_reg (regno -1 ), argno, fn->arg_type[arg -1 ] &MEM_WRITE ?BPF_WRITE :BPF_READ , false, meta);break ; -case ARG_CONST_SIZE_OR_ZERO : +case ARG_MEM_SIZE_OR_ZERO : err = check_mem_size_reg(env, reg_state(env, regno - 1), reg, argno_from_reg(regno - 1), argno, fn->arg_type[arg - 1] & MEM_WRITE ? BPF_WRITE : BPF_READ,
kernel/trace/bpf_trace.c +31 -31
203 lines not on this page · raw message
net/core/filter.c +58 -58
449 lines not on this page · raw message
tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c +1 -1
@@ -137,7 +137,7 @@ int helper_param_not_ok(void *ctx) p =bpf_rdonly_cast (0 ,0 );/* -* Any helper with ARG_CONST_SIZE_OR_ZERO constraint will do, +* Any helper with ARG_MEM_SIZE_OR_ZERO constraint will do, * the most permissive constraint */ bpf_copy_from_user (p,0 , (void *)42 );
tools/testing/selftests/bpf/progs/verifier_bounds.c +1 -1
@@ -1195,7 +1195,7 @@ l0_%=: r1 = r6; \ r3 +=-8 ; \ r5 =0 ; \/* The 4th argument of bpf_skb_store_bytes is defined as \ -* ARG_CONST_SIZE, so 0 is not allowed. The 'r4 != 0' \ +* ARG_MEM_SIZE, so 0 is not allowed. The 'r4 != 0' \ * is providing us this exclusion of zero from initial \ * [0, 7] range. \ */ \
tools/testing/selftests/bpf/progs/verifier_helper_access_var_len.c +3 -3
@@ -85,7 +85,7 @@ __naked void stack_bitwise_and_zero_included(void) r2 +=-64 ; \ r4 =0 ; \/* Call bpf_ringbuf_output(), it is one of a few helper functions with\ -* ARG_CONST_SIZE_OR_ZERO parameter allowed in unpriv mode.\ +* ARG_MEM_SIZE_OR_ZERO parameter allowed in unpriv mode.\ * For unpriv this should signal an error, because memory at &fp[-64] is\ * not initialized. \ */ \
@@ -278,7 +278,7 @@ __naked void stack_jmp_no_min_check(void) r2 +=-64 ; \ r4 =0 ; \/* Call bpf_ringbuf_output(), it is one of a few helper functions with\ -* ARG_CONST_SIZE_OR_ZERO parameter allowed in unpriv mode.\ +* ARG_MEM_SIZE_OR_ZERO parameter allowed in unpriv mode.\ * For unpriv this should signal an error, because memory at &fp[-64] is\ * not initialized. \ */ \
@@ -778,7 +778,7 @@ __naked void variable_memory_8_bytes_leak(void) r3 +=1 ; \ r4 =0 ; \/* Call bpf_ringbuf_output(), it is one of a few helper functions with\ -* ARG_CONST_SIZE_OR_ZERO parameter allowed in unpriv mode.\ +* ARG_MEM_SIZE_OR_ZERO parameter allowed in unpriv mode.\ * For unpriv this should signal an error, because memory region [1, 64]\ * at &fp[-64] is not fully initialized. \ */ \
tools/testing/selftests/bpf/progs/verifier_helper_value_access.c +1 -1
@@ -91,7 +91,7 @@ l0_%=: exit; \/* Call a function taking a pointer and a size which doesn't allow the size to * be zero (i.e. bpf_trace_printk() declares the second argument to be -* ARG_CONST_SIZE, not ARG_CONST_SIZE_OR_ZERO). We attempt to pass zero for the +* ARG_MEM_SIZE, not ARG_MEM_SIZE_OR_ZERO). We attempt to pass zero for the * size and expect to fail. */ SEC ("tracepoint" )
Signature · 1 line
2.52.0
PATCH v3 10/18 bpf: Fold __szk const size handling into the scalar arg path
In reply to Amery HungTo align helper and kfunc pointer to memory argument handling, move kfunc constant memorry size argument handling to the kfunc scalar section. In addition, factor out constant scalar argument handling.
The constant size argument (__szk) of a kfunc memory/size pair was recorded into meta->arg_constant by a dedicated block in the KF_ARG_PTR_TO_MEM_SIZE case, duplicating the "only one constant argument" and "must be a known constant" checks already in the generic scalar argument handling. That block also did an explicit i++ to skip the size argument.
This also fixes a precision gap: the old dedicated block did not mark the size register precise, relying on check_mem_size_reg() for that. But check_mem_size_reg() is skipped when the buffer is a nullable arg passed as NULL (e.g. bpf_dynptr_slice(_rdwr) with a NULL buffer), so in that case the __szk value was recorded and used for regs[R0].mem_size without marking it precise. Routing the size through the scalar path marks it precise in all cases.
--- include/linux/bpf_verifier.h | 11 +++--- kernel/bpf/verifier.c | 66 +++++++++++++++++------------------- 2 files changed, 39 insertions(+), 38 deletions(-)
include/linux/bpf_verifier.h +7 -4
@@ -1479,6 +1479,12 @@ struct ret_mem_desc {bool found; }; +/* A constant scalar argument; Populated by process_const_arg() */ +struct arg_constant_desc { +u64 value; +bool found; +}; +struct bpf_call_arg_meta {/* Common */ struct btf *btf;
@@ -1496,10 +1502,7 @@ struct bpf_call_arg_meta {u32 kfunc_flags;const struct btf_type *func_proto;const char *func_name; -struct { -u64 value; -bool found; - } arg_constant; +struct arg_constant_desc arg_constant;/* arg_{btf,btf_id,owning_ref} are used by kfunc-specific handling, * generally to pass info about user-defined local kptr types to later
kernel/bpf/verifier.c +32 -34
92 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH v3 11/18 selftests/bpf: Test __szk precision with a NULL nullable buffer
In reply to Amery HungWhen a nullable buffer is passed as NULL, check_mem_size_reg() is skipped, so the __szk memory size must be marked precise through the scalar argument path instead. Exercise this with bpf_dynptr_slice() and a NULL buffer.
--- .../selftests/bpf/prog_tests/verifier.c | 2 ++ .../bpf/progs/verifier_mem_size_reg.c | 28 +++++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_mem_size_reg.c
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
@@ -68,6 +68,7 @@#include "verifier_masking.skel.h" #include "verifier_may_goto_1.skel.h" #include "verifier_may_goto_2.skel.h" +#include "verifier_mem_size_reg.skel.h" #include "verifier_meta_access.skel.h" #include "verifier_movsx.skel.h" #include "verifier_mtu.skel.h"
@@ -223,6 +224,7 @@ void test_verifier_map_ret_val(void) { RUN(verifier_map_ret_val); }void test_verifier_masking (void ) {RUN (verifier_masking); }void test_verifier_may_goto_1 (void ) {RUN (verifier_may_goto_1); }void test_verifier_may_goto_2 (void ) {RUN (verifier_may_goto_2); } +void test_verifier_mem_size_reg (void ) {RUN (verifier_mem_size_reg); }void test_verifier_meta_access (void ) {RUN (verifier_meta_access); }void test_verifier_movsx (void ) {RUN (verifier_movsx); }void test_verifier_mul (void ) {RUN (verifier_mul); }
tools/testing/selftests/bpf/progs/verifier_mem_size_reg.c new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include "bpf_misc.h" +#include "bpf_kfuncs.h" + +char _license[] SEC("license") = "GPL"; + +/* +* The __szk size of a kfunc memory/size pair must be marked precise even when +* the nullable buffer is passed as NULL. +*/ +SEC("?tc") +__success __log_level(2) +__msg("mark_precise: frame0: regs=r4 stack= before") +int dynptr_slice_null_buf_size_precise (struct __sk_buff *skb) +{ +struct bpf_dynptr dptr; +char *p; + +bpf_dynptr_from_skb (skb,0 , &dptr); + + p =bpf_dynptr_slice (&dptr,0 ,NULL ,8 ); +if (p) +return p[0 ]; +return 0 ; +}
Signature · 1 line
2.52.0
PATCH v3 12/18 bpf: Classify kfunc mem_size args from BTF without register state
In reply to Amery Hungcheck_kfunc_args() already makes sure a scalar value is passed to a scalar kfunc argument. Drop the check in is_kfunc_arg_mem_size() and is_kfunc_arg_const_mem_size() to further decouple get_kfunc_ptr_arg_type() from register state (a prerequisite for generating a helper-like prototype from kfunc's BTF).
--- kernel/bpf/verifier.c | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-)
kernel/bpf/verifier.c +9 -11
@@ -10785,26 +10785,24 @@ static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) }static bool is_kfunc_arg_mem_size (const struct btf *btf, -const struct btf_param *arg, -const struct bpf_reg_state *reg) +const struct btf_param *arg) {const struct btf_type *t; t =btf_type_skip_modifiers (btf, arg->type,NULL ); -if (!btf_type_is_scalar (t) || reg->type !=SCALAR_VALUE ) +if (!btf_type_is_scalar (t))return false;return btf_param_match_suffix (btf, arg,"__sz" ); }static bool is_kfunc_arg_const_mem_size (const struct btf *btf, -const struct btf_param *arg, -const struct bpf_reg_state *reg) +const struct btf_param *arg) {const struct btf_type *t; t =btf_type_skip_modifiers (btf, arg->type,NULL ); -if (!btf_type_is_scalar (t) || reg->type !=SCALAR_VALUE ) +if (!btf_type_is_scalar (t))return false;return btf_param_match_suffix (btf, arg,"__szk" );
@@ -11338,7 +11336,7 @@ bool bpf_is_kfunc_pkt_changing(struct bpf_call_arg_meta *meta) } static enum kfunc_ptr_arg_type -get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_func_state *caller, +get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_reg_state *regs, struct bpf_call_arg_meta *meta, const struct btf_type *t, const struct btf_type *ref_t, const char *ref_tname, const struct btf_param *args,
@@ -11352,8 +11350,8 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_func_state *callreturn KF_ARG_PTR_TO_CTX ;if (arg +1 < nargs && - (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ],get_func_arg_reg (caller, regs, arg +1 )) || -is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ],get_func_arg_reg (caller, regs, arg +1 )))) + (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || +is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) arg_mem_size = true;/* In this function, we verify the kfunc's BTF as per the argument type,
@@ -12084,7 +12082,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me }if (is_kfunc_arg_constant (meta->btf, &args[i]) || -is_kfunc_arg_const_mem_size (meta->btf, &args[i], reg)) { +is_kfunc_arg_const_mem_size (meta->btf, &args[i])) { ret =process_const_arg (env, reg, argno, meta);if (ret <0 )return ret;
@@ -12129,7 +12127,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); ref_tname =btf_name_by_offset (btf, ref_t->name_off); - kf_arg_type =get_kfunc_ptr_arg_type (env, caller, regs, meta, t, ref_t, ref_tname, + kf_arg_type =get_kfunc_ptr_arg_type (env, regs, meta, t, ref_t, ref_tname, args, i, nargs, argno, reg);if (kf_arg_type <0 )return kf_arg_type;
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH bpf-next v3 12/18] bpf: Classify kfunc mem_size args from BTF without register state
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Removing the register type check from `is_kfunc_arg_mem_size()` allows a BPF program to pass a…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Removing the register type check from is_kfunc_arg_mem_size() allows a BPF program to pass a pointer register as a memory size parameter (__sz), which triggers a verifier_bug and a kernel warning. --
--- Patch [12]: [PATCH bpf-next v3 12/18] bpf: Classify kfunc mem_size args from BTF without register state --- commit e7666ea9e561228e1708d772f8e42d33c514cde8
Author: Amery Hung <[email protected]>
bpf: Classify kfunc mem_size args from BTF without register state
This commit removes register state checks from is_kfunc_arg_mem_size() and is_kfunc_arg_const_mem_size(). It relies solely on BTF to classify kfunc memory size arguments to further decouple argument type classification from register state.
Quoted 7 lines
kernel/bpf/verifier.c +0
-0@@ -10785,26 +10785,24 @@ static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) }
kernel/bpf/verifier.c static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) · line 10793
Quoted 10 lines
kernel/bpf/verifier.c +2
-3static bool is_kfunc_arg_mem_size (const struct btf *btf, -const struct btf_param *arg, -const struct bpf_reg_state *reg) +const struct btf_param *arg) {const struct btf_type *t; t =btf_type_skip_modifiers (btf, arg->type,NULL ); -if (!btf_type_is_scalar (t) || reg->type !=SCALAR_VALUE ) +if (!btf_type_is_scalar (t))
[Severity: High]
Does removing this SCALAR_VALUE check allow a BPF program to pass a pointer register instead of a scalar to a kfunc's size argument, potentially triggering a verifier_bug()?
If get_kfunc_ptr_arg_type() sets arg_mem_size purely based on BTF, check_kfunc_args() will process the memory pointer argument, peek ahead at the size argument, and call check_mem_size_reg():
kernel/bpf/verifier.c:check_kfunc_args() {
...
ret = check_mem_size_reg(env, buff_reg, size_reg, argno, next_argno,
BPF_READ | BPF_WRITE, true, meta);
...
}This happens before the main loop reaches the size argument and ensures it is a SCALAR_VALUE.
If a pointer register with a fixed zero offset is passed, check_mem_size_reg() might assume it is a valid scalar value of 0, pass the boundary checks, and call mark_chain_precision(). This explicitly triggers verifier_bug(env, "backtracking misuse") if the register is not a SCALAR_VALUE.
Could this lead to a kernel panic on systems with panic_on_warn=1?
Quoted 4 lines
kernel/bpf/verifier.c +0
-0return false;return btf_param_match_suffix (btf, arg,"__sz" ); }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
Re: [PATCH bpf-next v3 12/18] bpf: Classify kfunc mem_size args from BTF without register state
Quoted 30 lines · On Sat, Aug 1, 2026 at 1:09 AM <[email protected]> wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Removing the register type check fromis_kfunc_arg_mem_size()allows a BPF program to pass a pointer register as a memory size parameter (__sz), which triggers averifier_bugand a kernel warning. ----- Patch [12]: [PATCH bpf-next v3 12/18] bpf: Classify kfunc
mem_sizeargs from BTF without register state --- commite7666ea9e561228e1708d772f8e42d33c514cde8
Author: Amery Hung <[email protected]>bpf: Classify kfunc
mem_sizeargs from BTF without register stateThis commit removes register state checks from
is_kfunc_arg_mem_size()andis_kfunc_arg_const_mem_size(). It relies solely on BTF to classify kfunc memory size arguments to further decouple argument type classification from register state.Quoted 14 lines
kernel/bpf/verifier.c +1
-2@@ -10785,26 +10785,24 @@ static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) }static bool is_kfunc_arg_mem_size (const struct btf *btf, -const struct btf_param *arg, -const struct bpf_reg_state *reg) +const struct btf_param *arg) {const struct btf_type *t;
Quoted 8 lines
kernel/bpf/verifier.c static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) · line 10793
Quoted 3 lines
kernel/bpf/verifier.c +1
-1t =btf_type_skip_modifiers (btf, arg->type,NULL ); -if (!btf_type_is_scalar (t) || reg->type !=SCALAR_VALUE ) +if (!btf_type_is_scalar (t))[Severity: High]
Does removing thisSCALAR_VALUEcheck allow a BPF program to pass a pointer register instead of a scalar to a kfunc's size argument, potentially triggering averifier_bug()?
The issue is only temporary. It is not bisect safe but simplifies the patches. The issue will go away after patch 17 once check_mem_size_reg() is dispatched on KF_ARG_MEM_SIZE.
Quoted 4 lines
If
get_kfunc_ptr_arg_type()setsarg_mem_sizepurely based on BTF,check_kfunc_args()will process the memory pointer argument, peek ahead at the size argument, and callcheck_mem_size_reg():
A later patch will also defer mem+size checking to KF_ARG_MEM_SIZE similar to helper (look back) so check_mem_size_reg() will only be called after size if validated.
Quoted 26 lines
kernel/bpf/verifier.c:check_kfunc_args() { ... ret = check_mem_size_reg(env, buff_reg, size_reg, argno, next_argno, BPF_READ | BPF_WRITE, true, meta); ... }This happens before the main loop reaches the size argument and ensures it is a
SCALAR_VALUE.If a pointer register with a fixed zero offset is passed,
check_mem_size_reg()might assume it is a valid scalar value of 0, pass the boundary checks, and callmark_chain_precision(). This explicitly triggersverifier_bug(env, "backtracking misuse")if the register is not aSCALAR_VALUE.Could this lead to a kernel panic on systems with panic_on_warn=1?
kernel/bpf/verifier.c static bool is_kfunc_rcu_protected(struct bpf_call_arg_meta *meta) · line 10797
Quoted 4 lines
kernel/bpf/verifier.c +0
-0return false;return btf_param_match_suffix (btf, arg,"__sz" ); }--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
PATCH v3 13/18 bpf: Handle NULL kfunc pointer args without a KF_ARG_PTR_TO_NULL type
In reply to Amery Hungget_kfunc_ptr_arg_type() returned KF_ARG_PTR_TO_NULL when a nullable pointer argument was passed a NULL register. This folded a register-state decision (bpf_register_is_null()) into what is otherwise BTF-based argument classification, and it short-circuited before the BTF_ID/MEM resolution.
Drop KF_ARG_PTR_TO_NULL and handle the NULL case in check_kfunc_args()
instead: a nullable argument that is actually NULL is skipped. Note that it is okay to skip even when it is a mem+size pair because the size argument check has been moved to the scalar section. The skip is done before get_kfunc_ptr_arg_type() so that a NULL passed to a nullable non-scalar-struct argument is not newly rejected by the BTF_ID/MEM resolution.
No functional change.
--- kernel/bpf/verifier.c | 37 +++++++++++++++---------------------- 1 file changed, 15 insertions(+), 22 deletions(-)
kernel/bpf/verifier.c +15 -22
@@ -11072,7 +11072,6 @@ enum kfunc_ptr_arg_type {KF_ARG_PTR_TO_CALLBACK ,KF_ARG_PTR_TO_RB_ROOT ,KF_ARG_PTR_TO_RB_NODE , -KF_ARG_PTR_TO_NULL ,KF_ARG_PTR_TO_CONST_STR ,KF_ARG_CONST_MAP_PTR , KF_ARG_PTR_TO_TIMER,
@@ -11349,11 +11348,6 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, meta->func_id == special_kfunc_list[KF_bpf_session_cookie])return KF_ARG_PTR_TO_CTX ; -if (arg +1 < nargs && - (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || -is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) - arg_mem_size = true; -/* In this function, we verify the kfunc's BTF as per the argument type, * leaving the rest of the verification with respect to the register * type to our caller. When a set of conditions hold in the BTF type of
@@ -11362,10 +11356,6 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,if (btf_is_prog_ctx_type (&env->log, meta->btf, t,resolve_prog_type (env->prog), arg))return KF_ARG_PTR_TO_CTX ; -if (is_kfunc_arg_nullable (meta->btf, &args[arg]) &&bpf_register_is_null (reg) && - !arg_mem_size) -return KF_ARG_PTR_TO_NULL ; -if (is_kfunc_arg_alloc_obj (meta->btf, &args[arg]))return KF_ARG_PTR_TO_ALLOC_BTF_ID ;
@@ -11427,6 +11417,11 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,if (is_kfunc_arg_callback (env, meta->btf, &args[arg]))return KF_ARG_PTR_TO_CALLBACK ; +if (arg +1 < nargs && + (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || +is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) + arg_mem_size = true; +/* This is the catch all argument type of register types supported by * check_helper_mem_access. However, we only allow when argument type is * pointer to scalar, or struct composed (recursively) of scalars. When
@@ -12127,6 +12122,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); ref_tname =btf_name_by_offset (btf, ref_t->name_off); +if (is_kfunc_arg_nullable (meta->btf, &args[i]) &&bpf_register_is_null (reg)) +continue ; + kf_arg_type =get_kfunc_ptr_arg_type (env, regs, meta, t, ref_t, ref_tname, args, i, nargs, argno, reg);if (kf_arg_type <0 )
@@ -12139,8 +12137,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me }switch (kf_arg_type) { -case KF_ARG_PTR_TO_NULL : -continue ;case KF_ARG_PTR_TO_ALLOC_BTF_ID :case KF_ARG_PTR_TO_BTF_ID :if (!is_trusted_reg (env, reg)) {
@@ -12405,19 +12401,16 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mecase KF_ARG_PTR_TO_MEM_SIZE : {struct bpf_reg_state *buff_reg = reg; -const struct btf_param *buff_arg = &args[i];struct bpf_reg_state *size_reg =get_func_arg_reg (caller, regs, i +1 );argno_t next_argno =argno_from_arg (i +2 ); -if (!bpf_register_is_null (buff_reg) || !is_kfunc_arg_nullable (meta->btf, buff_arg)) { - ret =check_mem_size_reg (env, buff_reg, size_reg, argno, next_argno, -BPF_READ |BPF_WRITE , true, meta); -if (ret <0 ) { -verbose (env,"%s and " ,reg_arg_name (env, argno)); -verbose (env,"%s memory, len pair leads to invalid memory access\n" , -reg_arg_name (env, next_argno)); -return ret; - } + ret =check_mem_size_reg (env, buff_reg, size_reg, argno, next_argno, +BPF_READ |BPF_WRITE , true, meta); +if (ret <0 ) { +verbose (env,"%s and " ,reg_arg_name (env, argno)); +verbose (env,"%s memory, len pair leads to invalid memory access\n" , +reg_arg_name (env, next_argno)); +return ret; }break ; }
Signature · 1 line
2.52.0
PATCH v3 14/18 bpf: Distinguish fixed- and variable-size kfunc mem args with MEM_FIXED_SIZE
In reply to Amery HungA kfunc memory-pointer argument comes in two flavors: a fixed-size buffer whose access size is derived from the pointed-to BTF type, and a variable-size buffer paired with a following __sz/__szk size argument. Both were represented by separate kfunc_ptr_arg_type values (KF_ARG_PTR_TO_MEM vs KF_ARG_PTR_TO_MEM_SIZE) with the pointer classified as the latter when a size argument followed.
Mirror how helpers describe the same distinction: classify both as KF_ARG_PTR_TO_MEM and OR in MEM_FIXED_SIZE for the fixed-size case, just as helpers use ARG_PTR_TO_MEM | MEM_FIXED_SIZE. The switches now key on base_type(kf_arg_type) so the flag rides along, and the KF_ARG_PTR_TO_MEM handler either resolves the size from BTF (MEM_FIXED_SIZE) or falls through to the mem/size-pair check, which validates the buffer against the following size register and skips it. No functional change.
Currently, KF_ARG_MEM_SIZE and KF_ARG_CONST_MEM_SIZE are only reachable from ARG_PTR_TO_MEM fallthrough. A patch later will merge scalar checking into the same switch and remove the fallthrough.
--- kernel/bpf/verifier.c | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-)
kernel/bpf/verifier.c +21 -17
@@ -11059,6 +11059,8 @@ static bool __btf_type_is_scalar_struct(struct bpf_verifier_env *env, }enum kfunc_ptr_arg_type { +KF_ARG_CONST_MEM_SIZE , +KF_ARG_MEM_SIZE ,KF_ARG_PTR_TO_CTX ,KF_ARG_PTR_TO_ALLOC_BTF_ID ,/* Allocated object */ KF_ARG_PTR_TO_REFCOUNTED_KPTR ,/* Refcounted local kptr */
@@ -11068,7 +11070,6 @@ enum kfunc_ptr_arg_type {KF_ARG_PTR_TO_LIST_NODE ,KF_ARG_PTR_TO_BTF_ID ,/* Also covers reg2btf_ids conversions */ KF_ARG_PTR_TO_MEM , -KF_ARG_PTR_TO_MEM_SIZE ,/* Size derived from next argument, skip it */ KF_ARG_PTR_TO_CALLBACK ,KF_ARG_PTR_TO_RB_ROOT , KF_ARG_PTR_TO_RB_NODE,
@@ -11334,7 +11335,7 @@ bool bpf_is_kfunc_pkt_changing(struct bpf_call_arg_meta *meta)return meta->func_id == special_kfunc_list[KF_bpf_xdp_pull_data]; } -static enum kfunc_ptr_arg_type +static int get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_reg_state *regs, struct bpf_call_arg_meta *meta, const struct btf_type *t, const struct btf_type *ref_t,
@@ -11434,7 +11435,7 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, btf_type_str(ref_t), ref_tname, arg_mem_size ? "void, " : "");return -EINVAL ; } -return arg_mem_size ?KF_ARG_PTR_TO_MEM_SIZE :KF_ARG_PTR_TO_MEM ; +return arg_mem_size ?KF_ARG_PTR_TO_MEM :KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; } static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,
@@ -12136,7 +12137,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_tname =btf_name_by_offset (btf, ref_t->name_off); } -switch (kf_arg_type) { +switch (base_type (kf_arg_type)) {case KF_ARG_PTR_TO_ALLOC_BTF_ID :case KF_ARG_PTR_TO_BTF_ID :if (!is_trusted_reg (env, reg)) {
@@ -12159,7 +12160,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mecase KF_ARG_PTR_TO_RB_ROOT :case KF_ARG_PTR_TO_RB_NODE :case KF_ARG_PTR_TO_MEM : -case KF_ARG_PTR_TO_MEM_SIZE :case KF_ARG_PTR_TO_CALLBACK :case KF_ARG_PTR_TO_CONST_STR :case KF_ARG_PTR_TO_WORKQUEUE :
@@ -12190,7 +12190,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meif (ret <0 )return ret; -switch (kf_arg_type) { +switch (base_type (kf_arg_type)) {case KF_ARG_PTR_TO_CTX :if (reg->type !=PTR_TO_CTX ) { verbose(env, "%s expected pointer to ctx, but got %s\n",
@@ -12387,18 +12387,22 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mereturn ret;break ;case KF_ARG_PTR_TO_MEM : - resolve_ret =btf_resolve_size (btf, ref_t, &type_size); -if (IS_ERR (resolve_ret)) { -verbose (env,"%s reference type('%s %s') size cannot be determined: %ld\n" , -reg_arg_name (env, argno),btf_type_str (ref_t), - ref_tname,PTR_ERR (resolve_ret)); -return -EINVAL ; +if (kf_arg_type &MEM_FIXED_SIZE ) { + resolve_ret =btf_resolve_size (btf, ref_t, &type_size); +if (IS_ERR (resolve_ret)) { +verbose (env,"%s reference type('%s %s') size cannot be determined: %ld\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), + ref_tname,PTR_ERR (resolve_ret)); +return -EINVAL ; + } + ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta); +if (ret <0 ) +return ret; +break ; } - ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta); -if (ret <0 ) -return ret; -break ; -case KF_ARG_PTR_TO_MEM_SIZE : + fallthrough; +case KF_ARG_CONST_MEM_SIZE : +case KF_ARG_MEM_SIZE : {struct bpf_reg_state *buff_reg = reg;struct bpf_reg_state *size_reg =get_func_arg_reg (caller, regs, i +1 );
Signature · 1 line
2.52.0
PATCH v3 15/18 bpf: Classify kfunc pointer arguments from BTF, resolve type against the register
In reply to Amery Hungget_kfunc_ptr_arg_type() decided part of a kfunc pointer argument's type from the caller's register: a PTR_TO_BTF_ID (or reg2btf_ids) register made the argument KF_ARG_PTR_TO_BTF_ID, otherwise it fell through to a memory buffer. Folding register state into argument classification prevents describing a kfunc's arguments from its BTF alone, which is a prerequisite for generating a helper-like prototype and eventually sharing the argument checking (check_func_arg()) between helpers and kfuncs.
Classify pointer arguments from BTF only, and resolve them against the register in check_kfunc_args():
- A pointer to a struct that is not paired with a __sz/__szk size argument is classified KF_ARG_PTR_TO_BTF_ID and then checked against the register. A register carrying a BTF ID (PTR_TO_BTF_ID or a reg2btf_ids type) must be referenced or trusted and is matched against the expected type. The only relaxation is when the struct is composed of scalars, the register may be verified as a fixed-size memory buffer sized from the BTF type; anything else is rejected.
- A pointer paired with a size argument is always a memory buffer and is never classified as BTF_ID, so the __sz/__szk case no longer detours through BTF_ID.
The new design now accepts one previously rejected case: passing PTR_TO_BTF_ID to a pointer to scalar w/o a following __sz/__szk. The argument will be classified as KF_ARG_PTR_TO_MEM | MEM_FIXED_SIZE. The PTR_TO_BTF_ID register will go through check_mem_reg() -> check_helper_mem_access() -> check_ptr_to_btf_access(), and by default only read is allowed.
The referenced-or-trusted check thus moves into the KF_ARG_PTR_TO_BTF_ID resolution, alongside the type match.
get_kfunc_ptr_arg_type() no longer needs the register, so drop its regs and reg parameters; it is now a pure function of the kfunc's BTF.
When a register cannot satisfy a BTF_ID argument, report the register type passed and, when the expected struct has a reg2btf_ids mapping, the register type that would be accepted, instead of a confusing "socket". Update the affected selftest messages accordingly.
--- kernel/bpf/verifier.c | 130 ++++++++++-------- .../selftests/bpf/progs/cgrp_kfunc_failure.c | 2 +- .../selftests/bpf/progs/task_kfunc_failure.c | 2 +- .../selftests/bpf/progs/verifier_vfs_reject.c | 6 +- tools/testing/selftests/bpf/verifier/calls.c | 6 +- 5 files changed, 84 insertions(+), 62 deletions(-)
kernel/bpf/verifier.c +76 -54
@@ -4926,6 +4926,18 @@ static u32 *reg2btf_ids[__BPF_REG_TYPE_MAX] = { [CONST_PTR_TO_MAP] = btf_bpf_map_id, }; +static enum bpf_reg_type lookup_reg2btf_ids (u32 ref_id) +{ +enum bpf_reg_type type; + +for (type =0 ; type < __BPF_REG_TYPE_MAX; type++) { +if (reg2btf_ids[type] && *reg2btf_ids[type] == ref_id) +return type; + } + +return NOT_INIT ; +} +static bool is_trusted_reg (struct bpf_verifier_env *env,const struct bpf_reg_state *reg) {/* A referenced register is always trusted. */
@@ -11336,14 +11348,11 @@ bool bpf_is_kfunc_pkt_changing(struct bpf_call_arg_meta *meta) }static int -get_kfunc_ptr_arg_type (struct bpf_verifier_env *env, -struct bpf_reg_state *regs,struct bpf_call_arg_meta *meta, +get_kfunc_ptr_arg_type (struct bpf_verifier_env *env,struct bpf_call_arg_meta *meta,const struct btf_type *t,const struct btf_type *ref_t,const char *ref_tname,const struct btf_param *args, -int arg,int nargs,argno_t argno,struct bpf_reg_state *reg) +int arg,int nargs,argno_t argno) { -bool arg_mem_size = false; -if (meta->func_id == special_kfunc_list[KF_bpf_cast_to_kern_ctx] || meta->func_id == special_kfunc_list[KF_bpf_session_is_return] || meta->func_id == special_kfunc_list[KF_bpf_session_cookie])
@@ -11405,37 +11414,37 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,if (is_kfunc_arg_res_spin_lock (meta->btf, &args[arg]))return KF_ARG_PTR_TO_RES_SPIN_LOCK ; -if ((base_type (reg->type) ==PTR_TO_BTF_ID || reg2btf_ids[base_type (reg->type)])) { -if (!btf_type_is_struct (ref_t)) { -verbose (env,"kernel function %s %s pointer type %s %s is not supported\n" , - meta->func_name,reg_arg_name (env, argno), -btf_type_str (ref_t), ref_tname); -return -EINVAL ; - } -return KF_ARG_PTR_TO_BTF_ID ; - } -if (is_kfunc_arg_callback (env, meta->btf, &args[arg]))return KF_ARG_PTR_TO_CALLBACK ;if (arg +1 < nargs && (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || -is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) - arg_mem_size = true; +is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) { +if (!btf_type_is_void (ref_t) && !btf_type_is_scalar (ref_t) && + !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +verbose (env,"%s pointer type %s %s must point to void, scalar, or struct with scalar\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname); +return -EINVAL ; + } +return KF_ARG_PTR_TO_MEM ; + } -/* This is the catch all argument type of register types supported by -* check_helper_mem_access. However, we only allow when argument type is -* pointer to scalar, or struct composed (recursively) of scalars. When -* arg_mem_size is true, the pointer can be void *. +/* A pointer to a struct without a size argument is classified as KF_ARG_PTR_TO_BTF_ID */ +if (btf_type_is_struct (ref_t)) +return KF_ARG_PTR_TO_BTF_ID ; + +/* +* Otherwise this is a fixed-size memory buffer supported by +* check_helper_mem_access(): a pointer to a scalar or a struct of +* scalars. The access size is derived from the pointed-to BTF type. */ -if (!btf_type_is_scalar (ref_t) && !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 ) && - (arg_mem_size ? !btf_type_is_void (ref_t) :1 )) { -verbose (env,"%s pointer type %s %s must point to %sscalar, or struct with scalar\n" , -reg_arg_name (env, argno), -btf_type_str (ref_t), ref_tname, arg_mem_size ?"void, " :"" ); +if (!btf_type_is_scalar (ref_t) && + !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +verbose (env,"%s pointer type %s %s must point to scalar, or struct with scalar\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname);return -EINVAL ; } -return arg_mem_size ?KF_ARG_PTR_TO_MEM :KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; +return KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; } static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,
@@ -12126,8 +12135,8 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meif (is_kfunc_arg_nullable (meta->btf, &args[i]) &&bpf_register_is_null (reg))continue ; - kf_arg_type =get_kfunc_ptr_arg_type (env, regs, meta, t, ref_t, ref_tname, - args, i, nargs, argno, reg); + kf_arg_type =get_kfunc_ptr_arg_type (env, meta, t, ref_t, ref_tname, + args, i, nargs, argno);if (kf_arg_type <0 )return kf_arg_type;
@@ -12140,19 +12149,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meswitch (base_type (kf_arg_type)) {case KF_ARG_PTR_TO_ALLOC_BTF_ID :case KF_ARG_PTR_TO_BTF_ID : -if (!is_trusted_reg (env, reg)) { -if (!is_kfunc_rcu (meta)) { -verbose (env,"%s must be referenced or trusted\n" , -reg_arg_name (env, argno)); -return -EINVAL ; - } -if (!is_rcu_reg (reg)) { -verbose (env,"%s must be a rcu pointer\n" , -reg_arg_name (env, argno)); -return -EINVAL ; - } - } - fallthrough;case KF_ARG_CONST_MAP_PTR :case KF_ARG_PTR_TO_ITER :case KF_ARG_PTR_TO_LIST_HEAD :
@@ -12372,20 +12368,46 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mebreak ;case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if ((base_type (reg->type) !=PTR_TO_BTF_ID || - (bpf_type_has_unsafe_modifiers (reg->type) && !is_rcu_reg (reg))) && - !reg2btf_ids[base_type (reg->type)]) { -verbose (env,"%s is %s " ,reg_arg_name (env, argno), -reg_type_str (env, reg->type)); -verbose (env,"expected %s or socket\n" , -reg_type_str (env,base_type (reg->type) | - (type_flag (reg->type) &BPF_REG_TRUSTED_MODIFIERS ))); +if (base_type (reg->type) ==PTR_TO_BTF_ID || + reg2btf_ids[base_type (reg->type)]) { +if (!is_trusted_reg (env, reg) || +bpf_type_has_unsafe_modifiers (reg->type)) { +if (!is_kfunc_rcu (meta)) { +verbose (env,"%s must be referenced or trusted\n" , +reg_arg_name (env, argno)); +return -EINVAL ; + } +if (!is_rcu_reg (reg)) { +verbose (env,"%s must be a rcu pointer\n" , +reg_arg_name (env, argno)); +return -EINVAL ; + } + } + + ret =process_kf_arg_ptr_to_btf_id (env, reg, ref_t, ref_tname, ref_id, meta, i, argno); +if (ret <0 ) +return ret; +break ; + } + +if (!__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +enum bpf_reg_type reg2btf_type =lookup_reg2btf_ids (ref_id); + +verbose (env,"%s is %s expected %s %s" , +reg_arg_name (env, argno),reg_type_str (env, reg->type), +btf_type_str (ref_t), ref_tname); +if (reg2btf_type !=NOT_INIT ) +verbose (env," or %s" ,reg_type_str (env, reg2btf_type)); +verbose (env,"\n" );return -EINVAL ; } - ret =process_kf_arg_ptr_to_btf_id (env, reg, ref_t, ref_tname, ref_id, meta, i, argno); -if (ret <0 ) -return ret; -break ; + +/* +* If the register does not contain btf id but the argument type is a pointer to +* scalar-only struct, allow verifying it as a fixed size memory. +*/ + kf_arg_type =KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; + fallthrough;case KF_ARG_PTR_TO_MEM :if (kf_arg_type &MEM_FIXED_SIZE ) { resolve_ret =btf_resolve_size (btf, ref_t, &type_size);
tools/testing/selftests/bpf/progs/cgrp_kfunc_failure.c +1 -1
@@ -64,7 +64,7 @@ int BPF_PROG(cgrp_kfunc_acquire_no_null_check, struct cgroup *cgrp, const char * } SEC("tp_btf/cgroup_mkdir") -__failure __msg("R1 pointer type STRUCT cgroup must point") +__failure __msg("R1 is fp expected STRUCT cgroup") int BPF_PROG(cgrp_kfunc_acquire_fp, struct cgroup *cgrp, const char *path) {struct cgroup *acquired, *stack_cgrp = (struct cgroup *)&path;
tools/testing/selftests/bpf/progs/task_kfunc_failure.c +1 -1
@@ -50,7 +50,7 @@ int BPF_PROG(task_kfunc_acquire_untrusted, struct task_struct *task, u64 clone_f } SEC("tp_btf/task_newtask") -__failure __msg("R1 pointer type STRUCT task_struct must point") +__failure __msg("R1 is fp expected STRUCT task_struct") int BPF_PROG(task_kfunc_acquire_fp, struct task_struct *task, u64 clone_flags) {struct task_struct *acquired, *stack_task = (struct task_struct *)&clone_flags;
tools/testing/selftests/bpf/progs/verifier_vfs_reject.c +3 -3
@@ -28,7 +28,7 @@ int BPF_PROG(get_task_exe_file_kfunc_null) } SEC("lsm.s/inode_getxattr") -__failure __msg("R1 pointer type STRUCT task_struct must point to scalar, or struct with scalar") +__failure __msg("R1 is fp expected STRUCT task_struct") int BPF_PROG(get_task_exe_file_kfunc_fp) {u64 x;
@@ -98,7 +98,7 @@ int BPF_PROG(path_d_path_kfunc_null) } SEC("lsm.s/task_alloc") -__failure __msg("R1 must be referenced or trusted") +__failure __msg("dereference of modified untrusted_ptr_") int BPF_PROG(path_d_path_kfunc_untrusted_from_argument, struct task_struct *task) {struct path *root;
@@ -112,7 +112,7 @@ int BPF_PROG(path_d_path_kfunc_untrusted_from_argument, struct task_struct *task } SEC("lsm.s/file_open") -__failure __msg("R1 must be referenced or trusted") +__failure __msg("dereference of modified untrusted_ptr_") int BPF_PROG(path_d_path_kfunc_untrusted_from_current) {struct path *pwd;
tools/testing/selftests/bpf/verifier/calls.c +3 -3
@@ -31,7 +31,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "R1 pointer type STRUCT prog_test_fail1 must point to scalar", + .errstr = "R1 is fp expected STRUCT prog_test_fail1", .fixup_kfunc_btf_id = { { "bpf_kfunc_call_test_fail1", 2 }, },
@@ -46,7 +46,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "max struct nesting depth exceeded\nR1 pointer type STRUCT prog_test_fail2", + .errstr = "max struct nesting depth exceeded\nR1 is fp expected STRUCT prog_test_fail2", .fixup_kfunc_btf_id = { { "bpf_kfunc_call_test_fail2", 2 }, },
@@ -61,7 +61,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "R1 pointer type STRUCT prog_test_fail3 must point to scalar", + .errstr = "R1 is fp expected STRUCT prog_test_fail3", .fixup_kfunc_btf_id = { { "bpf_kfunc_call_test_fail3", 2 }, },
Signature · 1 line
2.52.0
[email protected]
AI reviewRe: [PATCH bpf-next v3 15/18] bpf: Classify kfunc pointer arguments from BTF, resolve type against the register
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Allowing PTR_TO_BTF_ID as a KF_ARG_PTR_TO_MEM argument is either broken or fundamentally unsafe…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Allowing PTR_TO_BTF_ID as a KF_ARG_PTR_TO_MEM argument is either broken or fundamentally unsafe due to unvalidated access flags. --
--- Patch [15]: [PATCH bpf-next v3 15/18] bpf: Classify kfunc pointer arguments from BTF, resolve type against the register --- commit d5adf1f80d7ac5827091492c5099bcb0c05e15d1
Author: Amery Hung <[email protected]>
bpf: Classify kfunc pointer arguments from BTF, resolve type against the register
This commit changes kfunc pointer argument classification to rely strictly on BTF rather than register state. It introduces support for passing a PTR_TO_BTF_ID as a fixed-size memory buffer when pointing to a scalar struct.
Quoted 6 lines
The new design now accepts one previously rejected case: passing
PTR_TO_BTF_IDto a pointer to scalar w/o a following __sz/__szk. The argument will be classified asKF_ARG_PTR_TO_MEM|MEM_FIXED_SIZE. ThePTR_TO_BTF_IDregister will go throughcheck_mem_reg()->check_helper_mem_access()->check_ptr_to_btf_access(), and by default only read is allowed.
[Severity: Medium]
Will this newly accepted case always fail verification?
While the commit message states that "by default only read is allowed," the call to check_mem_reg() for KF_ARG_PTR_TO_MEM arguments unconditionally demands BPF_READ | BPF_WRITE access. This causes check_ptr_to_btf_access() to reject standard kernel pointers with -EACCES.
Quoted 5 lines
kernel/bpf/verifier.c +0
-0@@ -11405,37 +11414,37 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,
[ ... ]
Quoted 17 lines
kernel/bpf/verifier.c +8
-8-/* This is the catch all argument type of register types supported by -* check_helper_mem_access. However, we only allow when argument type is -* pointer to scalar, or struct composed (recursively) of scalars. When -* arg_mem_size is true, the pointer can be void *. +/* A pointer to a struct without a size argument is classified as KF_ARG_PTR_TO_BTF_ID */ +if (btf_type_is_struct (ref_t)) +return KF_ARG_PTR_TO_BTF_ID ; + +/* +* Otherwise this is a fixed-size memory buffer supported by +* check_helper_mem_access(): a pointer to a scalar or a struct of +* scalars. The access size is derived from the pointed-to BTF type. */ -if (!btf_type_is_scalar (ref_t) && !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 ) && - (arg_mem_size ? !btf_type_is_void (ref_t) :1 )) { - verbose(env, "%s pointer type %s %s must point to %sscalar, or struct with scalar\n", - reg_arg_name(env, argno),
kernel/bpf/verifier.c get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, · line 11448
Quoted 10 lines
kernel/bpf/verifier.c +5
-2- btf_type_str(ref_t), ref_tname, arg_mem_size ? "void, " : ""); +if (!btf_type_is_scalar (ref_t) && + !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +verbose (env,"%s pointer type %s %s must point to scalar, or struct with scalar\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname);return -EINVAL ; } -return arg_mem_size ?KF_ARG_PTR_TO_MEM :KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; +return KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; }
[Severity: Medium]
When get_kfunc_ptr_arg_type() returns KF_ARG_PTR_TO_MEM | MEM_FIXED_SIZE for a PTR_TO_BTF_ID, or when check_kfunc_args() falls through to KF_ARG_PTR_TO_MEM, it verifies the argument as a memory buffer:
kernel/bpf/verifier.c:check_kfunc_args() {
...
case KF_ARG_PTR_TO_MEM:
if (kf_arg_type & MEM_FIXED_SIZE) {
resolve_ret = btf_resolve_size(btf, ref_t, &type_size);
...
ret = check_mem_reg(env, reg, argno, type_size, BPF_READ | BPF_WRITE, meta);
...
}Because check_mem_reg() is passed BPF_READ | BPF_WRITE, it requires write access. When this goes through check_helper_mem_access() and reaches check_ptr_to_btf_access(), it will be rejected because atype != BPF_READ:
kernel/bpf/verifier.c:check_ptr_to_btf_access() {
...
if (atype != BPF_READ && !type_is_ptr_alloc_obj(reg->type)) {
verbose(env, "only read is supported\n");
return -EACCES;
}
...
}Could this unconditionally break the newly introduced feature for standard (non-allocated) kernel pointers? Also, if the BPF_READ | BPF_WRITE flag were simply changed to BPF_READ to pass verification, could it introduce a vulnerability since the verifier cannot guarantee that the underlying kfunc will not write to the buffer?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15
Re: [PATCH bpf-next v3 15/18] bpf: Classify kfunc pointer arguments from BTF, resolve type against the register
Quoted 22 lines · On Sat, Aug 1, 2026 at 1:22 AM <[email protected]> wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] AllowingPTR_TO_BTF_IDas aKF_ARG_PTR_TO_MEMargument is either broken or fundamentally unsafe due to unvalidated access flags. ----- Patch [15]: [PATCH bpf-next v3 15/18] bpf: Classify kfunc pointer arguments from BTF, resolve type against the register --- commit
d5adf1f80d7ac5827091492c5099bcb0c05e15d1
Author: Amery Hung <[email protected]>bpf: Classify kfunc pointer arguments from BTF, resolve type against the register
This commit changes kfunc pointer argument classification to rely strictly on BTF rather than register state. It introduces support for passing a
PTR_TO_BTF_IDas a fixed-size memory buffer when pointing to a scalar struct.Quoted 6 lines
The new design now accepts one previously rejected case: passing
PTR_TO_BTF_IDto a pointer to scalar w/o a following __sz/__szk. The argument will be classified asKF_ARG_PTR_TO_MEM|MEM_FIXED_SIZE. ThePTR_TO_BTF_IDregister will go throughcheck_mem_reg()->check_helper_mem_access()->check_ptr_to_btf_access(), and by default only read is allowed.
Quoted 7 lines
[Severity: Medium]
Will this newly accepted case always fail verification?While the commit message states that "by default only read is allowed," the call to
check_mem_reg()forKF_ARG_PTR_TO_MEMarguments unconditionally demandsBPF_READ|BPF_WRITEaccess. This causescheck_ptr_to_btf_access()to reject standard kernel pointers with-EACCES.
I see the problem in my wording. So it should be:
For a pointer to scalar arg, a kernel btf id will be rejected unless explicitly granted by btf_struct_access(); a program allocated btf id will be allowed.
Quoted 71 lines
Quoted 6 lines
kernel/bpf/verifier.c +0
-0@@ -11405,37 +11414,37 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env,[ ... ]
Quoted 17 lines
kernel/bpf/verifier.c +8
-8-/* This is the catch all argument type of register types supported by -* check_helper_mem_access. However, we only allow when argument type is -* pointer to scalar, or struct composed (recursively) of scalars. When -* arg_mem_size is true, the pointer can be void *. +/* A pointer to a struct without a size argument is classified as KF_ARG_PTR_TO_BTF_ID */ +if (btf_type_is_struct (ref_t)) +return KF_ARG_PTR_TO_BTF_ID ; + +/* +* Otherwise this is a fixed-size memory buffer supported by +* check_helper_mem_access(): a pointer to a scalar or a struct of +* scalars. The access size is derived from the pointed-to BTF type. */ -if (!btf_type_is_scalar (ref_t) && !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 ) && - (arg_mem_size ? !btf_type_is_void (ref_t) :1 )) { - verbose(env, "%s pointer type %s %s must point to %sscalar, or struct with scalar\n", - reg_arg_name(env, argno),kernel/bpf/verifier.c get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, · line 11448
Quoted 10 lines
kernel/bpf/verifier.c +5
-2- btf_type_str(ref_t), ref_tname, arg_mem_size ? "void, " : ""); +if (!btf_type_is_scalar (ref_t) && + !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +verbose (env,"%s pointer type %s %s must point to scalar, or struct with scalar\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname);return -EINVAL ; } -return arg_mem_size ?KF_ARG_PTR_TO_MEM :KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; +return KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; }[Severity: Medium]
Whenget_kfunc_ptr_arg_type()returnsKF_ARG_PTR_TO_MEM|MEM_FIXED_SIZEfor aPTR_TO_BTF_ID, or whencheck_kfunc_args()falls through toKF_ARG_PTR_TO_MEM, it verifies the argument as a memory buffer:kernel/bpf/verifier.c:check_kfunc_args() { ... case KF_ARG_PTR_TO_MEM: if (kf_arg_type & MEM_FIXED_SIZE) { resolve_ret = btf_resolve_size(btf, ref_t, &type_size); ... ret = check_mem_reg(env, reg, argno, type_size, BPF_READ | BPF_WRITE, meta); ... }Because
check_mem_reg()is passedBPF_READ|BPF_WRITE, it requires write access. When this goes throughcheck_helper_mem_access()and reachescheck_ptr_to_btf_access(), it will be rejected because atype !=BPF_READ:kernel/bpf/verifier.c:check_ptr_to_btf_access() { ... if (atype != BPF_READ && !type_is_ptr_alloc_obj(reg->type)) { verbose(env, "only read is supported\n"); return -EACCES; } ... }Could this unconditionally break the newly introduced feature for standard (non-allocated) kernel pointers? Also, if the
BPF_READ|BPF_WRITEflag were simply changed toBPF_READto pass verification, could it introduce a vulnerability since the verifier cannot guarantee that the underlying kfunc will not write to the buffer?--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15
PATCH v3 16/18 bpf: Tag nullable kfunc pointer args with PTR_MAYBE_NULL
In reply to Amery HungNow that get_kfunc_ptr_arg_type() classifies a kfunc pointer argument from its BTF alone, express a nullable argument by OR-ing PTR_MAYBE_NULL into the classified type, and resolve a NULL register after classification instead of before it.
Previously check_kfunc_args() short-circuited a nullable argument passed a NULL register with a continue placed before get_kfunc_ptr_arg_type(), so the NULL never reached classification. That kept a register-state decision (bpf_register_is_null()) ahead of the BTF-based classification.
This mirrors how helper arguments carry PTR_MAYBE_NULL in their bpf_arg_type and is a step toward describing kfuncs with a bpf_func_proto:
the nullability now travels with the per-argument classification, so it is captured when the prototype is generated at add-call time.
--- kernel/bpf/verifier.c | 147 +++++++++++++++++++----------------------- 1 file changed, 67 insertions(+), 80 deletions(-)
kernel/bpf/verifier.c +67 -80
@@ -11353,98 +11353,85 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_call_arg_meta *m const char *ref_tname, const struct btf_param *args, int arg, int nargs, argno_t argno) { - if (meta->func_id == special_kfunc_list[KF_bpf_cast_to_kern_ctx] || - meta->func_id == special_kfunc_list[KF_bpf_session_is_return] || - meta->func_id == special_kfunc_list[KF_bpf_session_cookie]) - return KF_ARG_PTR_TO_CTX; + int arg_type;/* In this function, we verify the kfunc's BTF as per the argument type, * leaving the rest of the verification with respect to the register * type to our caller. When a set of conditions hold in the BTF type of * arguments, we resolve it to a known kfunc_ptr_arg_type. */ -if (btf_is_prog_ctx_type (&env->log, meta->btf, t,resolve_prog_type (env->prog), arg)) -return KF_ARG_PTR_TO_CTX ; - -if (is_kfunc_arg_alloc_obj (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_ALLOC_BTF_ID ; - -if (is_kfunc_arg_refcounted_kptr (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_REFCOUNTED_KPTR ; - -if (is_kfunc_arg_dynptr (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_DYNPTR ; - -if (is_kfunc_arg_iter (meta, arg, &args[arg])) -return KF_ARG_PTR_TO_ITER ; - -if (is_kfunc_arg_list_head (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_LIST_HEAD ; - -if (is_kfunc_arg_list_node (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_LIST_NODE ; - -if (is_kfunc_arg_rbtree_root (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_RB_ROOT ; - -if (is_kfunc_arg_rbtree_node (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_RB_NODE ; - -if (is_kfunc_arg_const_str (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_CONST_STR ; - -if (is_kfunc_arg_const_map (meta->btf, &args[arg])) -return KF_ARG_CONST_MAP_PTR ; - -if (is_kfunc_arg_map (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_BTF_ID ; - -if (is_kfunc_arg_wq (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_WORKQUEUE ; - -if (is_kfunc_arg_timer (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_TIMER ; - -if (is_kfunc_arg_task_work (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_TASK_WORK ; - -if (is_kfunc_arg_irq_flag (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_IRQ_FLAG ; - -if (is_kfunc_arg_res_spin_lock (meta->btf, &args[arg])) -return KF_ARG_PTR_TO_RES_SPIN_LOCK ; - -if (is_kfunc_arg_callback (env, meta->btf, &args[arg])) -return KF_ARG_PTR_TO_CALLBACK ; - -if (arg +1 < nargs && - (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || -is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) { +if (meta->func_id == special_kfunc_list[KF_bpf_cast_to_kern_ctx] || + meta->func_id == special_kfunc_list[KF_bpf_session_is_return] || + meta->func_id == special_kfunc_list[KF_bpf_session_cookie]) + arg_type =KF_ARG_PTR_TO_CTX ; +else if (btf_is_prog_ctx_type (&env->log, meta->btf, t,resolve_prog_type (env->prog), arg)) + arg_type =KF_ARG_PTR_TO_CTX ; +else if (is_kfunc_arg_alloc_obj (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_ALLOC_BTF_ID ; +else if (is_kfunc_arg_refcounted_kptr (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_REFCOUNTED_KPTR ; +else if (is_kfunc_arg_dynptr (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_DYNPTR ; +else if (is_kfunc_arg_iter (meta, arg, &args[arg])) + arg_type =KF_ARG_PTR_TO_ITER ; +else if (is_kfunc_arg_list_head (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_LIST_HEAD ; +else if (is_kfunc_arg_list_node (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_LIST_NODE ; +else if (is_kfunc_arg_rbtree_root (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_RB_ROOT ; +else if (is_kfunc_arg_rbtree_node (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_RB_NODE ; +else if (is_kfunc_arg_const_str (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_CONST_STR ; +else if (is_kfunc_arg_const_map (meta->btf, &args[arg])) + arg_type =KF_ARG_CONST_MAP_PTR ; +else if (is_kfunc_arg_map (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_BTF_ID ; +else if (is_kfunc_arg_wq (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_WORKQUEUE ; +else if (is_kfunc_arg_timer (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_TIMER ; +else if (is_kfunc_arg_task_work (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_TASK_WORK ; +else if (is_kfunc_arg_irq_flag (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_IRQ_FLAG ; +else if (is_kfunc_arg_res_spin_lock (meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_RES_SPIN_LOCK ; +else if (is_kfunc_arg_callback (env, meta->btf, &args[arg])) + arg_type =KF_ARG_PTR_TO_CALLBACK ; +else if (arg +1 < nargs && + (is_kfunc_arg_mem_size (meta->btf, &args[arg +1 ]) || +is_kfunc_arg_const_mem_size (meta->btf, &args[arg +1 ]))) {if (!btf_type_is_void (ref_t) && !btf_type_is_scalar (ref_t) && !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) {verbose (env,"%s pointer type %s %s must point to void, scalar, or struct with scalar\n" ,reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname);return -EINVAL ; } -return KF_ARG_PTR_TO_MEM ; + arg_type =KF_ARG_PTR_TO_MEM ; + }else if (btf_type_is_struct (ref_t)) +/* A pointer to a struct without a size argument is classified as KF_ARG_PTR_TO_BTF_ID */ + arg_type =KF_ARG_PTR_TO_BTF_ID ; +else { +/* +* Otherwise this is a fixed-size memory buffer supported by +* check_helper_mem_access(): a pointer to a scalar or a struct of +* scalars. The access size is derived from the pointed-to BTF type. +*/ +if (!btf_type_is_scalar (ref_t) && + !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { +verbose (env,"%s pointer type %s %s must point to scalar, or struct with scalar\n" , +reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname); +return -EINVAL ; + } + arg_type =KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; } -/* A pointer to a struct without a size argument is classified as KF_ARG_PTR_TO_BTF_ID */ -if (btf_type_is_struct (ref_t)) -return KF_ARG_PTR_TO_BTF_ID ; +if (is_kfunc_arg_nullable (meta->btf, &args[arg])) + arg_type |=PTR_MAYBE_NULL ; -/* -* Otherwise this is a fixed-size memory buffer supported by -* check_helper_mem_access(): a pointer to a scalar or a struct of -* scalars. The access size is derived from the pointed-to BTF type. -*/ -if (!btf_type_is_scalar (ref_t) && - !__btf_type_is_scalar_struct (env, meta->btf, ref_t,0 )) { -verbose (env,"%s pointer type %s %s must point to scalar, or struct with scalar\n" , -reg_arg_name (env, argno),btf_type_str (ref_t), ref_tname); -return -EINVAL ; - } -return KF_ARG_PTR_TO_MEM |MEM_FIXED_SIZE ; +return arg_type; } static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,
@@ -12132,14 +12119,14 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); ref_tname =btf_name_by_offset (btf, ref_t->name_off); -if (is_kfunc_arg_nullable (meta->btf, &args[i]) &&bpf_register_is_null (reg)) -continue ; - kf_arg_type =get_kfunc_ptr_arg_type (env, meta, t, ref_t, ref_tname, args, i, nargs, argno);if (kf_arg_type <0 )return kf_arg_type; +if (bpf_register_is_null (reg) &&type_may_be_null (kf_arg_type)) +continue ; +if (is_kfunc_arg_map (btf, &args[i])) { ref_id = *reg2btf_ids[CONST_PTR_TO_MAP ]; ref_t =btf_type_by_id (btf_vmlinux, ref_id);
Signature · 1 line
2.52.0
PATCH v3 17/18 bpf: Classify scalar kfunc arguments from BTF
In reply to Amery HungAdd kfunc scalar argument types, classify them in get_kfunc_arg_type() along side with pointer arguments and move scalar type verification into the main switch in check_kfunc_args(). This keeps BTF-based classification separate from register validation for every argument, paving the way for generating the kfunc argument prototype at add-call time. No functional change intended.
KF_ARG_MEM_SIZE and KF_ARG_CONST_MEM_SIZE now are reachable. Therefore, remove the fallthrough from KF_ARG_PTR_TO_MEM case and adjust the register indexing.
--- kernel/bpf/verifier.c | 141 +++++++++++------- .../testing/selftests/bpf/progs/dynptr_fail.c | 2 +- 2 files changed, 92 insertions(+), 51 deletions(-)
kernel/bpf/verifier.c +91 -50
@@ -11073,6 +11073,9 @@ static bool __btf_type_is_scalar_struct(struct bpf_verifier_env *env,enum kfunc_ptr_arg_type {KF_ARG_CONST_MEM_SIZE ,KF_ARG_MEM_SIZE , +KF_ARG_CONST , +KF_ARG_CONST_ALLOC_SIZE_OR_ZERO , +KF_ARG_ANYTHING ,KF_ARG_PTR_TO_CTX ,KF_ARG_PTR_TO_ALLOC_BTF_ID ,/* Allocated object */ KF_ARG_PTR_TO_REFCOUNTED_KPTR ,/* Refcounted local kptr */
@@ -11348,13 +11351,39 @@ bool bpf_is_kfunc_pkt_changing(struct bpf_call_arg_meta *meta) }static int -get_kfunc_ptr_arg_type (struct bpf_verifier_env *env,struct bpf_call_arg_meta *meta, -const struct btf_type *t,const struct btf_type *ref_t, -const char *ref_tname,const struct btf_param *args, -int arg,int nargs,argno_t argno) +get_kfunc_arg_type (struct bpf_verifier_env *env,struct bpf_call_arg_meta *meta, +const struct btf_param *args,int arg,int nargs) { +const struct btf_type *t, *ref_t =NULL ; +argno_t argno =argno_from_arg (arg +1 ); +const char *ref_tname =NULL ;int arg_type; + t =btf_type_skip_modifiers (meta->btf, args[arg].type,NULL ); + +/* Scalar arguments are classified from their BTF suffix/name alone. */ +if (btf_type_is_scalar (t)) { +if (is_kfunc_arg_constant (meta->btf, &args[arg])) +return KF_ARG_CONST ; +if (is_kfunc_arg_const_mem_size (meta->btf, &args[arg])) +return KF_ARG_CONST_MEM_SIZE ; +if (is_kfunc_arg_mem_size (meta->btf, &args[arg])) +return KF_ARG_MEM_SIZE ; +if (is_kfunc_arg_scalar_with_name (meta->btf, &args[arg],"rdonly_buf_size" ) || +is_kfunc_arg_scalar_with_name (meta->btf, &args[arg],"rdwr_buf_size" )) +return KF_ARG_CONST_ALLOC_SIZE_OR_ZERO ; +return KF_ARG_ANYTHING ; + } + +if (!btf_type_is_ptr (t)) { +verbose (env,"Unrecognized %s type %s\n" , +reg_arg_name (env, argno),btf_type_str (t)); +return -EINVAL ; + } + + ref_t =btf_type_skip_modifiers (meta->btf, t->type,NULL ); + ref_tname =btf_name_by_offset (meta->btf, ref_t->name_off); +/* In this function, we verify the kfunc's BTF as per the argument type, * leaving the rest of the verification with respect to the register * type to our caller. When a set of conditions hold in the BTF type of
@@ -12043,7 +12072,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meint 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;if (is_kfunc_arg_prog_aux (btf, &args[i])) {
@@ -12067,39 +12095,7 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me t =btf_type_skip_modifiers (btf, args[i].type,NULL ); -if (btf_type_is_scalar (t)) { -if (reg->type !=SCALAR_VALUE ) { -verbose (env,"%s is not a scalar\n" ,reg_arg_name (env, argno)); -return -EINVAL ; - } - -if (is_kfunc_arg_constant (meta->btf, &args[i]) || -is_kfunc_arg_const_mem_size (meta->btf, &args[i])) { - ret =process_const_arg (env, reg, argno, meta); -if (ret <0 ) -return ret; - }else if (is_kfunc_arg_scalar_with_name (btf, &args[i],"rdonly_buf_size" )) { - meta->r0_rdonly = true; - is_ret_buf_sz = true; - }else if (is_kfunc_arg_scalar_with_name (btf, &args[i],"rdwr_buf_size" )) { - is_ret_buf_sz = true; - } - -if (is_ret_buf_sz) { - ret =process_const_alloc_mem_size (env, reg, argno, &meta->ret_mem); -if (ret <0 ) -return ret; - } -continue ; - } - -if (!btf_type_is_ptr (t)) { -verbose (env,"Unrecognized %s type %s\n" , -reg_arg_name (env, argno),btf_type_str (t)); -return -EINVAL ; - } - -if ((bpf_register_is_null (reg) ||type_may_be_null (reg->type)) && +if (btf_type_is_ptr (t) && (bpf_register_is_null (reg) ||type_may_be_null (reg->type)) && !is_kfunc_arg_nullable (meta->btf, &args[i])) {verbose (env,"Possibly NULL pointer passed to trusted %s\n" ,reg_arg_name (env, argno));
@@ -12116,11 +12112,12 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_meif (reg_is_referenced (env, reg))update_ref_obj (&meta->ref_obj, reg); - ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); - ref_tname =btf_name_by_offset (btf, ref_t->name_off); +if (btf_type_is_ptr (t)) { + ref_t =btf_type_skip_modifiers (btf, t->type, &ref_id); + ref_tname =btf_name_by_offset (btf, ref_t->name_off); + } - kf_arg_type =get_kfunc_ptr_arg_type (env, meta, t, ref_t, ref_tname, - args, i, nargs, argno); + kf_arg_type =get_kfunc_arg_type (env, meta, args, i, nargs);if (kf_arg_type <0 )return kf_arg_type;
@@ -12134,6 +12131,11 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me }switch (base_type (kf_arg_type)) { +case KF_ARG_CONST : +case KF_ARG_CONST_MEM_SIZE : +case KF_ARG_MEM_SIZE : +case KF_ARG_ANYTHING : +case KF_ARG_CONST_ALLOC_SIZE_OR_ZERO :case KF_ARG_PTR_TO_ALLOC_BTF_ID :case KF_ARG_PTR_TO_BTF_ID :case KF_ARG_CONST_MAP_PTR :
@@ -12174,6 +12176,34 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_mereturn ret;switch (base_type (kf_arg_type)) { +case KF_ARG_CONST : +if (reg->type !=SCALAR_VALUE ) { +verbose (env,"%s is not a scalar\n" ,reg_arg_name (env, argno)); +return -EINVAL ; + } + + ret =process_const_arg (env, reg, argno, meta); +if (ret <0 ) +return ret; +break ; +case KF_ARG_ANYTHING : +if (reg->type !=SCALAR_VALUE ) { +verbose (env,"%s is not a scalar\n" ,reg_arg_name (env, argno)); +return -EINVAL ; + } +break ; +case KF_ARG_CONST_ALLOC_SIZE_OR_ZERO : +if (reg->type !=SCALAR_VALUE ) { +verbose (env,"%s is not a scalar\n" ,reg_arg_name (env, argno)); +return -EINVAL ; + } + +if (is_kfunc_arg_scalar_with_name (btf, &args[i],"rdonly_buf_size" )) + meta->r0_rdonly = true; + ret =process_const_alloc_mem_size (env, reg, argno, &meta->ret_mem); +if (ret <0 ) +return ret; +break ;case KF_ARG_PTR_TO_CTX :if (reg->type !=PTR_TO_CTX ) { verbose(env, "%s expected pointer to ctx, but got %s\n",
@@ -12407,22 +12437,33 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_call_arg_me ret =check_mem_reg (env, reg, argno, type_size,BPF_READ |BPF_WRITE , meta);if (ret <0 )return ret; -break ; } - fallthrough; +break ;case KF_ARG_CONST_MEM_SIZE : + ret =process_const_arg (env, reg, argno, meta); +if (ret <0 ) +return ret; + fallthrough;case KF_ARG_MEM_SIZE : { -struct bpf_reg_state *buff_reg = reg; -struct bpf_reg_state *size_reg =get_func_arg_reg (caller, regs, i +1 ); -argno_t next_argno =argno_from_arg (i +2 ); +struct bpf_reg_state *buff_reg =get_func_arg_reg (caller, regs, i -1 ); +struct bpf_reg_state *size_reg = reg; +argno_t buff_argno =argno_from_arg (i); - ret =check_mem_size_reg (env, buff_reg, size_reg, argno, next_argno, +if (reg->type !=SCALAR_VALUE ) { +verbose (env,"%s is not a scalar\n" ,reg_arg_name (env, argno)); +return -EINVAL ; + } + +if (bpf_register_is_null (buff_reg)) +break ; + + ret =check_mem_size_reg (env, buff_reg, size_reg, buff_argno, argno,BPF_READ |BPF_WRITE , true, meta);if (ret <0 ) { -verbose (env,"%s and " ,reg_arg_name (env, argno)); +verbose (env,"%s and " ,reg_arg_name (env, buff_argno));verbose (env,"%s memory, len pair leads to invalid memory access\n" , -reg_arg_name (env, next_argno)); +reg_arg_name (env, argno));return ret; }break ;
tools/testing/selftests/bpf/progs/dynptr_fail.c +1 -1
@@ -1589,7 +1589,7 @@ int xdp_invalid_ctx(void *ctx)__u32 hdr_size =sizeof (struct ethhdr );/* Can't pass in variable-sized len to bpf_dynptr_slice */ SEC("?tc") -__failure __msg("unbounded memory access") +__failure __msg("must be a known constant") int dynptr_slice_var_len1(struct __sk_buff *skb) {struct bpf_dynptr ptr;
Signature · 1 line
2.52.0
PATCH v3 18/18 bpf: Generate kfunc argument prototype at add-call time
In reply to Amery HungKfunc argument checking re-derives each argument's kfunc_ptr_arg_type from BTF on every verification of a call in check_kfunc_args(). Now that get_kfunc_arg_type() is a function of the kfunc's BTF alone, it no longer inspects register state. The classification can be computed once when the call is added and cached. This is a step toward describing kfuncs with a bpf_func_proto and sharing the helper argument-checking path.
Generate the classification at bpf_add_kfunc_call() time:
- Extend struct bpf_func_proto to be able to describe a kfunc: widen arg_type[] and the arg_btf_id[]/arg_size[] union from 5 to MAX_BPF_FUNC_ARGS, since a kfunc may take up to 12 arguments (5 in registers, 7 on the stack).
- Embed a bpf_func_proto in struct bpf_kfunc_desc, populated by gen_kfunc_arg_proto() which runs get_kfunc_arg_type() for each argument and stores the result in proto.arg_type[]. Grow the descriptor table's descs[] as a flexible array to not waste memory.
- check_kfunc_args() reads the cached classification from meta->fn
The KF_ARG_PTR_TO_CTX classification depends on the resolved program type, and for BPF_PROG_TYPE_EXT that is the target program's type, which resolve_prog_type() reads from prog->aux->saved_dst_prog_type. That field is normally recorded later during verification in check_attach_btf_id(), after bpf_add_kfunc_call() has run.
Record saved_dst_prog_type and saved_dst_attach_type from dst_prog at program load time in bpf_prog_load() so the resolved type is available at add-call time without reordering check_attach_btf_id(). This keeps e.g. an freplace of an XDP program calling bpf_xdp_metadata_rx_hash() classifying its struct xdp_md * argument as context.
The classification result is unchanged; it is only computed earlier and cached.
--- include/linux/bpf.h | 36 ++++++------- include/linux/bpf_verifier.h | 9 ++-- kernel/bpf/syscall.c | 4 ++ kernel/bpf/verifier.c | 98 +++++++++++++++++++++++++++++------- 4 files changed, 109 insertions(+), 38 deletions(-)
include/linux/bpf.h +18 -18
@@ -960,6 +960,21 @@ enum bpf_return_type { };static_assert (__BPF_RET_TYPE_MAX <=BPF_BASE_TYPE_LIMIT ); +/* The longest tracepoint has 12 args. +* See include/trace/bpf_probe.h +* +* Also reuse this macro for maximum number of arguments a BPF function +* or a kfunc can have. Args 1-5 are passed in registers, args 6-12 via +* stack arg slots. The JIT may map some stack arg slots to registers based +* on the native calling convention (e.g., arg 6 to R9 on x86-64). +*/ +#define MAX_BPF_FUNC_ARGS 12 + +/* The maximum number of arguments passed through registers +* a single function may have. +*/ +#define MAX_BPF_FUNC_REG_ARGS 5 +/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs * to in-kernel helper functions and for adjusting imm32 field in BPF_CALL * instructions after verifying
@@ -984,7 +999,7 @@ struct bpf_func_proto {enum bpf_arg_type arg4_type;enum bpf_arg_type arg5_type; }; -enum bpf_arg_type arg_type[5 ]; +enum bpf_arg_type arg_type[MAX_BPF_FUNC_ARGS ]; }; union { struct {
@@ -994,7 +1009,7 @@ struct bpf_func_proto {u32 *arg4_btf_id;u32 *arg5_btf_id; }; -u32 *arg_btf_id[5 ]; +u32 *arg_btf_id[MAX_BPF_FUNC_ARGS ];struct {size_t arg1_size;size_t arg2_size;
@@ -1002,7 +1017,7 @@ struct bpf_func_proto {size_t arg4_size;size_t arg5_size; }; -size_t arg_size[5 ]; +size_t arg_size[MAX_BPF_FUNC_ARGS ]; };int *ret_btf_id;/* return value btf_id */ bool (*allowed)(const struct bpf_prog *prog);
@@ -1192,21 +1207,6 @@ struct bpf_prog_offload {u32 jited_len; }; -/* The longest tracepoint has 12 args. -* See include/trace/bpf_probe.h -* -* Also reuse this macro for maximum number of arguments a BPF function -* or a kfunc can have. Args 1-5 are passed in registers, args 6-12 via -* stack arg slots. The JIT may map some stack arg slots to registers based -* on the native calling convention (e.g., arg 6 to R9 on x86-64). -*/ -#define MAX_BPF_FUNC_ARGS 12 - -/* The maximum number of arguments passed through registers -* a single function may have. -*/ -#define MAX_BPF_FUNC_REG_ARGS 5 -/* The argument is a structure or a union. */ #define BTF_FMODEL_STRUCT_ARG BIT(0)
include/linux/bpf_verifier.h +6 -3
@@ -1302,7 +1302,6 @@ static inline u32 type_flag(u32 type)return type & ~BPF_BASE_TYPE_MASK ; } -/* only use after check_attach_btf_id() */ static inline enum bpf_prog_type resolve_prog_type (const struct bpf_prog *prog) { return (prog->type == BPF_PROG_TYPE_EXT && prog->aux->saved_dst_prog_type) ?
@@ -1489,6 +1488,7 @@ struct bpf_call_arg_meta {/* Common */ struct btf *btf;u32 func_id; +const struct bpf_func_proto *fn;u8 release_regno;u32 ret_btf_id;u32 subprogno;
@@ -1617,6 +1617,7 @@ enum bpf_reg_arg_type {struct bpf_kfunc_desc {struct btf_func_model func_model; +struct bpf_func_proto proto;u32 func_id;s32 imm;u16 offset;
@@ -1624,13 +1625,15 @@ struct bpf_kfunc_desc { };struct bpf_kfunc_desc_tab { +u32 nr_descs;/* Sorted by func_id (BTF ID) and offset (fd_array offset) during * verification. JITs do lookups by bpf_insn, where func_id may not be * available, therefore at the end of verification do_misc_fixups() * sorts this by imm and offset. +* +* Grown one entry at a time by bpf_add_kfunc_call(). */ -struct bpf_kfunc_desc descs[MAX_KFUNC_DESCS ]; -u32 nr_descs; +struct bpf_kfunc_desc descs[]; };/* Functions exported from verifier.c, used by fixups.c */
kernel/bpf/syscall.c +4 -0
@@ -3043,6 +3043,10 @@ static int bpf_prog_load(union bpf_attr *attr, bpfptr_t uattr, struct bpf_log_at prog->aux->attach_btf = attach_btf; prog->aux->attach_btf_id = multi_func ? bpf_multi_func_btf_id[0 ] : attr->attach_btf_id; prog->aux->dst_prog = dst_prog; +if (dst_prog) { + prog->aux->saved_dst_prog_type = dst_prog->type; + prog->aux->saved_dst_attach_type = dst_prog->expected_attach_type; + } prog->aux->dev_bound = !!attr->prog_ifindex; prog->aux->xdp_has_frags = attr->prog_flags &BPF_F_XDP_HAS_FRAGS ;
kernel/bpf/verifier.c +81 -17
192 lines not on this page · raw message
Signature · 1 line
2.52.0
Quoted 9 lines · Amery Hung
Hi,
This is the second of three patch sets to unify kfunc and helper argument verification. It:
1) further aligns the kfunc and helper argument checks,
2) makes kfunc argument type classification depend solely on BTF, and
3) generates abpf_func_protofor each kfunc.
Quoted 9 lines
With classification now a pure function of the kfunc's BTF, it is computed once at add-call time and cached in the generated
bpf_func_proto, rather than re-derived on every verification of the call. Along the way it also fixes a few issues.The next patch set will align the argument register compatibility checks and route helper and kfunc argument verification through a single shared function.
I adjusted the commit log for patch 15 per your correction. If there are any other changes, let's do them as follow ups or in the 3rd tranche of changes.
Applied, thanks.
Quoted 1 line
[...]
This series was applied to bpf/bpf-next.git (master) by Kumar Kartikeya Dwivedi <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Kumar Kartikeya Dwivedi <[email protected]>:
Quoted 10 lines · On Sat, 1 Aug 2026 00:46:15 -0700 you wrote:
Hi,
This is the second of three patch sets to unify kfunc and helper argument verification. It:
1) further aligns the kfunc and helper argument checks,
2) makes kfunc argument type classification depend solely on BTF, and
3) generates abpf_func_protofor each kfunc.[...]
Here is the summary with links:
- [bpf-next,v3,01/18] bpf: Drop process_timer_func wrappers
https://git.kernel.org/bpf/bpf-next/c/70a841617aa8 - [bpf-next,v3,02/18] bpf: Unify const map ptr argument checking for helpers and kfuncs https://git.kernel.org/bpf/bpf-next/c/b33d09b4d914 - [bpf-next,v3,03/18] bpf: Split kfunc map argument into __const_map and __map https://git.kernel.org/bpf/bpf-next/c/c82b998777b7 - [bpf-next,v3,04/18] bpf: Pass kfunc meta to mem and mem_size check https://git.kernel.org/bpf/bpf-next/c/9f52714dd89b - [bpf-next,v3,05/18] bpf: Resolve map lookup result type at lookup time https://git.kernel.org/bpf/bpf-next/c/341d227fa5db - [bpf-next,v3,06/18] bpf: Check helper and kfunc mem+size arguments identically https://git.kernel.org/bpf/bpf-next/c/d4e7fb59c0d4 - [bpf-next,v3,07/18] selftests/bpf: Test map lookup result refinement https://git.kernel.org/bpf/bpf-next/c/e6d200dd1026 - [bpf-next,v3,08/18] bpf: Check fixed-size mem args of helpers and kfuncs the same way https://git.kernel.org/bpf/bpf-next/c/e566701b9b0c - [bpf-next,v3,09/18] bpf: Rename ARG_CONST_SIZE{,_OR_ZERO} to ARG_MEM_SIZE{,_OR_ZERO} https://git.kernel.org/bpf/bpf-next/c/c0e091f30f0d - [bpf-next,v3,10/18] bpf: Fold __szk const size handling into the scalar arg path https://git.kernel.org/bpf/bpf-next/c/f16e80c2c451 - [bpf-next,v3,11/18] selftests/bpf: Test __szk precision with a NULL nullable buffer https://git.kernel.org/bpf/bpf-next/c/f88caee62e45 - [bpf-next,v3,12/18] bpf: Classify kfunc mem_size args from BTF without register state https://git.kernel.org/bpf/bpf-next/c/ea5ab2389801 - [bpf-next,v3,13/18] bpf: Handle NULL kfunc pointer args without a KF_ARG_PTR_TO_NULL type https://git.kernel.org/bpf/bpf-next/c/76fb08750481 - [bpf-next,v3,14/18] bpf: Distinguish fixed- and variable-size kfunc mem args with MEM_FIXED_SIZE https://git.kernel.org/bpf/bpf-next/c/90990ee10be8 - [bpf-next,v3,15/18] bpf: Classify kfunc pointer arguments from BTF, resolve type against the register https://git.kernel.org/bpf/bpf-next/c/c9e995ba0d11 - [bpf-next,v3,16/18] bpf: Tag nullable kfunc pointer args with PTR_MAYBE_NULL https://git.kernel.org/bpf/bpf-next/c/ba5b99470c40 - [bpf-next,v3,17/18] bpf: Classify scalar kfunc arguments from BTF https://git.kernel.org/bpf/bpf-next/c/1690dcf27c73 - [bpf-next,v3,18/18] bpf: Generate kfunc argument prototype at add-call time https://git.kernel.org/bpf/bpf-next/c/a49b70400b9d
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html