Support storing struct task_struct objects as kptrs
Subsystems (9)
v9 cover Support storing struct task_struct objects as kptrs
Now that BPF supports adding new kernel functions with kfuncs, and storing kernel objects in maps with kptrs, we can add a set of kfuncs which allow struct task_struct objects to be stored in maps as referenced kptrs.
The possible use cases for doing this are plentiful. During tracing, for example, it would be useful to be able to collect some tasks that performed a certain operation, and then periodically summarize who they are, which cgroup they're in, how much CPU time they've utilized, etc. Doing this now would require storing the tasks' pids along with some relevant data to be exported to user space, and later associating the pids to tasks in other event handlers where the data is recorded. Another useful by-product of this is that it allows a program to pin a task in a BPF program, and by proxy therefore also e.g. pin its task local storage.
In order to support this, we'll need to expand KF_TRUSTED_ARGS to support receiving trusted, non-refcounted pointers. It currently only supports either PTR_TO_CTX pointers, or refcounted pointers. What this means in terms of the implementation is that check_kfunc_args() would have to also check for the PTR_TRUSTED or MEM_ALLOC type modifiers when determining if a trusted KF_ARG_PTR_TO_ALLOC_BTF_ID or KF_ARG_PTR_TO_BTF_ID pointer requires a refcount.
Note that PTR_UNTRUSTED is insufficient for this purpose, as it does not cover all of the possible types of potentially unsafe pointers. For example, a pointer obtained from walking a struct is not PTR_UNTRUSTED. To account for this and enable us to expand KF_TRUSTED_ARGS to include allow-listed arguments such as those passed by the kernel to tracepoints and struct_ops callbacks, this patch set also introduces a new PTR_TRUSTED type flag modifier which records if a pointer was obtained passed from the kernel in a trusted context.
Currently, both PTR_TRUSTED and MEM_ALLOC are used to imply that a pointer is trusted. Longer term, PTR_TRUSTED should be the sole source of truth for whether a pointer is trusted. This requires us to set PTR_TRUSTED when appropriate (e.g. when setting MEM_ALLOC), and unset it when appropriate (e.g. when setting PTR_UNTRUSTED). We don't do that in this patch, as we need to do more clean up before this can be done in a clear and well-defined manner.
In closing, this patch set:
1. Adds the new PTR_TRUSTED register type modifier flag, and updates the verifier and existing selftests accordingly. Also expands KF_TRUSTED_ARGS to also include trusted pointers that were not obtained from walking structs.
2. Adds a new set of kfuncs that allows struct task_struct* objects to be used as kptrs.
3. Adds a new selftest suite to validate these new task kfuncs.
--
Changelog:
v8 -> v9:
- Moved check for release register back to where we check for !PTR_TO_BTF_ID || socket. Change the verifier log message to reflect really what's being tested (the presence of unsafe modifiers) (Alexei)
- Fix verifier_test error tests to reflect above changes
- Remove unneeded parens around bitwise operator checks (Alexei)
- Move updates to reg_type_str() which allow multiple type modifiers to be present in the prefix string, to a separate patch (Alexei)
- Increase TYPE_STR_BUF_LEN size to 128 to reflect larger prefix size in reg_type_str().
v7 -> v8:
- Rebased onto Kumar's latest patch set which, adds a new MEM_ALLOC reg type modifier for bpf_obj_new() calls.
- Added comments to bpf_task_kptr_get() describing some of the subtle races we're protecting against (Alexei and John)
- Slightly rework process_kf_arg_ptr_to_btf_id(), and add a new reg_has_unsafe_modifiers() function which validates that a register containing a kfunc release arg doesn't have unsafe modifiers. Note that this is slightly different than the check for KF_TRUSTED_ARGS. An alternative here would be to treat KF_RELEASE as implicitly requiring KF_TRUSTED_ARGS.
- Export inline bpf_type_has_unsafe_modifiers() function from bpf_verifier.h so that it can be used from bpf_tcp_ca.c. Eventually this function should likely be changed to bpf_type_is_trusted(), once PTR_TRUSTED is the real source of truth.
v6 -> v7:
- Removed the PTR_WALKED type modifier, and instead define a new PTR_TRUSTED type modifier which is set on registers containing pointers passed from trusted contexts (i.e. as tracepoint or struct_ops callback args) (Alexei)
- Remove the new KF_OWNED_ARGS kfunc flag. This can be accomplished by defining a new type that wraps an existing type, such as with struct nf_conn___init (Alexei)
- Add a test_task_current_acquire_release testcase which verifies we can acquire a task struct returned from bpf_get_current_task_btf().
- Make bpf_task_acquire() no longer return NULL, as it can no longer be called with a NULL task.
- Removed unnecessary is_test_kfunc_task() checks from failure testcases.
v5 -> v6:
- Add a new KF_OWNED_ARGS kfunc flag which may be used by kfuncs to express that they require trusted, refcounted args (Kumar)
- Rename PTR_NESTED -> PTR_WALKED in the verifier (Kumar)
- Convert reg_type_str() prefixes to use snprintf() instead of strncpy() (Kumar)
- Add PTR_TO_BTF_ID | PTR_WALKED to missing struct btf_reg_type instances -- specifically btf_id_sock_common_types, and percpu_btf_ptr_types.
- Add a missing PTR_TO_BTF_ID | PTR_WALKED switch case entry in check_func_arg_reg_off(), which is required when validating helper calls (Kumar)
- Update reg_type_mismatch_ok() to check base types for the registers (i.e. to accommodate type modifiers). Additionally, add a lengthy comment that explains why this is being done (Kumar)
- Update convert_ctx_accesses() to also issue probe reads for PTR_TO_BTF_ID | PTR_WALKED (Kumar)
- Update selftests to expect new prefix reg type strings.
- Rename task_kfunc_acquire_trusted_nested testcase to task_kfunc_acquire_trusted_walked, and fix a comment (Kumar)
- Remove KF_TRUSTED_ARGS from bpf_task_release(), which already includes KF_RELEASE (Kumar)
- Add bpf-next in patch subject lines (Kumar)
v4 -> v5:
- Fix an improperly formatted patch title.
v3 -> v4:
- Remove an unnecessary check from my repository that I forgot to remove after debugging something.
v2 -> v3:
- Make bpf_task_acquire() check for NULL, and include KF_RET_NULL (Martin)
- Include new PTR_NESTED register modifier type flag which specifies whether a pointer was obtained from walking a struct. Use this to expand the meaning of KF_TRUSTED_ARGS to include trusted pointers that were passed from the kernel (Kumar)
- Add more selftests to the task_kfunc selftest suite which verify that you cannot pass a walked pointer to bpf_task_acquire().
- Update bpf_task_acquire() to also specify KF_TRUSTED_ARGS.
v1 -> v2:
- Rename tracing_btf_ids to generic_kfunc_btf_ids, and add the new kfuncs to that list instead of making a separate btf id list (Alexei).
- Don't run the new selftest suite on s390x, which doesn't appear to support invoking kfuncs.
- Add a missing __diag_ignore block for -Wmissing-prototypes ([email protected]).
- Fix formatting on some of the SPDX-License-Identifier tags.
- Clarified the function header comment a bit on bpf_task_kptr_get().
David Vernet (4):
bpf: Allow multiple modifiers in reg_type_str() prefix
bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
bpf: Add kfuncs for storing struct task_struct * as a kptr bpf/selftests: Add selftests for new task kfuncs
Documentation/bpf/kfuncs.rst | 30 +- include/linux/bpf.h | 30 ++ include/linux/bpf_verifier.h | 9 +- include/linux/btf.h | 65 +++-- kernel/bpf/btf.c | 8 + kernel/bpf/helpers.c | 78 +++++- kernel/bpf/verifier.c | 84 ++++-- kernel/trace/bpf_trace.c | 2 +- net/ipv4/bpf_tcp_ca.c | 4 +- tools/testing/selftests/bpf/DENYLIST.s390x | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 159 +++++++++++ .../selftests/bpf/progs/task_kfunc_common.h | 71 +++++ .../selftests/bpf/progs/task_kfunc_failure.c | 260 ++++++++++++++++++ .../selftests/bpf/progs/task_kfunc_success.c | 149 ++++++++++ tools/testing/selftests/bpf/verifier/calls.c | 2 +- .../selftests/bpf/verifier/ref_tracking.c | 4 +- 16 files changed, 886 insertions(+), 70 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/task_kfunc.c create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_common.h create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_failure.c create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_success.c
Signature · 1 line
2.38.1
PATCH v9 1/4 bpf: Allow multiple modifiers in reg_type_str() prefix
reg_type_str() in the verifier currently only allows a single register type modifier to be present in the 'prefix' string which is eventually stored in the env type_str_buf. This currently works fine because there are no overlapping type modifiers, but once PTR_TRUSTED is added, that will no longer be the case. This patch updates reg_type_str() to support having multiple modifiers in the prefix string, and updates the size of type_str_buf to be 128 bytes.
--- include/linux/bpf_verifier.h | 2 +- kernel/bpf/verifier.c | 19 ++++++++----------- 2 files changed, 9 insertions(+), 12 deletions(-)
include/linux/bpf_verifier.h +1 -1
@@ -19,7 +19,7 @@*/ #define BPF_MAX_VAR_SIZ (1 << 29)/* size of type_str_buf in bpf_verifier. */ -#define TYPE_STR_BUF_LEN 64 +#define TYPE_STR_BUF_LEN 128/* Liveness marks, used for registers and spilled-regs (in stack slots). * Read marks propagate upwards until they find a write mark; they record that
kernel/bpf/verifier.c +8 -11
@@ -557,7 +557,7 @@ static bool is_cmpxchg_insn(const struct bpf_insn *insn)static const char *reg_type_str (struct bpf_verifier_env *env,enum bpf_reg_type type) { -char postfix[16 ] = {0 }, prefix[32 ] = {0 }; +char postfix[16 ] = {0 }, prefix[64 ] = {0 };static const char *const str[] = { [NOT_INIT ] ="?" , [SCALAR_VALUE ] ="scalar" ,
@@ -589,16 +589,13 @@ static const char *reg_type_str(struct bpf_verifier_env *env,strncpy (postfix,"_or_null" ,16 ); } -if (type &MEM_RDONLY ) -strncpy (prefix,"rdonly_" ,32 ); -if (type &MEM_RINGBUF ) -strncpy (prefix,"ringbuf_" ,32 ); -if (type &MEM_USER ) -strncpy (prefix,"user_" ,32 ); -if (type &MEM_PERCPU ) -strncpy (prefix,"percpu_" ,32 ); -if (type &PTR_UNTRUSTED ) -strncpy (prefix,"untrusted_" ,32 ); +snprintf (prefix,sizeof (prefix),"%s%s%s%s%s" , + type &MEM_RDONLY ?"rdonly_" :"" , + type &MEM_RINGBUF ?"ringbuf_" :"" , + type &MEM_USER ?"user_" :"" , + type &MEM_PERCPU ?"percpu_" :"" , + type &PTR_UNTRUSTED ?"untrusted_" :"" + );snprintf (env->type_str_buf,TYPE_STR_BUF_LEN ,"%s%s%s" , prefix, str[base_type (type)], postfix);
Signature · 1 line
2.38.1
PATCH v9 3/4 bpf: Add kfuncs for storing struct task_struct * as a kptr
In reply to David VernetNow that BPF supports adding new kernel functions with kfuncs, and storing kernel objects in maps with kptrs, we can add a set of kfuncs which allow struct task_struct objects to be stored in maps as referenced kptrs. The possible use cases for doing this are plentiful. During tracing, for example, it would be useful to be able to collect some tasks that performed a certain operation, and then periodically summarize who they are, which cgroup they're in, how much CPU time they've utilized, etc.
In order to enable this, this patch adds three new kfuncs:
struct task_struct *bpf_task_acquire(struct task_struct *p); struct task_struct *bpf_task_kptr_get(struct task_struct **pp); void bpf_task_release(struct task_struct *p);
A follow-on patch will add selftests validating these kfuncs.
--- kernel/bpf/helpers.c | 78 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 3 deletions(-)
kernel/bpf/helpers.c +75 -3
@@ -1824,6 +1824,63 @@ struct bpf_list_node *bpf_list_pop_back(struct bpf_list_head *head)return __bpf_list_del (head, true); } +/** +* bpf_task_acquire - Acquire a reference to a task. A task acquired by this +* kfunc which is not stored in a map as a kptr, must be released by calling +* bpf_task_release(). +* @p: The task on which a reference is being acquired. +*/ +struct task_struct *bpf_task_acquire (struct task_struct *p) +{ +refcount_inc (&p->rcu_users); +return p; +} + +/** +* bpf_task_kptr_get - Acquire a reference on a struct task_struct kptr. A task +* kptr acquired by this kfunc which is not subsequently stored in a map, must +* be released by calling bpf_task_release(). +* @pp: A pointer to a task kptr on which a reference is being acquired. +*/ +struct task_struct *bpf_task_kptr_get (struct task_struct **pp) +{ +struct task_struct *p; + +rcu_read_lock (); + p =READ_ONCE (*pp); + +/* Another context could remove the task from the map and release it at +* any time, including after we've done the lookup above. This is safe +* because we're in an RCU read region, so the task is guaranteed to +* remain valid until at least the rcu_read_unlock() below. +*/ +if (p && !refcount_inc_not_zero (&p->rcu_users)) +/* If the task had been removed from the map and freed as +* described above, refcount_inc_not_zero() will return false. +* The task will be freed at some point after the current RCU +* gp has ended, so just return NULL to the user. +*/ + p =NULL ; +rcu_read_unlock (); + +return p; +} + +/** +* bpf_task_release - Release the reference acquired on a struct task_struct *. +* If this kfunc is invoked in an RCU read region, the task_struct is +* guaranteed to not be freed until the current grace period has ended, even if +* its refcount drops to 0. +* @p: The task on which a reference is being released. +*/ +void bpf_task_release (struct task_struct *p) +{ +if (!p) +return ; + +put_task_struct_rcu_user (p); +} +__diag_pop ();BTF_SET8_START (generic_btf_ids)
@@ -1836,6 +1893,9 @@ BTF_ID_FLAGS(func, bpf_list_push_front) BTF_ID_FLAGS(func, bpf_list_push_back) BTF_ID_FLAGS(func, bpf_list_pop_front, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_list_pop_back, KF_ACQUIRE | KF_RET_NULL) +BTF_ID_FLAGS(func, bpf_task_acquire, KF_ACQUIRE | KF_TRUSTED_ARGS) +BTF_ID_FLAGS(func, bpf_task_kptr_get, KF_ACQUIRE | KF_KPTR_GET | KF_RET_NULL) +BTF_ID_FLAGS(func, bpf_task_release, KF_RELEASE)BTF_SET8_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = {
@@ -1843,14 +1903,26 @@ static const struct btf_kfunc_id_set generic_kfunc_set = { .set = &generic_btf_ids, }; +BTF_ID_LIST (generic_dtor_ids) +BTF_ID(struct, task_struct) +BTF_ID (func, bpf_task_release) + static int__init kfunc_init (void) {int ret; +const struct btf_id_dtor_kfunc generic_dtors[] = { + { + .btf_id = generic_dtor_ids[0 ], + .kfunc_btf_id = generic_dtor_ids[1 ] + }, + }; ret =register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &generic_kfunc_set); -if (ret) -return ret; -return register_btf_kfunc_id_set (BPF_PROG_TYPE_SCHED_CLS , &generic_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SCHED_CLS , &generic_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &generic_kfunc_set); +return ret ?:register_btf_id_dtor_kfuncs (generic_dtors, +ARRAY_SIZE (generic_dtors), +THIS_MODULE ); }late_initcall (kfunc_init);
Signature · 1 line
2.38.1
PATCH v9 2/4 bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
In reply to David VernetKfuncs currently support specifying the KF_TRUSTED_ARGS flag to signal to the verifier that it should enforce that a BPF program passes it a "safe", trusted pointer. Currently, "safe" means that the pointer is either PTR_TO_CTX, or is refcounted. There may be cases, however, where the kernel passes a BPF program a safe / trusted pointer to an object that the BPF program wishes to use as a kptr, but because the object does not yet have a ref_obj_id from the perspective of the verifier, the program would be unable to pass it to a KF_ACQUIRE | KF_TRUSTED_ARGS kfunc.
The solution is to expand the set of pointers that are considered trusted according to KF_TRUSTED_ARGS, so that programs can invoke kfuncs with these pointers without getting rejected by the verifier.
There is already a PTR_UNTRUSTED flag that is set in some scenarios, such as when a BPF program reads a kptr directly from a map without performing a bpf_kptr_xchg() call. These pointers of course can and should be rejected by the verifier. Unfortunately, however, PTR_UNTRUSTED does not cover all the cases for safety that need to be addressed to adequately protect kfuncs. Specifically, pointers obtained by a BPF program "walking" a struct are _not_ considered PTR_UNTRUSTED according to BPF. For example, say that we were to add a kfunc called bpf_task_acquire(), with KF_ACQUIRE | KF_TRUSTED_ARGS, to acquire a struct task_struct *. If we only used PTR_UNTRUSTED to signal that a task was unsafe to pass to a kfunc, the verifier would mistakenly allow the following unsafe BPF program to be loaded:
SEC("tp_btf/task_newtask")
int BPF_PROG(unsafe_acquire_task,
struct task_struct *task,
u64 clone_flags)
{
struct task_struct *acquired, *nested;
nested = task->last_wakee;
/* Would not be rejected by the verifier. */
acquired = bpf_task_acquire(nested);
if (!acquired)
return 0;
bpf_task_release(acquired);
return 0;
}To address this, this patch defines a new type flag called PTR_TRUSTED which tracks whether a PTR_TO_BTF_ID pointer is safe to pass to a KF_TRUSTED_ARGS kfunc or a BPF helper function. PTR_TRUSTED pointers are passed directly from the kernel as a tracepoint or struct_ops callback argument. Any nested pointer that is obtained from walking a PTR_TRUSTED pointer is no longer PTR_TRUSTED. From the example above, the struct task_struct *task argument is PTR_TRUSTED, but the 'nested' pointer obtained from 'task->last_wakee' is not PTR_TRUSTED.
A subsequent patch will add kfuncs for storing a task kfunc as a kptr, and then another patch will add selftests to validate.
--- Documentation/bpf/kfuncs.rst | 30 ++++---- include/linux/bpf.h | 30 ++++++++ include/linux/bpf_verifier.h | 7 ++ include/linux/btf.h | 65 ++++++++++------- kernel/bpf/btf.c | 8 +++ kernel/bpf/verifier.c | 69 +++++++++++++++---- kernel/trace/bpf_trace.c | 2 +- net/ipv4/bpf_tcp_ca.c | 4 +- tools/testing/selftests/bpf/verifier/calls.c | 2 +- .../selftests/bpf/verifier/ref_tracking.c | 4 +- 10 files changed, 164 insertions(+), 57 deletions(-)
Documentation/bpf/kfuncs.rst +14 -16
@@ -161,22 +161,20 @@ KF_ACQUIRE and KF_RET_NULL flags. -------------------------- The KF_TRUSTED_ARGS flag is used for kfuncs taking pointer arguments. It -indicates that the all pointer arguments will always have a guaranteed lifetime, -and pointers to kernel objects are always passed to helpers in their unmodified -form (as obtained from acquire kfuncs). - -It can be used to enforce that a pointer to a refcounted object acquired from a -kfunc or BPF helper is passed as an argument to this kfunc without any -modifications (e.g. pointer arithmetic) such that it is trusted and points to -the original object. - -Meanwhile, it is also allowed pass pointers to normal memory to such kfuncs, -but those can have a non-zero offset. - -This flag is often used for kfuncs that operate (change some property, perform -some operation) on an object that was obtained using an acquire kfunc. Such -kfuncs need an unchanged pointer to ensure the integrity of the operation being -performed on the expected object. +indicates that the all pointer arguments are valid, and that all pointers to +BTF objects have been passed in their unmodified form (that is, at a zero +offset, and without having been obtained from walking another pointer). + +There are two types of pointers to kernel objects which are considered "valid": + +1. Pointers which are passed as tracepoint or struct_ops callback arguments. +2. Pointers which were returned from a KF_ACQUIRE or KF_KPTR_GET kfunc. + +Pointers to non-BTF objects (e.g. scalar pointers) may also be passed to +KF_TRUSTED_ARGS kfuncs, and may have a non-zero offset. + +The definition of "valid" pointers is subject to change at any time, and has +absolutely no ABI stability guarantees. 2.4.6 KF_SLEEPABLE flag -----------------------
include/linux/bpf.h +30 -0
@@ -543,6 +543,35 @@ enum bpf_type_flag {*/ MEM_ALLOC =BIT (11 +BPF_BASE_TYPE_BITS ), +/* PTR was passed from the kernel in a trusted context, and may be +* passed to KF_TRUSTED_ARGS kfuncs or BPF helper functions. +* Confusingly, this is _not_ the opposite of PTR_UNTRUSTED above. +* PTR_UNTRUSTED refers to a kptr that was read directly from a map +* without invoking bpf_kptr_xchg(). What we really need to know is +* whether a pointer is safe to pass to a kfunc or BPF helper function. +* While PTR_UNTRUSTED pointers are unsafe to pass to kfuncs and BPF +* helpers, they do not cover all possible instances of unsafe +* pointers. For example, a pointer that was obtained from walking a +* struct will _not_ get the PTR_UNTRUSTED type modifier, despite the +* fact that it may be NULL, invalid, etc. This is due to backwards +* compatibility requirements, as this was the behavior that was first +* introduced when kptrs were added. The behavior is now considered +* deprecated, and PTR_UNTRUSTED will eventually be removed. +* +* PTR_TRUSTED, on the other hand, is a pointer that the kernel +* guarantees to be valid and safe to pass to kfuncs and BPF helpers. +* For example, pointers passed to tracepoint arguments are considered +* PTR_TRUSTED, as are pointers that are passed to struct_ops +* callbacks. As alluded to above, pointers that are obtained from +* walking PTR_TRUSTED pointers are _not_ trusted. For example, if a +* struct task_struct *task is PTR_TRUSTED, then accessing +* task->last_wakee will lose the PTR_TRUSTED modifier when it's stored +* in a BPF register. Similarly, pointers passed to certain programs +* types such as kretprobes are not guaranteed to be valid, as they may +* for example contain an object that was recently freed. +*/ +PTR_TRUSTED =BIT (12 +BPF_BASE_TYPE_BITS ), + __BPF_TYPE_FLAG_MAX, __BPF_TYPE_LAST_FLAG = __BPF_TYPE_FLAG_MAX - 1, };
@@ -636,6 +665,7 @@ enum bpf_return_type {RET_PTR_TO_RINGBUF_MEM_OR_NULL =PTR_MAYBE_NULL |MEM_RINGBUF |RET_PTR_TO_MEM ,RET_PTR_TO_DYNPTR_MEM_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_MEM ,RET_PTR_TO_BTF_ID_OR_NULL =PTR_MAYBE_NULL |RET_PTR_TO_BTF_ID , +RET_PTR_TO_BTF_ID_TRUSTED =PTR_TRUSTED |RET_PTR_TO_BTF_ID ,/* This must be the last entry. Its purpose is to ensure the enum is * wide enough to hold the higher bits reserved for bpf_type_flag.
include/linux/bpf_verifier.h +7 -0
@@ -680,4 +680,11 @@ static inline bool bpf_prog_check_recur(const struct bpf_prog *prog) } } +#define BPF_REG_TRUSTED_MODIFIERS (MEM_ALLOC | PTR_TRUSTED) + +static inline bool bpf_type_has_unsafe_modifiers (u32 type) +{ +return type_flag (type) & ~BPF_REG_TRUSTED_MODIFIERS ; +} +#endif /* _LINUX_BPF_VERIFIER_H */
include/linux/btf.h +41 -24
77 lines not on this page · raw message
kernel/bpf/btf.c +8 -0
@@ -5799,6 +5799,11 @@ static u32 get_ctx_arg_idx(struct btf *btf, const struct btf_type *func_proto,return nr_args +1 ; } +static bool prog_type_args_trusted (enum bpf_prog_type prog_type) +{ +return prog_type ==BPF_PROG_TYPE_TRACING || prog_type ==BPF_PROG_TYPE_STRUCT_OPS ; +} +bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)
@@ -5942,6 +5947,9 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, } info->reg_type =PTR_TO_BTF_ID ; +if (prog_type_args_trusted (prog->type)) + info->reg_type |=PTR_TRUSTED ; +if (tgt_prog) {enum bpf_prog_type tgt_type;
kernel/bpf/verifier.c +57 -12
157 lines not on this page · raw message
kernel/trace/bpf_trace.c +1 -1
@@ -774,7 +774,7 @@ BPF_CALL_0(bpf_get_current_task_btf)const struct bpf_func_proto bpf_get_current_task_btf_proto = { .func = bpf_get_current_task_btf, .gpl_only = true, - .ret_type =RET_PTR_TO_BTF_ID , + .ret_type =RET_PTR_TO_BTF_ID_TRUSTED , .ret_btf_id = &btf_tracing_ids[BTF_TRACING_TYPE_TASK ], };
net/ipv4/bpf_tcp_ca.c +3 -1
@@ -61,7 +61,9 @@ static bool bpf_tcp_ca_is_valid_access(int off, int size,if (!bpf_tracing_btf_ctx_access (off, size, type, prog, info))return false; -if (info->reg_type ==PTR_TO_BTF_ID && info->btf_id == sock_id) +if (base_type (info->reg_type) ==PTR_TO_BTF_ID && + !bpf_type_has_unsafe_modifiers (info->reg_type) && + info->btf_id == sock_id)/* promote it to tcp_sock */ info->btf_id = tcp_sock_id;
tools/testing/selftests/bpf/verifier/calls.c +1 -1
@@ -109,7 +109,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "arg#0 expected pointer to btf or socket", + .errstr = "arg#0 is ptr_or_null_ expected ptr_ or socket", .fixup_kfunc_btf_id = { { "bpf_kfunc_call_test_acquire", 3 }, { "bpf_kfunc_call_test_release", 5 },
tools/testing/selftests/bpf/verifier/ref_tracking.c +2 -2
@@ -142,7 +142,7 @@ .kfunc = "bpf", .expected_attach_type = BPF_LSM_MAC, .flags = BPF_F_SLEEPABLE, - .errstr = "arg#0 expected pointer to btf or socket", + .errstr = "arg#0 is ptr_or_null_ expected ptr_ or socket", .fixup_kfunc_btf_id = { { "bpf_lookup_user_key", 2 }, { "bpf_key_put", 4 },
@@ -163,7 +163,7 @@ .kfunc = "bpf", .expected_attach_type = BPF_LSM_MAC, .flags = BPF_F_SLEEPABLE, - .errstr = "arg#0 expected pointer to btf or socket", + .errstr = "arg#0 is ptr_or_null_ expected ptr_ or socket", .fixup_kfunc_btf_id = { { "bpf_lookup_system_key", 1 }, { "bpf_key_put", 3 },
Signature · 1 line
2.38.1
PATCH v9 4/4 bpf/selftests: Add selftests for new task kfuncs
In reply to David VernetA previous change added a series of kfuncs for storing struct task_struct objects as referenced kptrs. This patch adds a new task_kfunc test suite for validating their expected behavior.
--- tools/testing/selftests/bpf/DENYLIST.s390x | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 159 +++++++++++ .../selftests/bpf/progs/task_kfunc_common.h | 71 +++++ .../selftests/bpf/progs/task_kfunc_failure.c | 260 ++++++++++++++++++ .../selftests/bpf/progs/task_kfunc_success.c | 149 ++++++++++ 5 files changed, 640 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/task_kfunc.c create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_common.h create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_failure.c create mode 100644 tools/testing/selftests/bpf/progs/task_kfunc_success.c
tools/testing/selftests/bpf/DENYLIST.s390x +1 -0
@@ -54,6 +54,7 @@ skc_to_unix_sock # could not attach BPF object unexpecte socket_cookie # prog_attach unexpected error: -524 (trampoline) stacktrace_build_id # compare_map_keys stackid_hmap vs. stackmap err -2 errno 2 (?) tailcalls # tail_calls are not allowed in non-JITed programs with bpf-to-bpf calls (?) +task_kfunc # JIT does not support calling kernel function task_local_storage # failed to auto-attach program 'trace_exit_creds': -524 (trampoline) test_bpffs # bpffs test failed 255 (iterator) test_bprm_opts # failed to auto-attach program 'secure_exec': -524 (trampoline)
tools/testing/selftests/bpf/prog_tests/task_kfunc.c new file +159 -0
159 lines not on this page · raw message
tools/testing/selftests/bpf/progs/task_kfunc_common.h new file +71 -0
71 lines not on this page · raw message
tools/testing/selftests/bpf/progs/task_kfunc_failure.c new file +260 -0
260 lines not on this page · raw message
tools/testing/selftests/bpf/progs/task_kfunc_success.c new file +149 -0
149 lines not on this page · raw message
Signature · 1 line
2.38.1
Re: [PATCH bpf-next v9 2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
In reply to David VernetQuoted 12 lines · David Vernet
kernel/bpf/verifier.c +7
-3case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if (reg->type !=PTR_TO_BTF_ID && - (!reg2btf_ids[base_type (reg->type)] ||type_flag (reg->type))) { -verbose (env,"arg#%d expected pointer to btf or socket\n" , i); +if ((base_type (reg->type) !=PTR_TO_BTF_ID || +bpf_type_has_unsafe_modifiers (reg->type)) && + !reg2btf_ids[base_type (reg->type)]) { +verbose (env,"arg#%d is %s " , i,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 )));
...
tools/testing/selftests/bpf/verifier/calls.c line 112
Quoted 10 lines
tools/testing/selftests/bpf/verifier/calls.c +1
-1@@ -109,7 +109,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "arg#0 expected pointer to btf or socket", + .errstr = "arg#0 is ptr_or_null_ expected ptr_ or socket",
Nice.
I missed the fact that reg_type_str() prints only the type. We see more verbose prints in print_verifier_state():
verbose(env, "%s", reg_type_str(env, t));
if (base_type(t) == PTR_TO_BTF_ID)
verbose(env, "%s", kernel_type_name(reg->btf, reg->btf_id));
Since reg_type_str() prints into a buffer maybe we can enhance it with struct name printing too?
Not urgent.
The set looks great. Applied.
There is an odd arm64 failure in bonding test reported by CI, but looks unrelated.
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 16 lines · On Sat, 19 Nov 2022 23:10:00 -0600 you wrote:
Now that BPF supports adding new kernel functions with kfuncs, and storing kernel objects in maps with kptrs, we can add a set of kfuncs which allow struct
task_structobjects to be stored in maps as referenced kptrs.The possible use cases for doing this are plentiful. During tracing, for example, it would be useful to be able to collect some tasks that performed a certain operation, and then periodically summarize who they are, which cgroup they're in, how much CPU time they've utilized, etc. Doing this now would require storing the tasks' pids along with some relevant data to be exported to user space, and later associating the pids to tasks in other event handlers where the data is recorded. Another useful by-product of this is that it allows a program to pin a task in a BPF program, and by proxy therefore also e.g. pin its task local storage.
Quoted 1 line
[...]
Here is the summary with links:
- [bpf-next,v9,1/4] bpf: Allow multiple modifiers in reg_type_str() prefix
https://git.kernel.org/bpf/bpf-next/c/ef66c5475d7f - [bpf-next,v9,2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs https://git.kernel.org/bpf/bpf-next/c/3f00c5239344 - [bpf-next,v9,3/4] bpf: Add kfuncs for storing struct task_struct * as a kptr https://git.kernel.org/bpf/bpf-next/c/90660309b0c7 - [bpf-next,v9,4/4] bpf/selftests: Add selftests for new task kfuncs https://git.kernel.org/bpf/bpf-next/c/fe147956fca4
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Re: [PATCH bpf-next v9 2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
In reply to Alexei StarovoitovQuoted 30 lines · Alexei Starovoitov
Quoted 12 lines · David Vernet
kernel/bpf/verifier.c +7
-3case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if (reg->type !=PTR_TO_BTF_ID && - (!reg2btf_ids[base_type (reg->type)] ||type_flag (reg->type))) { -verbose (env,"arg#%d expected pointer to btf or socket\n" , i); +if ((base_type (reg->type) !=PTR_TO_BTF_ID || +bpf_type_has_unsafe_modifiers (reg->type)) && + !reg2btf_ids[base_type (reg->type)]) { +verbose (env,"arg#%d is %s " , i,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 )));...
tools/testing/selftests/bpf/verifier/calls.c line 112
Quoted 10 lines
tools/testing/selftests/bpf/verifier/calls.c +1
-1@@ -109,7 +109,7 @@ }, .prog_type = BPF_PROG_TYPE_SCHED_CLS, .result = REJECT, - .errstr = "arg#0 expected pointer to btf or socket", + .errstr = "arg#0 is ptr_or_null_ expected ptr_ or socket",Nice.
I missed the fact thatreg_type_str()prints only the type. We see more verbose prints inprint_verifier_state():
verbose(env, "%s", reg_type_str(env, t));
if (base_type(t)==PTR_TO_BTF_ID)
Quoted 3 lines
verbose(env, "%s", kernel_type_name(reg->btf, reg->btf_id));Since
reg_type_str()prints into a buffer maybe we can enhance it with struct name printing too?
I like that, and we have a bit of extra space after bumping TYPE_STR_BUF_LEN to 128 so why not. I'll take care of it in a follow-up change.
Quoted 2 lines
Not urgent.
The set looks great. Applied.
Thanks!
Quoted 1 line
There is an odd arm64 failure in bonding test reported by CI, but looks unrelated.
Hmmm yeah, can't see how this change would have affected that. I'll keep an eye on it in CI to see if it persists.
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v9 2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
In reply to David VernetQuoted 54 lines · David Vernet
Kfuncs currently support specifying the
KF_TRUSTED_ARGSflag to signal to the verifier that it should enforce that a BPF program passes it a "safe", trusted pointer. Currently, "safe" means that the pointer is eitherPTR_TO_CTX, or is refcounted. There may be cases, however, where the kernel passes a BPF program a safe / trusted pointer to an object that the BPF program wishes to use as a kptr, but because the object does not yet have aref_obj_idfrom the perspective of the verifier, the program would be unable to pass it to aKF_ACQUIRE|KF_TRUSTED_ARGSkfunc.The solution is to expand the set of pointers that are considered trusted according to
KF_TRUSTED_ARGS, so that programs can invoke kfuncs with these pointers without getting rejected by the verifier.There is already a
PTR_UNTRUSTEDflag that is set in some scenarios, such as when a BPF program reads a kptr directly from a map without performing abpf_kptr_xchg()call. These pointers of course can and should be rejected by the verifier. Unfortunately, however,PTR_UNTRUSTEDdoes not cover all the cases for safety that need to be addressed to adequately protect kfuncs. Specifically, pointers obtained by a BPF program "walking" a struct are _not_ consideredPTR_UNTRUSTEDaccording to BPF. For example, say that we were to add a kfunc calledbpf_task_acquire(), withKF_ACQUIRE|KF_TRUSTED_ARGS, to acquire a structtask_struct*. If we only usedPTR_UNTRUSTEDto signal that a task was unsafe to pass to a kfunc, the verifier would mistakenly allow the following unsafe BPF program to be loaded:
SEC("tp_btf/task_newtask")
int BPF_PROG(unsafe_acquire_task,
structtask_struct*task,
u64clone_flags){ struct task_struct *acquired, *nested; nested = task->last_wakee; /* Would not be rejected by the verifier. */ acquired = bpf_task_acquire(nested); if (!acquired) return 0; bpf_task_release(acquired); return 0; }To address this, this patch defines a new type flag called
PTR_TRUSTEDwhich tracks whether aPTR_TO_BTF_IDpointer is safe to pass to aKF_TRUSTED_ARGSkfunc or a BPF helper function.PTR_TRUSTEDpointers are passed directly from the kernel as a tracepoint orstruct_opscallback argument. Any nested pointer that is obtained from walking aPTR_TRUSTEDpointer is no longerPTR_TRUSTED. From the example above, the structtask_struct*task argument isPTR_TRUSTED, but the 'nested' pointer obtained from 'task->last_wakee' is notPTR_TRUSTED.
Quoted 5 lines
A subsequent patch will add kfuncs for storing a task kfunc as a kptr, and then another patch will add selftests to validate.
Signed-off-by David Vernet <[email protected]>---
Sorry that I couldn't look at it earlier.
Quoted 7 lines
[...]
kernel/bpf/verifier.c +0
-2@@ -5884,8 +5889,18 @@ static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } };static const struct bpf_reg_types context_types = { .types = {PTR_TO_CTX } };static const struct bpf_reg_types ringbuf_mem_types = { .types = {PTR_TO_MEM |MEM_RINGBUF } };static const struct bpf_reg_types const_map_ptr_types = { .types = {CONST_PTR_TO_MAP } }; -static const struct bpf_reg_types btf_ptr_types = { .types = {PTR_TO_BTF_ID } }; -static const struct bpf_reg_types percpu_btf_ptr_types = { .types = {PTR_TO_BTF_ID |MEM_PERCPU } };
kernel/bpf/verifier.c static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } }; · line 5901
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+static const struct bpf_reg_types btf_ptr_types = { + .types = { +PTR_TO_BTF_ID , +PTR_TO_BTF_ID |PTR_TRUSTED , + }, +}; +static const struct bpf_reg_types percpu_btf_ptr_types = { + .types = { +PTR_TO_BTF_ID |MEM_PERCPU , +PTR_TO_BTF_ID |MEM_PERCPU |PTR_TRUSTED ,
Where is PTR_TRUSTED set for MEM_PERCPU?
kernel/bpf/verifier.c static int check_reg_type(struct bpf_verifier_env *env, u32 regno, · line 5991
Quoted 11 lines
kernel/bpf/verifier.c +3
-1+ } +};static const struct bpf_reg_types func_ptr_types = { .types = {PTR_TO_FUNC } };static const struct bpf_reg_types stack_ptr_types = { .types = {PTR_TO_STACK } };static const struct bpf_reg_types const_str_ptr_types = { .types = {PTR_TO_MAP_VALUE } };@@ -5973,7 +5988,7 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno,return -EACCES ; found: -if (reg->type ==PTR_TO_BTF_ID ) { +if (reg->type ==PTR_TO_BTF_ID || reg->type &PTR_TRUSTED ) {
Now, earlier MEM_ALLOC was supposed to not enter this branch. If your patch allows MEM_ALLOC | PTR_TRUSTED (but I don't think it does), it will enter this branch. I think it is better to just be explicit and say PTR_TO_BTF_ID || PTR_TO_BTF_ID | PTR_TRUSTED.
kernel/bpf/verifier.c int check_func_arg_reg_off(struct bpf_verifier_env *env, · line 6074
Quoted 9 lines
kernel/bpf/verifier.c +2
-0/* For bpf_sk_release, it needs to match against first member * 'struct sock_common', hence make an exception for it. This * allows bpf_sk_release to work for multiple socket types. @@ -6055,6 +6070,8 @@ int check_func_arg_reg_off(struct bpf_verifier_env *env,*/ case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |PTR_TRUSTED : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :
This and the one below:
kernel/bpf/verifier.c static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ · line 8405
Quoted 5 lines
kernel/bpf/verifier.c +1
-0@@ -8366,6 +8402,7 @@ static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ ptr = reg->map_ptr;break ;case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :
I think this will never be set, based on my reading of the code. Is the case with MEM_ALLOC | PTR_TRUSTED ever possible? And if this is needed here, why not update btf_struct_access? And KF_ARG_PTR_TO_ALLOC_BTF_ID is not updated either? Let me know if I missed something.
Quoted 79 lines
kernel/bpf/verifier.c +20
-1/* When referenced PTR_TO_BTF_ID is passed to release function, * it's fixed offset must be 0. In the other cases, fixed offset * can be non-zero. @@ -7939,6 +7956,25 @@ static bool is_kfunc_arg_kptr_get(struct bpf_kfunc_call_arg_meta *meta, int arg)return arg ==0 && (meta->kfunc_flags &KF_KPTR_GET ); } +static bool is_trusted_reg (const struct bpf_reg_state *reg) +{ +/* A referenced register is always trusted. */ +if (reg->ref_obj_id) +return true; + +/* If a register is not referenced, it is trusted if it has either the +* MEM_ALLOC or PTR_TRUSTED type modifiers, and no others. Some of the +* other type modifiers may be safe, but we elect to take an opt-in +* approach here as some (e.g. PTR_UNTRUSTED and PTR_MAYBE_NULL) are +* not. +* +* Eventually, we should make PTR_TRUSTED the single source of truth +* for whether a register is trusted. +*/ +return type_flag (reg->type) &BPF_REG_TRUSTED_MODIFIERS && + !bpf_type_has_unsafe_modifiers (reg->type); +} +static bool __kfunc_param_match_suffix (const struct btf *btf,const struct btf_param *arg,const char *suffix)@@ -8220,7 +8256,7 @@ static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,const char *reg_ref_tname;u32 reg_ref_id; -if (reg->type ==PTR_TO_BTF_ID ) { +if (base_type (reg->type) ==PTR_TO_BTF_ID ) { reg_btf = reg->btf; reg_ref_id = reg->btf_id; }else {kernel/bpf/verifier.c +11
-5ptr = reg->btf;break ;default :@@ -8596,8 +8633,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_BTF_ID :if (!is_kfunc_trusted_args (meta))break ; -if (!reg->ref_obj_id) { -verbose (env,"R%d must be referenced\n" , regno); + +if (!is_trusted_reg (reg)) { +verbose (env,"R%d must be referenced or trusted\n" , regno);return -EINVAL ; } fallthrough;@@ -8702,9 +8740,13 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_break ;case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if (reg->type !=PTR_TO_BTF_ID && - (!reg2btf_ids[base_type (reg->type)] ||type_flag (reg->type))) { -verbose (env,"arg#%d expected pointer to btf or socket\n" , i); +if ((base_type (reg->type) !=PTR_TO_BTF_ID || +bpf_type_has_unsafe_modifiers (reg->type)) && + !reg2btf_ids[base_type (reg->type)]) { +verbose (env,"arg#%d is %s " , i,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 )));return -EINVAL ; } ret =process_kf_arg_ptr_to_btf_id (env, reg, ref_t, ref_tname, ref_id, meta, i);@@ -14713,6 +14755,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)break ;case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_TRUSTED :/* PTR_TO_BTF_ID | MEM_ALLOC always has a valid lifetime, unlike * PTR_TO_BTF_ID, and an active ref_obj_id, but the same cannot * be said once it is marked PTR_UNTRUSTED, hence we must handle
kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) · line 14766
Quoted 4 lines
kernel/bpf/verifier.c +1
-0@@ -14720,6 +14763,8 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)* for this case. */ case PTR_TO_BTF_ID |MEM_ALLOC |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_UNTRUSTED |PTR_TRUSTED :
I feel this is confusing. What do we mean with PTR_UNTRUSTED | PTR_TRUSTED?
Quoted 1 line
kernel/bpf/verifier.c +1
-0+case PTR_TO_BTF_ID |PTR_UNTRUSTED |MEM_ALLOC |PTR_TRUSTED :
Re: [PATCH bpf-next v9 2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
Quoted 74 lines · Kumar Kartikeya Dwivedi
Quoted 54 lines · David Vernet
Kfuncs currently support specifying the
KF_TRUSTED_ARGSflag to signal to the verifier that it should enforce that a BPF program passes it a "safe", trusted pointer. Currently, "safe" means that the pointer is eitherPTR_TO_CTX, or is refcounted. There may be cases, however, where the kernel passes a BPF program a safe / trusted pointer to an object that the BPF program wishes to use as a kptr, but because the object does not yet have aref_obj_idfrom the perspective of the verifier, the program would be unable to pass it to aKF_ACQUIRE|KF_TRUSTED_ARGSkfunc.The solution is to expand the set of pointers that are considered trusted according to
KF_TRUSTED_ARGS, so that programs can invoke kfuncs with these pointers without getting rejected by the verifier.There is already a
PTR_UNTRUSTEDflag that is set in some scenarios, such as when a BPF program reads a kptr directly from a map without performing abpf_kptr_xchg()call. These pointers of course can and should be rejected by the verifier. Unfortunately, however,PTR_UNTRUSTEDdoes not cover all the cases for safety that need to be addressed to adequately protect kfuncs. Specifically, pointers obtained by a BPF program "walking" a struct are _not_ consideredPTR_UNTRUSTEDaccording to BPF. For example, say that we were to add a kfunc calledbpf_task_acquire(), withKF_ACQUIRE|KF_TRUSTED_ARGS, to acquire a structtask_struct*. If we only usedPTR_UNTRUSTEDto signal that a task was unsafe to pass to a kfunc, the verifier would mistakenly allow the following unsafe BPF program to be loaded:
SEC("tp_btf/task_newtask")
int BPF_PROG(unsafe_acquire_task,
structtask_struct*task,
u64clone_flags){ struct task_struct *acquired, *nested; nested = task->last_wakee; /* Would not be rejected by the verifier. */ acquired = bpf_task_acquire(nested); if (!acquired) return 0; bpf_task_release(acquired); return 0; }To address this, this patch defines a new type flag called
PTR_TRUSTEDwhich tracks whether aPTR_TO_BTF_IDpointer is safe to pass to aKF_TRUSTED_ARGSkfunc or a BPF helper function.PTR_TRUSTEDpointers are passed directly from the kernel as a tracepoint orstruct_opscallback argument. Any nested pointer that is obtained from walking aPTR_TRUSTEDpointer is no longerPTR_TRUSTED. From the example above, the structtask_struct*task argument isPTR_TRUSTED, but the 'nested' pointer obtained from 'task->last_wakee' is notPTR_TRUSTED.Quoted 5 lines
A subsequent patch will add kfuncs for storing a task kfunc as a kptr, and then another patch will add selftests to validate.
Signed-off-by David Vernet <[email protected]>---
Sorry that I couldn't look at it earlier.
Quoted 11 lines
[...]
kernel/bpf/verifier.c +4
-2@@ -5884,8 +5889,18 @@ static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } };static const struct bpf_reg_types context_types = { .types = {PTR_TO_CTX } };static const struct bpf_reg_types ringbuf_mem_types = { .types = {PTR_TO_MEM |MEM_RINGBUF } };static const struct bpf_reg_types const_map_ptr_types = { .types = {CONST_PTR_TO_MAP } }; -static const struct bpf_reg_types btf_ptr_types = { .types = {PTR_TO_BTF_ID } }; -static const struct bpf_reg_types percpu_btf_ptr_types = { .types = {PTR_TO_BTF_ID |MEM_PERCPU } }; +static const struct bpf_reg_types btf_ptr_types = { + .types = { +PTR_TO_BTF_ID , +PTR_TO_BTF_ID |PTR_TRUSTED ,
Quoted 8 lines
kernel/bpf/verifier.c static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } }; · line 5901
Quoted 6 lines
kernel/bpf/verifier.c +6
-0+ }, +}; +static const struct bpf_reg_types percpu_btf_ptr_types = { + .types = { +PTR_TO_BTF_ID |MEM_PERCPU , +PTR_TO_BTF_ID |MEM_PERCPU |PTR_TRUSTED ,Where is
PTR_TRUSTEDset forMEM_PERCPU?
We set PTR_TRUSTED in btf_ctx_access() for all PTR_TO_BTF_ID regs for BPF_PROG_TYPE_TRACING and BPF_PROG_TYPE_STRUCT_OPS. See [0]. Let me know if I've misunderstood anything.
[0]: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/tree/kernel/bpf/btf.c#n5972
Quoted 8 lines
Quoted 8 lines
kernel/bpf/verifier.c +2
-0+ } +};static const struct bpf_reg_types func_ptr_types = { .types = {PTR_TO_FUNC } };static const struct bpf_reg_types stack_ptr_types = { .types = {PTR_TO_STACK } };static const struct bpf_reg_types const_str_ptr_types = { .types = {PTR_TO_MAP_VALUE } };@@ -5973,7 +5988,7 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno,return -EACCES ;
Quoted 8 lines
kernel/bpf/verifier.c static int check_reg_type(struct bpf_verifier_env *env, u32 regno, · line 5991
Quoted 3 lines
kernel/bpf/verifier.c +1
-1found: -if (reg->type ==PTR_TO_BTF_ID ) { +if (reg->type ==PTR_TO_BTF_ID || reg->type &PTR_TRUSTED ) {Now, earlier
MEM_ALLOCwas supposed to not enter this branch. If your patch allowsMEM_ALLOC|PTR_TRUSTED(but I don't think it does), it will enter this branch. I think it is better to just be explicit and sayPTR_TO_BTF_ID||PTR_TO_BTF_ID|PTR_TRUSTED.
Currently I don't believe we set PTR_TRUSTED | MEM_ALLOC, so this won't happen. I originally had this code doing:
if (reg->type == PTR_TO_BTF_ID || reg->type & BPF_REG_TRUSTED_MODIFIERS) {and it caused a bunch of the linked list tests to fail with:
verifier internal error: R0 has non-overwritten BPF_PTR_POISON type
Checking just PTR_TRUSTED avoids this (which I assume is what you were worried about?). I'm happy to respin a patch that applies your suggestion to do || PTR_TO_BTF_ID | PTR_TRUSTED, but to be honest I don't think it buys us anything. That whole codepath where we take it only in the event of no modifiers is kind of sketchy. Consider, e.g., that we're skipping this check if we don't take that path:
if (!btf_struct_ids_match(&env->log, reg->btf, reg->btf_id, reg->off,
btf_vmlinux, *arg_btf_id,
strict_type_match)) {
verbose(env, "R%d is of type %s but %s is expected\n",
regno, kernel_type_name(reg->btf, reg->btf_id),
kernel_type_name(btf_vmlinux, *arg_btf_id));
return -EACCES;
}I know we check it elsewhere such as in map_kptr_match_type() and process_kf_arg_ptr_to_list_node(), but it feels pretty brittle to say:
"Check it only if there are no modifiers set, else check it later in some helper-specific logic". I'd prefer to keep the check as broad as possible for now, and then refactor and clean this up. Lmk if you disagree.
Quoted 13 lines
kernel/bpf/verifier.c int check_func_arg_reg_off(struct bpf_verifier_env *env, · line 6074
Quoted 10 lines
kernel/bpf/verifier.c +2
-0/* For bpf_sk_release, it needs to match against first member * 'struct sock_common', hence make an exception for it. This * allows bpf_sk_release to work for multiple socket types. @@ -6055,6 +6070,8 @@ int check_func_arg_reg_off(struct bpf_verifier_env *env,*/ case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |PTR_TRUSTED : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :This and the one below:
Quoted 11 lines
kernel/bpf/verifier.c static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ · line 8405
Quoted 5 lines
kernel/bpf/verifier.c +1
-0@@ -8366,6 +8402,7 @@ static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ ptr = reg->map_ptr;break ;case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :I think this will never be set, based on my reading of the code. Is the case with
MEM_ALLOC|PTR_TRUSTEDever possible? And if this is needed here, why not updatebtf_struct_access? AndKF_ARG_PTR_TO_ALLOC_BTF_IDis not updated either? Let me know if I missed something.
These are all reasonable observations, but we went into them intentionally. Eventually the goal is to have PTR_TRUSTED be the single source of truth for whether a pointer is trusted or not. See [1] for the thread with the discussions.
I agree that I don't believe that MEM_ALLOC | PTR_TRUSTED can be set together yet, but eventually they should and will be. Conceptually, the behavior of check_func_arg_reg_off() should be the same for PTR_TO_BTF_ID, PTR_TO_BTF_ID | MEM_ALLOC | PTR_TRUSTED, PTR_TO_BTF_ID | PTR_TRUSTED, etc, so IMO it's correct to add that case to check_func_arg_reg_off() even if it's not yet used. Not adding it because no callers currently happen to require it is IMO a bit brittle.
[1]: https://lore.kernel.org/all/20221119164855.qvhgdpg5axa7kzey@macbook-pro-5.dhcp.thefacebook.com/
Quoted 77 lines
Quoted 77 lines
kernel/bpf/verifier.c +20
-1/* When referenced PTR_TO_BTF_ID is passed to release function, * it's fixed offset must be 0. In the other cases, fixed offset * can be non-zero. @@ -7939,6 +7956,25 @@ static bool is_kfunc_arg_kptr_get(struct bpf_kfunc_call_arg_meta *meta, int arg)return arg ==0 && (meta->kfunc_flags &KF_KPTR_GET ); } +static bool is_trusted_reg (const struct bpf_reg_state *reg) +{ +/* A referenced register is always trusted. */ +if (reg->ref_obj_id) +return true; + +/* If a register is not referenced, it is trusted if it has either the +* MEM_ALLOC or PTR_TRUSTED type modifiers, and no others. Some of the +* other type modifiers may be safe, but we elect to take an opt-in +* approach here as some (e.g. PTR_UNTRUSTED and PTR_MAYBE_NULL) are +* not. +* +* Eventually, we should make PTR_TRUSTED the single source of truth +* for whether a register is trusted. +*/ +return type_flag (reg->type) &BPF_REG_TRUSTED_MODIFIERS && + !bpf_type_has_unsafe_modifiers (reg->type); +} +static bool __kfunc_param_match_suffix (const struct btf *btf,const struct btf_param *arg,const char *suffix)@@ -8220,7 +8256,7 @@ static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,const char *reg_ref_tname;u32 reg_ref_id; -if (reg->type ==PTR_TO_BTF_ID ) { +if (base_type (reg->type) ==PTR_TO_BTF_ID ) { reg_btf = reg->btf; reg_ref_id = reg->btf_id; }else {kernel/bpf/verifier.c +11
-5ptr = reg->btf;break ;default :@@ -8596,8 +8633,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_BTF_ID :if (!is_kfunc_trusted_args (meta))break ; -if (!reg->ref_obj_id) { -verbose (env,"R%d must be referenced\n" , regno); + +if (!is_trusted_reg (reg)) { +verbose (env,"R%d must be referenced or trusted\n" , regno);return -EINVAL ; } fallthrough;@@ -8702,9 +8740,13 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_break ;case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if (reg->type !=PTR_TO_BTF_ID && - (!reg2btf_ids[base_type (reg->type)] ||type_flag (reg->type))) { -verbose (env,"arg#%d expected pointer to btf or socket\n" , i); +if ((base_type (reg->type) !=PTR_TO_BTF_ID || +bpf_type_has_unsafe_modifiers (reg->type)) && + !reg2btf_ids[base_type (reg->type)]) { +verbose (env,"arg#%d is %s " , i,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 )));return -EINVAL ; } ret =process_kf_arg_ptr_to_btf_id (env, reg, ref_t, ref_tname, ref_id, meta, i);@@ -14713,6 +14755,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)break ;case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_TRUSTED :/* PTR_TO_BTF_ID | MEM_ALLOC always has a valid lifetime, unlike * PTR_TO_BTF_ID, and an active ref_obj_id, but the same cannot
Quoted 8 lines
kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) · line 14766
Quoted 6 lines
kernel/bpf/verifier.c +1
-0* be said once it is marked PTR_UNTRUSTED, hence we must handle @@ -14720,6 +14763,8 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)* for this case. */ case PTR_TO_BTF_ID |MEM_ALLOC |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_UNTRUSTED |PTR_TRUSTED :I feel this is confusing. What do we mean with
PTR_UNTRUSTED|PTR_TRUSTED?
100% agreed. There are plans to clean this up, see the link above.
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v9 2/4] bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs
Quoted 84 lines · David Vernet
Quoted 74 lines · Kumar Kartikeya Dwivedi
Quoted 54 lines · David Vernet
Kfuncs currently support specifying the
KF_TRUSTED_ARGSflag to signal to the verifier that it should enforce that a BPF program passes it a "safe", trusted pointer. Currently, "safe" means that the pointer is eitherPTR_TO_CTX, or is refcounted. There may be cases, however, where the kernel passes a BPF program a safe / trusted pointer to an object that the BPF program wishes to use as a kptr, but because the object does not yet have aref_obj_idfrom the perspective of the verifier, the program would be unable to pass it to aKF_ACQUIRE|KF_TRUSTED_ARGSkfunc.The solution is to expand the set of pointers that are considered trusted according to
KF_TRUSTED_ARGS, so that programs can invoke kfuncs with these pointers without getting rejected by the verifier.There is already a
PTR_UNTRUSTEDflag that is set in some scenarios, such as when a BPF program reads a kptr directly from a map without performing abpf_kptr_xchg()call. These pointers of course can and should be rejected by the verifier. Unfortunately, however,PTR_UNTRUSTEDdoes not cover all the cases for safety that need to be addressed to adequately protect kfuncs. Specifically, pointers obtained by a BPF program "walking" a struct are _not_ consideredPTR_UNTRUSTEDaccording to BPF. For example, say that we were to add a kfunc calledbpf_task_acquire(), withKF_ACQUIRE|KF_TRUSTED_ARGS, to acquire a structtask_struct*. If we only usedPTR_UNTRUSTEDto signal that a task was unsafe to pass to a kfunc, the verifier would mistakenly allow the following unsafe BPF program to be loaded:
SEC("tp_btf/task_newtask")
int BPF_PROG(unsafe_acquire_task,
structtask_struct*task,
u64clone_flags){ struct task_struct *acquired, *nested; nested = task->last_wakee; /* Would not be rejected by the verifier. */ acquired = bpf_task_acquire(nested); if (!acquired) return 0; bpf_task_release(acquired); return 0; }To address this, this patch defines a new type flag called
PTR_TRUSTEDwhich tracks whether aPTR_TO_BTF_IDpointer is safe to pass to aKF_TRUSTED_ARGSkfunc or a BPF helper function.PTR_TRUSTEDpointers are passed directly from the kernel as a tracepoint orstruct_opscallback argument. Any nested pointer that is obtained from walking aPTR_TRUSTEDpointer is no longerPTR_TRUSTED. From the example above, the structtask_struct*task argument isPTR_TRUSTED, but the 'nested' pointer obtained from 'task->last_wakee' is notPTR_TRUSTED.Quoted 5 lines
A subsequent patch will add kfuncs for storing a task kfunc as a kptr, and then another patch will add selftests to validate.
Signed-off-by David Vernet <[email protected]>---
Sorry that I couldn't look at it earlier.
Quoted 11 lines
[...]
kernel/bpf/verifier.c +4
-2@@ -5884,8 +5889,18 @@ static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } };static const struct bpf_reg_types context_types = { .types = {PTR_TO_CTX } };static const struct bpf_reg_types ringbuf_mem_types = { .types = {PTR_TO_MEM |MEM_RINGBUF } };static const struct bpf_reg_types const_map_ptr_types = { .types = {CONST_PTR_TO_MAP } }; -static const struct bpf_reg_types btf_ptr_types = { .types = {PTR_TO_BTF_ID } }; -static const struct bpf_reg_types percpu_btf_ptr_types = { .types = {PTR_TO_BTF_ID |MEM_PERCPU } }; +static const struct bpf_reg_types btf_ptr_types = { + .types = { +PTR_TO_BTF_ID , +PTR_TO_BTF_ID |PTR_TRUSTED ,Quoted 8 lines
kernel/bpf/verifier.c static const struct bpf_reg_types scalar_types = { .types = { SCALAR_VALUE } }; · line 5901
Quoted 6 lines
kernel/bpf/verifier.c +6
-0+ }, +}; +static const struct bpf_reg_types percpu_btf_ptr_types = { + .types = { +PTR_TO_BTF_ID |MEM_PERCPU , +PTR_TO_BTF_ID |MEM_PERCPU |PTR_TRUSTED ,Where is
PTR_TRUSTEDset forMEM_PERCPU?
Quoted 6 lines
We set
PTR_TRUSTEDinbtf_ctx_access()for allPTR_TO_BTF_IDregs forBPF_PROG_TYPE_TRACINGandBPF_PROG_TYPE_STRUCT_OPS. See [0]. Let me know if I've misunderstood anything.[0]: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/tree/kernel/bpf/btf.c#n5972
Ah, I see. Makes sense.
Quoted 17 lines
Quoted 8 lines
Quoted 8 lines
kernel/bpf/verifier.c +2
-0+ } +};static const struct bpf_reg_types func_ptr_types = { .types = {PTR_TO_FUNC } };static const struct bpf_reg_types stack_ptr_types = { .types = {PTR_TO_STACK } };static const struct bpf_reg_types const_str_ptr_types = { .types = {PTR_TO_MAP_VALUE } };@@ -5973,7 +5988,7 @@ static int check_reg_type(struct bpf_verifier_env *env, u32 regno,return -EACCES ;Quoted 8 lines
kernel/bpf/verifier.c static int check_reg_type(struct bpf_verifier_env *env, u32 regno, · line 5991
Quoted 3 lines
kernel/bpf/verifier.c +1
-1found: -if (reg->type ==PTR_TO_BTF_ID ) { +if (reg->type ==PTR_TO_BTF_ID || reg->type &PTR_TRUSTED ) {Now, earlier
MEM_ALLOCwas supposed to not enter this branch. If your patch allowsMEM_ALLOC|PTR_TRUSTED(but I don't think it does), it will enter this branch. I think it is better to just be explicit and sayPTR_TO_BTF_ID||PTR_TO_BTF_ID|PTR_TRUSTED.
Quoted 9 lines
Currently I don't believe we set
PTR_TRUSTED|MEM_ALLOC, so this won't happen. I originally had this code doing:if (reg->type == PTR_TO_BTF_ID || reg->type & BPF_REG_TRUSTED_MODIFIERS) {and it caused a bunch of the linked list tests to fail with:
verifier internal error: R0 has non-overwritten
BPF_PTR_POISONtype
Yes, because that will make MEM_ALLOC enter this branch for bpf_spin_lock/bpf_spin_unlock, which is what shouldn't be happening. The else if (type_is_alloc) is precisely to handle MEM_ALLOC case.
Quoted 6 lines
Checking just
PTR_TRUSTEDavoids this (which I assume is what you were worried about?). I'm happy to respin a patch that applies your suggestion to do ||PTR_TO_BTF_ID|PTR_TRUSTED, but to be honest I don't think it buys us anything. That whole codepath where we take it only in the event of no modifiers is kind of sketchy. Consider, e.g., that we're skipping this check if we don't take that path:
It should be taken for PTR_TO_BTF_ID | PTR_TRUSTED, but not those with MEM_ALLOC.
Quoted 10 lines
if (!btf_struct_ids_match(&env->log, reg->btf, reg->btf_id, reg->off,
btf_vmlinux, *arg_btf_id,
strict_type_match)) {
verbose(env, "R%d is of type %s but %s is expected\n",
regno, kernel_type_name(reg->btf, reg->btf_id),
kernel_type_name(btf_vmlinux, *arg_btf_id));
return -EACCES;
}That's because we shouldn't take that path. MEM_ALLOC is for prog BTF PTR_TO_BTF_ID, matching with btf_vmlinux types is incorrect.
You won't see errors now because that case of MEM_ALLOC | PTR_TRUSTED is not happening.
Quoted 7 lines
I know we check it elsewhere such as in
map_kptr_match_type()andprocess_kf_arg_ptr_to_list_node(), but it feels pretty brittle to say:
"Check it only if there are no modifiers set, else check it later in some helper-specific logic". I'd prefer to keep the check as broad as possible for now, and then refactor and clean this up. Lmk if you disagree.
I think this one needs to be fixed, both MEM_ALLOC and MEM_ALLOC | PTR_TRUSTED should go to that else if branch. This should only be taken for PTR_TO_BTF_ID and PTR_TO_BTF_ID | PTR_TRUSTED.
Quoted 30 lines
Quoted 13 lines
kernel/bpf/verifier.c int check_func_arg_reg_off(struct bpf_verifier_env *env, · line 6074
Quoted 10 lines
kernel/bpf/verifier.c +2
-0/* For bpf_sk_release, it needs to match against first member * 'struct sock_common', hence make an exception for it. This * allows bpf_sk_release to work for multiple socket types. @@ -6055,6 +6070,8 @@ int check_func_arg_reg_off(struct bpf_verifier_env *env,*/ case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |PTR_TRUSTED : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :This and the one below:
Quoted 11 lines
kernel/bpf/verifier.c static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ · line 8405
Quoted 5 lines
kernel/bpf/verifier.c +1
-0@@ -8366,6 +8402,7 @@ static int check_reg_allocation_locked(struct bpf_verifier_env *env, struct bpf_ ptr = reg->map_ptr;break ;case PTR_TO_BTF_ID |MEM_ALLOC : +case PTR_TO_BTF_ID |MEM_ALLOC |PTR_TRUSTED :I think this will never be set, based on my reading of the code. Is the case with
MEM_ALLOC|PTR_TRUSTEDever possible? And if this is needed here, why not updatebtf_struct_access? AndKF_ARG_PTR_TO_ALLOC_BTF_IDis not updated either? Let me know if I missed something.These are all reasonable observations, but we went into them intentionally. Eventually the goal is to have
PTR_TRUSTEDbe the single source of truth for whether a pointer is trusted or not. See [1] for the thread with the discussions.
Quoted 8 lines
I agree that I don't believe that
MEM_ALLOC|PTR_TRUSTEDcan be set together yet, but eventually they should and will be. Conceptually, the behavior ofcheck_func_arg_reg_off()should be the same forPTR_TO_BTF_ID,PTR_TO_BTF_ID|MEM_ALLOC|PTR_TRUSTED,PTR_TO_BTF_ID|PTR_TRUSTED, etc, so IMO it's correct to add that case tocheck_func_arg_reg_off()even if it's not yet used. Not adding it because no callers currently happen to require it is IMO a bit brittle.
I don't have a problem with PTR_TRUSTED being the source of truth. I think it's fine.
I was just pointing out that the checks are there in some places but not all, even if there are no users, you should be accounting for MEM_ALLOC | PTR_TRUSTED either everywhere or nowhere. It was a bit confusing to see it in check_reg_allocation_locked right now but not in check_ptr_to_btf_access (e.g. it would disallow writes for MEM_ALLOC | PTR_TRUSTED), or in kfunc handling.
But I guess you plan to address that in a follow up, so it's not a big deal. It would be a great improvement over the status quo if we can make this work properly, and then finally flip KF_TRUSTED_ARGS eventually to default on.
Quoted 88 lines
[1]: https://lore.kernel.org/all/20221119164855.qvhgdpg5axa7kzey@macbook-pro-5.dhcp.thefacebook.com/
Quoted 77 lines
Quoted 77 lines
kernel/bpf/verifier.c +20
-1/* When referenced PTR_TO_BTF_ID is passed to release function, * it's fixed offset must be 0. In the other cases, fixed offset * can be non-zero. @@ -7939,6 +7956,25 @@ static bool is_kfunc_arg_kptr_get(struct bpf_kfunc_call_arg_meta *meta, int arg)return arg ==0 && (meta->kfunc_flags &KF_KPTR_GET ); } +static bool is_trusted_reg (const struct bpf_reg_state *reg) +{ +/* A referenced register is always trusted. */ +if (reg->ref_obj_id) +return true; + +/* If a register is not referenced, it is trusted if it has either the +* MEM_ALLOC or PTR_TRUSTED type modifiers, and no others. Some of the +* other type modifiers may be safe, but we elect to take an opt-in +* approach here as some (e.g. PTR_UNTRUSTED and PTR_MAYBE_NULL) are +* not. +* +* Eventually, we should make PTR_TRUSTED the single source of truth +* for whether a register is trusted. +*/ +return type_flag (reg->type) &BPF_REG_TRUSTED_MODIFIERS && + !bpf_type_has_unsafe_modifiers (reg->type); +} +static bool __kfunc_param_match_suffix (const struct btf *btf,const struct btf_param *arg,const char *suffix)@@ -8220,7 +8256,7 @@ static int process_kf_arg_ptr_to_btf_id(struct bpf_verifier_env *env,const char *reg_ref_tname;u32 reg_ref_id; -if (reg->type ==PTR_TO_BTF_ID ) { +if (base_type (reg->type) ==PTR_TO_BTF_ID ) { reg_btf = reg->btf; reg_ref_id = reg->btf_id; }else {kernel/bpf/verifier.c +11
-5ptr = reg->btf;break ;default :@@ -8596,8 +8633,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_case KF_ARG_PTR_TO_BTF_ID :if (!is_kfunc_trusted_args (meta))break ; -if (!reg->ref_obj_id) { -verbose (env,"R%d must be referenced\n" , regno); + +if (!is_trusted_reg (reg)) { +verbose (env,"R%d must be referenced or trusted\n" , regno);return -EINVAL ; } fallthrough;@@ -8702,9 +8740,13 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_break ;case KF_ARG_PTR_TO_BTF_ID :/* Only base_type is checked, further checks are done here */ -if (reg->type !=PTR_TO_BTF_ID && - (!reg2btf_ids[base_type (reg->type)] ||type_flag (reg->type))) { -verbose (env,"arg#%d expected pointer to btf or socket\n" , i); +if ((base_type (reg->type) !=PTR_TO_BTF_ID || +bpf_type_has_unsafe_modifiers (reg->type)) && + !reg2btf_ids[base_type (reg->type)]) { +verbose (env,"arg#%d is %s " , i,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 )));return -EINVAL ; } ret =process_kf_arg_ptr_to_btf_id (env, reg, ref_t, ref_tname, ref_id, meta, i);@@ -14713,6 +14755,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)break ;case PTR_TO_BTF_ID :case PTR_TO_BTF_ID |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_TRUSTED :/* PTR_TO_BTF_ID | MEM_ALLOC always has a valid lifetime, unlike * PTR_TO_BTF_ID, and an active ref_obj_id, but the same cannot Quoted 8 lines
kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) · line 14766
Quoted 6 lines
kernel/bpf/verifier.c +1
-0* be said once it is marked PTR_UNTRUSTED, hence we must handle @@ -14720,6 +14763,8 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)* for this case. */ case PTR_TO_BTF_ID |MEM_ALLOC |PTR_UNTRUSTED : +case PTR_TO_BTF_ID |PTR_UNTRUSTED |PTR_TRUSTED :I feel this is confusing. What do we mean with
PTR_UNTRUSTED|PTR_TRUSTED?
Quoted 1 line
100% agreed. There are plans to clean this up, see the link above.
Great, looking forward.
Re: [PATCH bpf-next v9 3/4] bpf: Add kfuncs for storing struct task_struct * as a kptr
In reply to David VernetHello David,
Your idea behind this patch is cool, but I'm afraid that the implementation is incorrect.
As you can see, the task_struct:rcu_users member shares the same memory area with the task_struct:rcu (the head of an RCU CB).
Consequence: *violated invariant* that the reference counter will remain zero after reaching zero!!!
After reaching zero the task_struct:rcu head is set, so further attempts to access the task_struct:rcu_users may lead to a non-zero value. For more information see
https://lore.kernel.org/lkml/CAHk-=wjT6LG6sDaZtfeT80B9RaMP-y7RNRM4F5CX2v2Z=o8e=A@mail.gmail.com/
In my opinion, the decision about task_struct:rcu and task_struct:rcu_users union is very bad, but you should probably consult the memory separation with authors of the actual implementation.
For now, in our project, we use the following approach:
1) get a reference to a valid task within RCU read-side with get_task_struct()
2) in the release function:
2.1) enter RCU read-side
2.2) if the task state is not TASK_DEAD: use put_task_struct()
Note: In the case of a race with an exiting task it's OK to call put_task_struct(), because task_struct will be freed *after* the current RCU GP thanks to the task_struct:rcu_users mechanism.
2.3) otherwise if test_and_set(my_cb_flag): call_rcu(my_cb)
Note1: With respect to the RCU CB API you should guarantee that your CB will be installed only once within a given RCU GP. For that purpose we use my_cb_flag.
Note2: This code will race with the task_struct:rcu_users mechanism [delayed_put_task_struct()], but it's OK. Either the delayed_put_task_struct() or my_cb() can be the last to call final put_task_struct() after the current RCU GP.
2.4) otherwise: call put_task_struct()
Note: The my_cb() is already installed, so within the current RCU GP we can invoke put_task_struct() and the ref counter of the task_struct will not reach zero.
2.5) release the RCU read-side
3) The RCU CB my_cb() should set the my_cb_flag to False and call put_task_struct().
If the release function is called within RCU read-side, the task_struct is guaranteed to remain valid until the end of the current RCU GP.
Good luck,
mY
Re: [PATCH bpf-next v9 3/4] bpf: Add kfuncs for storing struct task_struct * as a kptr
Quoted 1 line · Matus Jokay
Hello David,
Hi Matus,
Quoted 10 lines
Your idea behind this patch is cool, but I'm afraid that the implementation is incorrect.
As you can see, the task_struct:rcu_users member shares the same memory area with the task_struct:rcu (the head of an RCU CB).
Consequence: *violated invariant* that the reference counter will remain zero after reaching zero!!!
After reaching zero the task_struct:rcu head is set, so further attempts to access the task_struct:rcu_users may lead to a non-zero value.
Yes, you're right. Thanks for explaining this and pointing out the oversight.
Quoted 5 lines
For more information see
https://lore.kernel.org/lkml/CAHk-=wjT6LG6sDaZtfeT80B9RaMP-y7RNRM4F5CX2v2Z=o8e=A@mail.gmail.com/
In my opinion, the decision about task_struct:rcu and task_struct:rcu_users union is very bad, but you should probably consult the memory separation with authors of the actual implementation.
I expect the reason it's like that is because prior to this change, as Linus pointed out, nothing ever increments the refcount (other than as of commit 912616f142bf: ("exit: Guarantee make_task_dead leaks the tsk when calling do_task_exit"), which similarly increments before the reference could have ever gone to 0, so I think is fine), so we had the ability to save a few bytes of memory in struct task_struct. Eric mentioned this explicitly in the commit summary for commit 3fbd7ee285b2 ("tasks: Add a count of task RCU users").
Now that the refcount is actually being used as a proper refcount with this commit, that space saving is no longer an option (unless we rip out my changes of course). +cc Eric and Oleg -- would you guys be OK with separating them out from that union? I guess the alternative would be to check for p->flags & PF_EXITING in the helper, but using p->rcu_users feels more natural.
Quoted 11 lines
For now, in our project, we use the following approach:
1) get a reference to a valid task within RCU read-side with
get_task_struct()
2) in the release function:
2.1) enter RCU read-side
2.2) if the task state is notTASK_DEAD: useput_task_struct()
Note: In the case of a race with an exiting task it's OK to callput_task_struct(), becausetask_structwill be freed *after* the current RCU GP thanks to the task_struct:rcu_users mechanism.
Quoted 8 lines
2.3) otherwise if
test_and_set(my_cb_flag):call_rcu(my_cb)
Note1: With respect to the RCU CB API you should guarantee that your CB will be installed only once within a given RCU GP. For that purpose we usemy_cb_flag.
Note2: This code will race with the task_struct:rcu_users mechanism [delayed_put_task_struct()], but it's OK. Either thedelayed_put_task_struct()ormy_cb()can be the last to call finalput_task_struct()after the current RCU GP.
I think this idea would work, but in order for us to do this, I believe we'd have to add _another_ struct rcu_head to struct task_struct. If we did that, I don't think there's any reason to not just separate them out of the union where they live today as it's only like that for space-saving reasons.
Quoted 13 lines
2.4) otherwise: call
put_task_struct()
Note: Themy_cb()is already installed, so within the current RCU GP we can invokeput_task_struct()and the ref counter of thetask_structwill not reach zero.
2.5) release the RCU read-side
3) The RCU CBmy_cb()should set themy_cb_flagto False and callput_task_struct().If the release function is called within RCU read-side, the
task_structis guaranteed to remain valid until the end of the current RCU GP.Good luck,
mY