Explicit raw_tp NULL arguments
Subsystems (4)
Kumar Kartikeya Dwivedi
maintainerv2 cover Explicit raw_tp NULL arguments
This set reverts the raw_tp masking changes introduced in commit cb4158ce8ec8 ("bpf: Mark raw_tp arguments with PTR_MAYBE_NULL") and replaces it wwith an explicit list of tracepoints and their arguments which need to be annotated as PTR_MAYBE_NULL. More context on the fallout caused by the masking fix and subsequent discussions can be found in [0].
To remedy this, we implement a solution of explicitly defined tracepoint and define which args need to be marked NULL or scalar (for IS_ERR case). The commit logs describes the details of this approach in detail.
We will follow up this solution an approach Eduard is working on to perform automated analysis of NULL-ness of tracepoint arguments. The current PoC is available here:
- LLVM branch with the analysis:
https://github.com/eddyz87/llvm-project/tree/nullness-for-tracepoint-params
- Python script for merging of analysis results:
https://gist.github.com/eddyz87/e47c164466a60e8d49e6911cff146f47
The idea is to infer a tri-state verdict for each tracepoint parameter:
definitely not null, can be null, unknown (in which case no assumptions should be made).
Using this information, the verifier in most cases will be able to precisely determine the state of the tracepoint parameter without any human effort. At that point, the table maintained manually in this set can be dropped and replace with this automated analysis tool's result. This will be kept up to date with each kernel release.
[0]: https://lore.kernel.org/bpf/[email protected]
Changelog:
----------
v1 -> v2:
v1: https://lore.kernel.org/bpf/[email protected]
* Address comments from Jiri
* Mark module tracepoints args NULL by default
* Add more sunrpc tracepoints
* Unify scalar or null handling
* Address comments from Alexei
* Use bitmask approach suggested in review
* Unify scalar or null handling
* Drop most tests that rely on CONFIG options
* Drop scripts to generate tests
Kumar Kartikeya Dwivedi (3):
bpf: Revert "bpf: Mark raw_tp arguments with PTR_MAYBE_NULL"
bpf: Augment raw_tp arguments with PTR_MAYBE_NULL selftests/bpf: Add tests for raw_tp NULL args
include/linux/bpf.h | 6 - kernel/bpf/btf.c | 141 +++++++++++++++++- kernel/bpf/verifier.c | 79 +--------- .../selftests/bpf/prog_tests/raw_tp_null.c | 3 + .../testing/selftests/bpf/progs/raw_tp_null.c | 19 ++- .../selftests/bpf/progs/raw_tp_null_fail.c | 24 +++ .../bpf/progs/test_tp_btf_nullable.c | 6 +- 7 files changed, 181 insertions(+), 97 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/raw_tp_null_fail.c
base-commit: e4c80f69758e5088e8aae48f3d6abb41c6da7812
Signature · 1 line
2.43.5
Kumar Kartikeya Dwivedi
maintainerPATCH v2 1/3 bpf: Revert "bpf: Mark raw_tp arguments with PTR_MAYBE_NULL"
This patch reverts commitcb4158ce8ec8 ("bpf: Mark raw_tp arguments with PTR_MAYBE_NULL"). The patch was well-intended and meant to be as a stop-gap fixing branch prediction when the pointer may actually be NULL at runtime. Eventually, it was supposed to be replaced by an automated script or compiler pass detecting possibly NULL arguments and marking them accordingly.
However, it caused two main issues observed for production programs and failed to preserve backwards compatibility. First, programs relied on the verifier not exploring == NULL branch when pointer is not NULL, thus they started failing with a 'dereference of scalar' error. Next, allowing raw_tp arguments to be modified surfaced the warning in the verifier that warns against reg->off when PTR_MAYBE_NULL is set.
More information, context, and discusson on both problems is available in [0]. Overall, this approach had several shortcomings, and the fixes would further complicate the verifier's logic, and the entire masking scheme would have to be removed eventually anyway.
Hence, revert the patch in preparation of a better fix avoiding these issues to replace this commit.
[0]: https://lore.kernel.org/bpf/[email protected]
--- include/linux/bpf.h | 6 -- kernel/bpf/btf.c | 5 +- kernel/bpf/verifier.c | 79 ++----------------- .../bpf/progs/test_tp_btf_nullable.c | 6 +- 4 files changed, 9 insertions(+), 87 deletions(-)
include/linux/bpf.h +0 -6
@@ -3514,10 +3514,4 @@ static inline bool bpf_is_subprog(const struct bpf_prog *prog) return prog->aux->func_idx != 0; } -static inline bool bpf_prog_is_raw_tp (const struct bpf_prog *prog) -{ -return prog->type ==BPF_PROG_TYPE_TRACING && - prog->expected_attach_type ==BPF_TRACE_RAW_TP ; -} -#endif /* _LINUX_BPF_H */
kernel/bpf/btf.c +1 -4
@@ -6594,10 +6594,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,if (prog_args_trusted (prog)) info->reg_type |=PTR_TRUSTED ; -/* Raw tracepoint arguments always get marked as maybe NULL */ -if (bpf_prog_is_raw_tp (prog)) - info->reg_type |=PTR_MAYBE_NULL ; -else if (btf_param_match_suffix (btf, &args[arg],"__nullable" )) +if (btf_param_match_suffix (btf, &args[arg],"__nullable" )) info->reg_type |=PTR_MAYBE_NULL ;if (tgt_prog) {
kernel/bpf/verifier.c +7 -72
223 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_tp_btf_nullable.c +1 -5
@@ -7,11 +7,7 @@#include "bpf_misc.h" SEC("tp_btf/bpf_testmod_test_nullable_bare") -/* This used to be a failure test, but raw_tp nullable arguments can now -* directly be dereferenced, whether they have nullable annotation or not, -* and don't need to be explicitly checked. - */ -__success +__failure __msg("R1 invalid mem access 'trusted_ptr_or_null_'") int BPF_PROG(handle_tp_btf_nullable_bare1, struct bpf_testmod_test_read_ctx *nullable_ctx) {return nullable_ctx->len;
Signature · 1 line
2.43.5
Kumar Kartikeya Dwivedi
maintainerPATCH v2 2/3 bpf: Augment raw_tp arguments with PTR_MAYBE_NULL
In reply to Kumar Kartikeya DwivediArguments to a raw tracepoint are tagged as trusted, which carries the semantics that the pointer will be non-NULL. However, in certain cases, a raw tracepoint argument may end up being NULL. More context about this issue is available in [0].
Thus, there is a discrepancy between the reality, that raw_tp arguments can actually be NULL, and the verifier's knowledge, that they are never NULL, causing explicit NULL check branch to be dead code eliminated.
A previous attempt [1], i.e. the second fixed commit, was made to simulate symbolic execution as if in most accesses, the argument is a non-NULL raw_tp, except for conditional jumps. This tried to suppress branch prediction while preserving compatibility, but surfaced issues with production programs that were difficult to solve without increasing verifier complexity. A more complete discussion of issues and fixes is available at [2].
Fix this by maintaining an explicit list of tracepoints where the arguments are known to be NULL, and mark the positional arguments as PTR_MAYBE_NULL. Additionally, capture the tracepoints where arguments are known to be ERR_PTR, and mark these arguments as scalar values to prevent potential dereference.
Each hex digit is used to encode NULL-ness (0x1) or ERR_PTR-ness (0x2), shifted by the zero-indexed argument number x 4. This can be represented as follows:
1st arg: 0x1
2nd arg: 0x10
3rd arg: 0x100
... and so on (likewise for ERR_PTR case).
In the future, an automated pass will be used to produce such a list, or insert __nullable annotations automatically for tracepoints. Each compilation unit will be analyzed and results will be collated to find whether a tracepoint pointer is definitely not null, maybe null, or an unknown state where verifier conservatively marks it PTR_MAYBE_NULL. A proof of concept of this tool from Eduard is available at [3].
Note that in case we don't find a specification in the raw_tp_null_args array and the tracepoint belongs to a kernel module, we will conservatively mark the arguments as PTR_MAYBE_NULL. This is because unlike for in-tree modules, out-of-tree module tracepoints may pass NULL freely to the tracepoint. We don't protect against such tracepoints passing ERR_PTR (which is uncommon anyway), lest we mark all such arguments as SCALAR_VALUE.
While we are it, let's adjust the test raw_tp_null to not perform dereference of the skb->mark, as that won't be allowed anymore, and make it more robust by using inline assembly to test the dead code elimination behavior, which should still stay the same.
[0]: https://lore.kernel.org/bpf/[email protected]
[1]: https://lore.kernel.org/all/[email protected]
[2]: https://lore.kernel.org/bpf/[email protected]
[3]: https://github.com/eddyz87/llvm-project/tree/nullness-for-tracepoint-params
--- kernel/bpf/btf.c | 136 ++++++++++++++++++ .../testing/selftests/bpf/progs/raw_tp_null.c | 19 ++- 2 files changed, 145 insertions(+), 10 deletions(-)
kernel/bpf/btf.c +136 -0
@@ -6439,6 +6439,101 @@ int btf_ctx_arg_offset(const struct btf *btf, const struct btf_type *func_proto,return off; } +struct bpf_raw_tp_null_args { +const char *func; +u64 mask; +}; + +static const struct bpf_raw_tp_null_args raw_tp_null_args[] = { +/* sched */ + {"sched_pi_setprio" ,0x10 }, +/* ... from sched_numa_pair_template event class */ + {"sched_stick_numa" ,0x100 }, + {"sched_swap_numa" ,0x100 }, +/* afs */ + {"afs_make_fs_call" ,0x10 }, + {"afs_make_fs_calli" ,0x10 }, + {"afs_make_fs_call1" ,0x10 }, + {"afs_make_fs_call2" ,0x10 }, + {"afs_protocol_error" ,0x1 }, + {"afs_flock_ev" ,0x10 }, +/* cachefiles */ + {"cachefiles_lookup" ,0x1 |0x200 }, + {"cachefiles_unlink" ,0x1 }, + {"cachefiles_rename" ,0x1 }, + {"cachefiles_prep_read" ,0x1 }, + {"cachefiles_mark_active" ,0x1 }, + {"cachefiles_mark_failed" ,0x1 }, + {"cachefiles_mark_inactive" ,0x1 }, + {"cachefiles_vfs_error" ,0x1 }, + {"cachefiles_io_error" ,0x1 }, + {"cachefiles_ondemand_open" ,0x1 }, + {"cachefiles_ondemand_copen" ,0x1 }, + {"cachefiles_ondemand_close" ,0x1 }, + {"cachefiles_ondemand_read" ,0x1 }, + {"cachefiles_ondemand_cread" ,0x1 }, + {"cachefiles_ondemand_fd_write" ,0x1 }, + {"cachefiles_ondemand_fd_release" ,0x1 }, +/* ext4, from ext4__mballoc event class */ + {"ext4_mballoc_discard" ,0x10 }, + {"ext4_mballoc_free" ,0x10 }, +/* fib */ + {"fib_table_lookup" ,0x100 }, +/* filelock */ +/* ... from filelock_lock event class */ + {"posix_lock_inode" ,0x10 }, + {"fcntl_setlk" ,0x10 }, + {"locks_remove_posix" ,0x10 }, + {"flock_lock_inode" ,0x10 }, +/* ... from filelock_lease event class */ + {"break_lease_noblock" ,0x10 }, + {"break_lease_block" ,0x10 }, + {"break_lease_unblock" ,0x10 }, + {"generic_delete_lease" ,0x10 }, + {"time_out_leases" ,0x10 }, +/* host1x */ + {"host1x_cdma_push_gather" ,0x10000 }, +/* huge_memory */ + {"mm_khugepaged_scan_pmd" ,0x10 }, + {"mm_collapse_huge_page_isolate" ,0x1 }, + {"mm_khugepaged_scan_file" ,0x10 }, + {"mm_khugepaged_collapse_file" ,0x10 }, +/* kmem */ + {"mm_page_alloc" ,0x1 }, + {"mm_page_pcpu_drain" ,0x1 }, +/* .. from mm_page event class */ + {"mm_page_alloc_zone_locked" ,0x1 }, +/* netfs */ + {"netfs_failure" ,0x10 }, +/* power */ + {"device_pm_callback_start" ,0x10 }, +/* qdisc */ + {"qdisc_dequeue" ,0x1000 }, +/* rxrpc */ + {"rxrpc_recvdata" ,0x1 }, + {"rxrpc_resend" ,0x10 }, +/* sunrpc */ + {"xs_stream_read_data" ,0x1 }, +/* ... from xprt_cong_event event class */ + {"xprt_reserve_cong" ,0x10 }, + {"xprt_release_cong" ,0x10 }, + {"xprt_get_cong" ,0x10 }, + {"xprt_put_cong" ,0x10 }, +/* tcp */ + {"tcp_send_reset" ,0x11 }, +/* tegra_apb_dma */ + {"tegra_dma_tx_status" ,0x100 }, +/* timer_migration */ + {"tmigr_update_events" ,0x1 }, +/* writeback, from writeback_folio_template event class */ + {"writeback_dirty_folio" ,0x10 }, + {"folio_wait_writeback" ,0x10 }, +/* rdma */ + {"mr_integ_alloc" ,0x2000 }, +/* bpf_testmod */ + {"bpf_testmod_test_read" ,0x0 }, +}; +bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)
@@ -6449,6 +6544,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,const char *tname = prog->aux->attach_func_name;struct bpf_verifier_log *log = info->log;const struct btf_param *args; +bool ptr_err_raw_tp = false;const char *tag_value;u32 nr_args, arg;int i, ret;
@@ -6597,6 +6693,39 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,if (btf_param_match_suffix (btf, &args[arg],"__nullable" )) info->reg_type |=PTR_MAYBE_NULL ; +if (prog->expected_attach_type ==BPF_TRACE_RAW_TP ) { +struct btf *btf = prog->aux->attach_btf; +const struct btf_type *t; +const char *tname; + +/* BTF lookups cannot fail, return false on error */ + t =btf_type_by_id (btf, prog->aux->attach_btf_id); +if (!t) +return false; + tname =btf_name_by_offset (btf, t->name_off); +if (!tname) +return false; +/* Checked by bpf_check_attach_target */ + tname +=sizeof ("bpf_trace_" ) -1 ; +for (i =0 ; i <ARRAY_SIZE (raw_tp_null_args); i++) { +/* Is this a func with potential NULL args? */ +if (strcmp (tname, raw_tp_null_args[i].func)) +continue ; +if (raw_tp_null_args[i].mask & (0x1 << (arg *4 ))) + info->reg_type |=PTR_MAYBE_NULL ; +/* Is the current arg IS_ERR? */ +if (raw_tp_null_args[i].mask & (0x2 << (arg *4 ))) + ptr_err_raw_tp = true; +break ; + } +/* If we don't know NULL-ness specification and the tracepoint +* is coming from a loadable module, be conservative and mark +* argument as PTR_MAYBE_NULL. +*/ +if (i ==ARRAY_SIZE (raw_tp_null_args) &&btf_is_module (btf)) + info->reg_type |=PTR_MAYBE_NULL ; + } +if (tgt_prog) {enum bpf_prog_type tgt_type;
@@ -6641,6 +6770,13 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,bpf_log (log,"func '%s' arg%d has btf_id %d type %s '%s'\n" , tname, arg, info->btf_id,btf_type_str (t),__btf_name_by_offset (btf, t->name_off)); + +/* Perform all checks on the validity of type for this argument, but if +* we know it can be IS_ERR at runtime, scrub pointer type and mark as +* scalar. +*/ +if (ptr_err_raw_tp) + info->reg_type =SCALAR_VALUE ;return true; }EXPORT_SYMBOL_GPL (btf_ctx_access);
tools/testing/selftests/bpf/progs/raw_tp_null.c +9 -10
@@ -3,6 +3,7 @@#include <vmlinux.h> #include <bpf/bpf_tracing.h> +#include "bpf_misc.h" char _license[] SEC("license") = "GPL";
@@ -17,16 +18,14 @@ int BPF_PROG(test_raw_tp_null, struct sk_buff *skb)if (task->pid != tid)return 0 ; - i = i + skb->mark +1 ; -/* The compiler may move the NULL check before this deref, which causes -* the load to fail as deref of scalar. Prevent that by using a barrier. +/* If dead code elimination kicks in, the increment +=2 will be +* removed. For raw_tp programs attaching to tracepoints in kernel +* modules, we mark input arguments as PTR_MAYBE_NULL, so branch +* prediction should never kick in. */ -barrier (); -/* If dead code elimination kicks in, the increment below will -* be removed. For raw_tp programs, we mark input arguments as -* PTR_MAYBE_NULL, so branch prediction should never kick in. -*/ -if (!skb) - i +=2 ; + asmvolatile ("%[i] += 1; if %[ctx] != 0 goto +1; %[i] += 2;" + : [i]"+r" (i) + : [ctx]"r" (skb) + :"memory" );return 0 ; }
Signature · 1 line
2.43.5
Re: [PATCH bpf v2 2/3] bpf: Augment raw_tp arguments with PTR_MAYBE_NULL
Quoted 56 lines · Kumar Kartikeya Dwivedi
Arguments to a raw tracepoint are tagged as trusted, which carries the semantics that the pointer will be non-NULL. However, in certain cases, a raw tracepoint argument may end up being NULL. More context about this issue is available in [0].
Thus, there is a discrepancy between the reality, that
raw_tparguments can actually be NULL, and the verifier's knowledge, that they are never NULL, causing explicit NULL check branch to be dead code eliminated.A previous attempt [1], i.e. the second fixed commit, was made to simulate symbolic execution as if in most accesses, the argument is a non-NULL
raw_tp, except for conditional jumps. This tried to suppress branch prediction while preserving compatibility, but surfaced issues with production programs that were difficult to solve without increasing verifier complexity. A more complete discussion of issues and fixes is available at [2].Fix this by maintaining an explicit list of tracepoints where the arguments are known to be NULL, and mark the positional arguments as
PTR_MAYBE_NULL. Additionally, capture the tracepoints where arguments are known to beERR_PTR, and mark these arguments as scalar values to prevent potential dereference.Each hex digit is used to encode NULL-ness (
0x1) or ERR_PTR-ness (0x2), shifted by the zero-indexed argument number x 4. This can be represented as follows:
1st arg:0x1
2nd arg:0x10
3rd arg:0x100
... and so on (likewise forERR_PTRcase).In the future, an automated pass will be used to produce such a list, or insert
__nullableannotations automatically for tracepoints. Each compilation unit will be analyzed and results will be collated to find whether a tracepoint pointer is definitely not null, maybe null, or an unknown state where verifier conservatively marks itPTR_MAYBE_NULL. A proof of concept of this tool from Eduard is available at [3].Note that in case we don't find a specification in the
raw_tp_null_argsarray and the tracepoint belongs to a kernel module, we will conservatively mark the arguments asPTR_MAYBE_NULL. This is because unlike for in-tree modules, out-of-tree module tracepoints may pass NULL freely to the tracepoint. We don't protect against such tracepoints passingERR_PTR(which is uncommon anyway), lest we mark all such arguments asSCALAR_VALUE.While we are it, let's adjust the test
raw_tp_nullto not perform dereference of theskb->mark, as that won't be allowed anymore, and make it more robust by using inline assembly to test the dead code elimination behavior, which should still stay the same.[0]: https://lore.kernel.org/bpf/[email protected]
[1]: https://lore.kernel.org/all/[email protected]
[2]: https://lore.kernel.org/bpf/[email protected]
[3]: https://github.com/eddyz87/llvm-project/tree/nullness-for-tracepoint-params
Quoted 8 lines
Reported-by Juri Lelli <[email protected]> # original bugFixes 3f00c5239344 ("bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs")Fixes cb4158ce8ec8 ("bpf: Mark raw_tp arguments with PTR_MAYBE_NULL")Co-developed-by Jiri Olsa <[email protected]>Signed-off-by Jiri Olsa <[email protected]>Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>---
Tbh, I think we should have fixed the bug in what is currently in the tree and avoid revert. Anyways, the code looks good to me.
[...]
Quoted 8 lines
kernel/bpf/btf.c +4
-0@@ -6597,6 +6693,39 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,if (btf_param_match_suffix (btf, &args[arg],"__nullable" )) info->reg_type |=PTR_MAYBE_NULL ; +if (prog->expected_attach_type ==BPF_TRACE_RAW_TP ) { +struct btf *btf = prog->aux->attach_btf; +const struct btf_type *t; +const char *tname;
kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 6709
Quoted 10 lines
kernel/bpf/btf.c +10
-0+ +/* BTF lookups cannot fail, return false on error */ + t =btf_type_by_id (btf, prog->aux->attach_btf_id); +if (!t) +return false; + tname =btf_name_by_offset (btf, t->name_off); +if (!tname) +return false; +/* Checked by bpf_check_attach_target */ + tname +=sizeof ("bpf_trace_" ) -1 ;
Nit: bpf_check_attach_target uses "btf_trace_" prefix.
Quoted 23 lines
kernel/bpf/btf.c +19
-0+for (i =0 ; i <ARRAY_SIZE (raw_tp_null_args); i++) { +/* Is this a func with potential NULL args? */ +if (strcmp (tname, raw_tp_null_args[i].func)) +continue ; +if (raw_tp_null_args[i].mask & (0x1 << (arg *4 ))) + info->reg_type |=PTR_MAYBE_NULL ; +/* Is the current arg IS_ERR? */ +if (raw_tp_null_args[i].mask & (0x2 << (arg *4 ))) + ptr_err_raw_tp = true; +break ; + } +/* If we don't know NULL-ness specification and the tracepoint +* is coming from a loadable module, be conservative and mark +* argument as PTR_MAYBE_NULL. +*/ +if (i ==ARRAY_SIZE (raw_tp_null_args) &&btf_is_module (btf)) + info->reg_type |=PTR_MAYBE_NULL ; + } +if (tgt_prog) {enum bpf_prog_type tgt_type;
kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 6779
Quoted 10 lines
kernel/bpf/btf.c +7
-0@@ -6641,6 +6770,13 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,bpf_log (log,"func '%s' arg%d has btf_id %d type %s '%s'\n" , tname, arg, info->btf_id,btf_type_str (t),__btf_name_by_offset (btf, t->name_off)); + +/* Perform all checks on the validity of type for this argument, but if +* we know it can be IS_ERR at runtime, scrub pointer type and mark as +* scalar. +*/ +if (ptr_err_raw_tp) + info->reg_type =SCALAR_VALUE ;
Nit: the log line above would be a bit confusing if 'ptr_err_raw_tp' would be true.
maybe add an additional line here, saying that verifier overrides BTF type?
Quoted 3 lines
kernel/bpf/btf.c +0
-0return true; }EXPORT_SYMBOL_GPL (btf_ctx_access);
[...]
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf v2 2/3] bpf: Augment raw_tp arguments with PTR_MAYBE_NULL
Quoted 67 lines · Eduard Zingerman
Quoted 56 lines · Kumar Kartikeya Dwivedi
Arguments to a raw tracepoint are tagged as trusted, which carries the semantics that the pointer will be non-NULL. However, in certain cases, a raw tracepoint argument may end up being NULL. More context about this issue is available in [0].
Thus, there is a discrepancy between the reality, that
raw_tparguments can actually be NULL, and the verifier's knowledge, that they are never NULL, causing explicit NULL check branch to be dead code eliminated.A previous attempt [1], i.e. the second fixed commit, was made to simulate symbolic execution as if in most accesses, the argument is a non-NULL
raw_tp, except for conditional jumps. This tried to suppress branch prediction while preserving compatibility, but surfaced issues with production programs that were difficult to solve without increasing verifier complexity. A more complete discussion of issues and fixes is available at [2].Fix this by maintaining an explicit list of tracepoints where the arguments are known to be NULL, and mark the positional arguments as
PTR_MAYBE_NULL. Additionally, capture the tracepoints where arguments are known to beERR_PTR, and mark these arguments as scalar values to prevent potential dereference.Each hex digit is used to encode NULL-ness (
0x1) or ERR_PTR-ness (0x2), shifted by the zero-indexed argument number x 4. This can be represented as follows:
1st arg:0x1
2nd arg:0x10
3rd arg:0x100
... and so on (likewise forERR_PTRcase).In the future, an automated pass will be used to produce such a list, or insert
__nullableannotations automatically for tracepoints. Each compilation unit will be analyzed and results will be collated to find whether a tracepoint pointer is definitely not null, maybe null, or an unknown state where verifier conservatively marks itPTR_MAYBE_NULL. A proof of concept of this tool from Eduard is available at [3].Note that in case we don't find a specification in the
raw_tp_null_argsarray and the tracepoint belongs to a kernel module, we will conservatively mark the arguments asPTR_MAYBE_NULL. This is because unlike for in-tree modules, out-of-tree module tracepoints may pass NULL freely to the tracepoint. We don't protect against such tracepoints passingERR_PTR(which is uncommon anyway), lest we mark all such arguments asSCALAR_VALUE.While we are it, let's adjust the test
raw_tp_nullto not perform dereference of theskb->mark, as that won't be allowed anymore, and make it more robust by using inline assembly to test the dead code elimination behavior, which should still stay the same.[0]: https://lore.kernel.org/bpf/[email protected]
[1]: https://lore.kernel.org/all/[email protected]
[2]: https://lore.kernel.org/bpf/[email protected]
[3]: https://github.com/eddyz87/llvm-project/tree/nullness-for-tracepoint-paramsQuoted 8 lines
Reported-by Juri Lelli <[email protected]> # original bugFixes 3f00c5239344 ("bpf: Allow trusted pointers to be passed to KF_TRUSTED_ARGS kfuncs")Fixes cb4158ce8ec8 ("bpf: Mark raw_tp arguments with PTR_MAYBE_NULL")Co-developed-by Jiri Olsa <[email protected]>Signed-off-by Jiri Olsa <[email protected]>Signed-off-by Kumar Kartikeya Dwivedi <[email protected]>---
Quoted 5 lines
Tbh, I think we should have fixed the bug in what is currently in the tree and avoid revert. Anyways, the code looks good to me.
Reviewed-by Eduard Zingerman <[email protected]>
Thanks for the review, I have addressed the nits and resent v3.
Quoted 66 lines
[...]
Quoted 8 lines
kernel/bpf/btf.c +4
-0@@ -6597,6 +6693,39 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,if (btf_param_match_suffix (btf, &args[arg],"__nullable" )) info->reg_type |=PTR_MAYBE_NULL ; +if (prog->expected_attach_type ==BPF_TRACE_RAW_TP ) { +struct btf *btf = prog->aux->attach_btf; +const struct btf_type *t; +const char *tname;kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 6709
Quoted 10 lines
kernel/bpf/btf.c +10
-0+ +/* BTF lookups cannot fail, return false on error */ + t =btf_type_by_id (btf, prog->aux->attach_btf_id); +if (!t) +return false; + tname =btf_name_by_offset (btf, t->name_off); +if (!tname) +return false; +/* Checked by bpf_check_attach_target */ + tname +=sizeof ("bpf_trace_" ) -1 ;Nit:
bpf_check_attach_targetuses "btf_trace_" prefix.Quoted 23 lines
kernel/bpf/btf.c +19
-0+for (i =0 ; i <ARRAY_SIZE (raw_tp_null_args); i++) { +/* Is this a func with potential NULL args? */ +if (strcmp (tname, raw_tp_null_args[i].func)) +continue ; +if (raw_tp_null_args[i].mask & (0x1 << (arg *4 ))) + info->reg_type |=PTR_MAYBE_NULL ; +/* Is the current arg IS_ERR? */ +if (raw_tp_null_args[i].mask & (0x2 << (arg *4 ))) + ptr_err_raw_tp = true; +break ; + } +/* If we don't know NULL-ness specification and the tracepoint +* is coming from a loadable module, be conservative and mark +* argument as PTR_MAYBE_NULL. +*/ +if (i ==ARRAY_SIZE (raw_tp_null_args) &&btf_is_module (btf)) + info->reg_type |=PTR_MAYBE_NULL ; + } +if (tgt_prog) {enum bpf_prog_type tgt_type;kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 6779
Quoted 10 lines
kernel/bpf/btf.c +7
-0@@ -6641,6 +6770,13 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,bpf_log (log,"func '%s' arg%d has btf_id %d type %s '%s'\n" , tname, arg, info->btf_id,btf_type_str (t),__btf_name_by_offset (btf, t->name_off)); + +/* Perform all checks on the validity of type for this argument, but if +* we know it can be IS_ERR at runtime, scrub pointer type and mark as +* scalar. +*/ +if (ptr_err_raw_tp) + info->reg_type =SCALAR_VALUE ;Nit: the log line above would be a bit confusing if '
ptr_err_raw_tp' would be true.
maybe add an additional line here, saying that verifier overrides BTF type?Quoted 3 lines
kernel/bpf/btf.c +0
-0return true; }EXPORT_SYMBOL_GPL (btf_ctx_access);[...]
Kumar Kartikeya Dwivedi
maintainerPATCH v2 3/3 selftests/bpf: Add tests for raw_tp NULL args
In reply to Kumar Kartikeya DwivediAdd tests to ensure that arguments are correctly marked based on their specified positions, and whether they get marked correctly as maybe null. For modules, all tracepoint parameters should be marked PTR_MAYBE_NULL by default.
--- .../selftests/bpf/prog_tests/raw_tp_null.c | 3 +++ .../selftests/bpf/progs/raw_tp_null_fail.c | 24 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/raw_tp_null_fail.c
tools/testing/selftests/bpf/prog_tests/raw_tp_null.c +3 -0
@@ -3,11 +3,14 @@#include <test_progs.h> #include "raw_tp_null.skel.h" +#include "raw_tp_null_fail.skel.h" void test_raw_tp_null (void ) {struct raw_tp_null *skel; +RUN_TESTS (raw_tp_null_fail); + skel =raw_tp_null__open_and_load ();if (!ASSERT_OK_PTR (skel,"raw_tp_null__open_and_load" ))return ;
tools/testing/selftests/bpf/progs/raw_tp_null_fail.c new file +24 -0
@@ -0,0 +1,24 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */ + +#include <vmlinux.h> +#include <bpf/bpf_tracing.h> +#include "bpf_misc.h" + +char _license[] SEC("license") = "GPL"; + +/* Ensure module parameter has PTR_MAYBE_NULL */ +SEC("tp_btf/bpf_testmod_test_raw_tp_null") +__failure __msg("R1 invalid mem access 'trusted_ptr_or_null_'") +int test_raw_tp_null_bpf_testmod_test_raw_tp_null_arg_1(void *ctx) { + asm volatile("r1 = *(u64 *)(r1 +0); r1 = *(u64 *)(r1 +0);" ::: __clobber_all); +return 0 ; +} + +/* Check NULL marking */ +SEC("tp_btf/sched_pi_setprio") +__failure __msg("R1 invalid mem access 'trusted_ptr_or_null_'") +int test_raw_tp_null_sched_pi_setprio_arg_2(void *ctx) { + asm volatile("r1 = *(u64 *)(r1 +8); r1 = *(u64 *)(r1 +0);" ::: __clobber_all); +return 0 ; +}
Signature · 1 line
2.43.5