writable contexts for bpf raw tracepoints
Subsystems (12)
v3 cover writable contexts for bpf raw tracepoints
This adds an opt-in interface for tracepoints to expose a writable context to BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE programs that are attached, while supporting read-only access from existing BPF_PROG_TYPE_RAW_TRACEPOINT programs, as well as from non-BPF-based tracepoints.
The initial motivation is to support tracing that can be observed from the remote end of an NBD socket, e.g. by adding flags to the struct nbd_request header. Earlier attempts included adding an NBD-specific tracepoint fd, but in code review, I was recommended to implement it more generically -- as a result, this patchset is far simpler than my initial try.
v2->v3:
* Andrew addressed Josef's comments:
* C-style commenting in nbd.c
* Collapsed identical events into a single DECLARE_EVENT_CLASS. This saves about 2kB of kernel text
v1->v2:
* add selftests
* sync tools/include/uapi/linux/bpf.h
* reject variable offset into the buffer
* add string representation of PTR_TO_TP_BUFFER to reg_type_str
Andrew Hall (1):
nbd: add tracepoints for send/receive timing
Matt Mullins (4):
bpf: add writable context for raw tracepoints
nbd: trace sending nbd requests
tools: sync bpf.h
selftests: bpf: test writable buffers in raw tps
MAINTAINERS | 1 + drivers/block/nbd.c | 13 +++ include/linux/bpf.h | 2 + include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 ++++- include/trace/events/bpf_test_run.h | 50 ++++++++ include/trace/events/nbd.h | 107 ++++++++++++++++++ include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 +- kernel/bpf/verifier.c | 31 +++++ kernel/trace/bpf_trace.c | 21 ++++ net/bpf/test_run.c | 4 + tools/include/uapi/linux/bpf.h | 1 + tools/lib/bpf/libbpf.c | 1 + tools/lib/bpf/libbpf_probes.c | 1 + .../raw_tp_writable_reject_nbd_invalid.c | 40 +++++++ .../bpf/prog_tests/raw_tp_writable_test_run.c | 80 +++++++++++++ .../selftests/bpf/verifier/raw_tp_writable.c | 34 ++++++ 19 files changed, 420 insertions(+), 4 deletions(-) create mode 100644 include/trace/events/bpf_test_run.h create mode 100644 include/trace/events/nbd.h create mode 100644 tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c create mode 100644 tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c create mode 100644 tools/testing/selftests/bpf/verifier/raw_tp_writable.c
Signature · 1 line
2.17.1
PATCH v3 1/5 bpf: add writable context for raw tracepoints
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a BPF_PROG_TYPE_RAW_TRACEPOINT program. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.
The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both BPF_PROG_TYPE_RAW_TRACEPOINT and BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE programs that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.
--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)
include/linux/bpf.h +2 -0
@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };/* The information passed from prog-specific *_is_valid_access
@@ -352,6 +353,7 @@ struct bpf_prog_aux {u32 used_map_cnt;u32 max_ctx_offset;u32 max_pkt_offset; +u32 max_tp_access;u32 stack_depth;u32 id;u32 func_cnt;/* used by non-func prog as the number of func progs */
include/linux/bpf_types.h +1 -0
@@ -25,6 +25,7 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_KPROBE, kprobe) BPF_PROG_TYPE(BPF_PROG_TYPE_TRACEPOINT, tracepoint) BPF_PROG_TYPE(BPF_PROG_TYPE_PERF_EVENT, perf_event) BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT, raw_tracepoint) +BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, raw_tracepoint_writable)#endif #ifdef CONFIG_CGROUP_BPF BPF_PROG_TYPE (BPF_PROG_TYPE_CGROUP_DEVICE , cg_dev)
include/linux/tracepoint-defs.h +1 -0
@@ -45,6 +45,7 @@ struct bpf_raw_event_map {struct tracepoint *tp;void *bpf_func;u32 num_args; + u32 writable_size; }__aligned(32) ;#endif
include/trace/bpf_probe.h +25 -2
@@ -69,8 +69,7 @@ __bpf_trace_##call(void *__data, proto) \* to make sure that if the tracepoint handling changes, the * bpf probe will fail to compile unless it too is updated. */ -#undef DEFINE_EVENT -#define DEFINE_EVENT (template, call, proto, args) \ +#define __DEFINE_EVENT (template, call, proto, args, size) \ static inline void bpf_test_probe_##call(void) \ { \ check_trace_callback_type_##call(__bpf_trace_##template); \
@@ -81,12 +80,36 @@ __bpf_trace_tp_map_##call = { \ .tp = &__tracepoint_##call, \ .bpf_func = (void *)__bpf_trace_##template, \ .num_args = COUNT_ARGS(args), \ + .writable_size = size, \ }; +#define FIRST (x, ...) x + +#undef DEFINE_EVENT_WRITABLE +#define DEFINE_EVENT_WRITABLE (template, call, proto, args, size) \ +static inline void bpf_test_buffer_##call(void) \ +{ \ +/* BUILD_BUG_ON() is ignored if the code is completely eliminated, but \ +* BUILD_BUG_ON_ZERO() uses a different mechanism that is not \ +* dead-code-eliminated. \ +*/ \ +FIRST (proto); \ + (void )BUILD_BUG_ON_ZERO (size !=sizeof (*FIRST (args))); \ +} \ +__DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args), size) + +#undef DEFINE_EVENT +#define DEFINE_EVENT (template, call, proto, args) \ + __DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args), 0)#undef DEFINE_EVENT_PRINT#define DEFINE_EVENT_PRINT (template, name, proto, args, print) \ DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))#include TRACE_INCLUDE (TRACE_INCLUDE_FILE ) + +#undef DEFINE_EVENT_WRITABLE +#undef __DEFINE_EVENT +#undef FIRST +#endif /* CONFIG_BPF_EVENTS */
include/uapi/linux/bpf.h +1 -0
@@ -166,6 +166,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LIRC_MODE2 ,BPF_PROG_TYPE_SK_REUSEPORT ,BPF_PROG_TYPE_FLOW_DISSECTOR , + BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, }; enum bpf_attach_type {
kernel/bpf/syscall.c +6 -2
@@ -1720,12 +1720,16 @@ static int bpf_raw_tracepoint_open(const union bpf_attr *attr) } raw_tp->btp = btp; - prog =bpf_prog_get_type (attr->raw_tracepoint.prog_fd, -BPF_PROG_TYPE_RAW_TRACEPOINT ); + prog =bpf_prog_get (attr->raw_tracepoint.prog_fd);if (IS_ERR (prog)) { err =PTR_ERR (prog); goto out_free_tp; } +if (prog->type !=BPF_PROG_TYPE_RAW_TRACEPOINT && + prog->type !=BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE ) { + err = -EINVAL ; + goto out_put_prog; + } err =bpf_probe_register (raw_tp->btp, prog);if (err)
kernel/bpf/verifier.c +31 -0
@@ -411,6 +411,7 @@ static const char * const reg_type_str[] = { [PTR_TO_SOCK_COMMON_OR_NULL] = "sock_common_or_null", [PTR_TO_TCP_SOCK] = "tcp_sock", [PTR_TO_TCP_SOCK_OR_NULL] = "tcp_sock_or_null", + [PTR_TO_TP_BUFFER] = "tp_buffer", };static char slot_type_char[] = {
@@ -1958,6 +1959,32 @@ static int check_ctx_reg(struct bpf_verifier_env *env,return 0 ; } +static int check_tp_buffer_access (struct bpf_verifier_env *env, +const struct bpf_reg_state *reg, +int regno,int off,int size) +{ +if (off <0 ) { +verbose (env, +"R%d invalid tracepoint buffer access: off=%d, size=%d" , + regno, off, size); +return -EACCES ; + } +if (!tnum_is_const (reg->var_off) || reg->var_off.value) { +char tn_buf[48 ]; + +tnum_strn (tn_buf,sizeof (tn_buf), reg->var_off); +verbose (env, +"R%d invalid variable buffer offset: off=%d, var_off=%s" , + regno, off, tn_buf); +return -EACCES ; + } +if (off + size > env->prog->aux->max_tp_access) + env->prog->aux->max_tp_access = off + size; + +return 0 ; +} + +/* truncate register to smaller size (in bytes) * must be called with size < BPF_REG_SIZE */
@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);
kernel/trace/bpf_trace.c +21 -0
@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { }; +static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ; +return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)
@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
Signature · 1 line
2.17.1
Re: [PATCH bpf-next v3 1/5] bpf: add writable context for raw tracepoints
Quoted 35 lines · Matt Mullins
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a
BPF_PROG_TYPE_RAW_TRACEPOINTprogram. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both
BPF_PROG_TYPE_RAW_TRACEPOINTandBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEprograms that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.Signed-off-by Matt Mullins <[email protected]>--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)include/linux/bpf.h +1
-0@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };
[...]
Quoted 19 lines
/* truncate register to smaller size (in bytes)
* must be called with size <BPF_REG_SIZE
*/include/linux/bpf.h +4
-0@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);kernel/trace/bpf_trace.c +0
-0
kernel/trace/bpf_trace.c const struct bpf_verifier_ops raw_tracepoint_verifier_ops = { · line 918
Quoted 10 lines
kernel/trace/bpf_trace.c +7
-0@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { }; +static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ;
on 32bit system, the first argument pointer size could be sizeof(u32)? Should the first argument for raw_tp_writable_prog be always PTR_TO_TP_BUFFER?
Quoted 25 lines
kernel/trace/bpf_trace.c +14
-0+return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
Re: [PATCH bpf-next v3 1/5] bpf: add writable context for raw tracepoints
Quoted 61 lines · Yonghong Song
Quoted 35 lines · Matt Mullins
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a
BPF_PROG_TYPE_RAW_TRACEPOINTprogram. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both
BPF_PROG_TYPE_RAW_TRACEPOINTandBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEprograms that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.Signed-off-by Matt Mullins <[email protected]>--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)include/linux/bpf.h +1
-0@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };[...]
Quoted 22 lines
/* truncate register to smaller size (in bytes)
* must be called with size <BPF_REG_SIZE
*/include/linux/bpf.h +4
-0@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);kernel/trace/bpf_trace.c +0
-0@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { };
Quoted 9 lines
kernel/trace/bpf_trace.c const struct bpf_verifier_ops raw_tracepoint_verifier_ops = { · line 918
Quoted 7 lines
kernel/trace/bpf_trace.c +7
-0+static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ;on 32bit system, the first argument pointer size could be sizeof(u32)?
As far as I can tell, pointers are always 64 bits wide from the perspective of the eBPF instruction set. I think the proper fixup is in include/trace/events/nbd.h ... I should use a u64 instead of a pointer type.
Quoted 2 lines
Should the first argument for
raw_tp_writable_progbe alwaysPTR_TO_TP_BUFFER?
That is the purpose of this patch series, yes. My initial attempt at this tried to add it to the end of the context structure instead, and that ended up being quite complex to track.
Quoted 26 lines
Quoted 26 lines
kernel/trace/bpf_trace.c +14
-0+return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
Re: [PATCH bpf-next v3 1/5] bpf: add writable context for raw tracepoints
Quoted 72 lines · Matt Mullins
Quoted 61 lines · Yonghong Song
Quoted 35 lines · Matt Mullins
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a
BPF_PROG_TYPE_RAW_TRACEPOINTprogram. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both
BPF_PROG_TYPE_RAW_TRACEPOINTandBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEprograms that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.Signed-off-by Matt Mullins <[email protected]>--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)include/linux/bpf.h +1
-0@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };[...]
Quoted 22 lines
/* truncate register to smaller size (in bytes) * must be called with size < BPF_REG_SIZE */include/linux/bpf.h +4
-0@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);kernel/trace/bpf_trace.c +0
-0@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { };Quoted 9 lines
kernel/trace/bpf_trace.c const struct bpf_verifier_ops raw_tracepoint_verifier_ops = { · line 918
Quoted 7 lines
kernel/trace/bpf_trace.c +7
-0+static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ;on 32bit system, the first argument pointer size could be sizeof(u32)?
Quoted 4 lines
As far as I can tell, pointers are always 64 bits wide from the perspective of the eBPF instruction set. I think the proper fixup is in
include/trace/events/nbd.h... I should use a u64 instead of a pointer type.
u64 is okay. You may want to double check tracepoint definition to ensure the assign to the first argument converting to u64 as well to avoid potential garbage. It would be good if this is enforced during compilation time.
Quoted 7 lines
Quoted 3 lines
Should the first argument for
raw_tp_writable_progbe alwaysPTR_TO_TP_BUFFER?That is the purpose of this patch series, yes. My initial attempt at this tried to add it to the end of the context structure instead, and that ended up being quite complex to track.
So size == sizeof(u64) can be removed, off == 0 just implies reg_type PTR_TO_TP_BUFFER?
Quoted 27 lines
Quoted 27 lines
Quoted 27 lines
kernel/trace/bpf_trace.c +14
-0+return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
Re: [PATCH bpf-next v3 1/5] bpf: add writable context for raw tracepoints
Quoted 79 lines · Yonghong Song
Quoted 72 lines · Matt Mullins
Quoted 61 lines · Yonghong Song
Quoted 35 lines · Matt Mullins
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a
BPF_PROG_TYPE_RAW_TRACEPOINTprogram. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both
BPF_PROG_TYPE_RAW_TRACEPOINTandBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEprograms that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.Signed-off-by Matt Mullins <[email protected]>--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)include/linux/bpf.h +1
-0@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };[...]
Quoted 22 lines
/* truncate register to smaller size (in bytes) * must be called with size < BPF_REG_SIZE */include/linux/bpf.h +4
-0@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);kernel/trace/bpf_trace.c +0
-0@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { };Quoted 9 lines
kernel/trace/bpf_trace.c const struct bpf_verifier_ops raw_tracepoint_verifier_ops = { · line 918
Quoted 7 lines
kernel/trace/bpf_trace.c +7
-0+static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ;on 32bit system, the first argument pointer size could be sizeof(u32)?
Quoted 4 lines
As far as I can tell, pointers are always 64 bits wide from the perspective of the eBPF instruction set. I think the proper fixup is in
include/trace/events/nbd.h... I should use a u64 instead of a pointer type.
Quoted 4 lines
u64 is okay. You may want to double check tracepoint definition to ensure the assign to the first argument converting to u64 as well to avoid potential garbage. It would be good if this is enforced during compilation time.
Now that I've looked into this further, this is already handled in include/trace/bpf_probe.h:
#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \
static notrace void \
__bpf_trace_##call(void *__data, proto) \
{ \
struct bpf_prog *prog = __data; \
CONCATENATE(bpf_trace_run, COUNT_ARGS(args))(prog, CAST_TO_U64(args)); \
}The 32-bit value of the struct nbd_request pointer will be zero- extended to 64-bits before the BPF program sees it, so there won't be any garbage in the upper half of the register. I'm going to leave the trace_* functions taking the pointer as-is, so that I can keep the compile-time checks that writable_size == sizeof(*first_argument).
Quoted 9 lines
Quoted 6 lines
Quoted 2 lines
Should the first argument for
raw_tp_writable_progbe alwaysPTR_TO_TP_BUFFER?That is the purpose of this patch series, yes. My initial attempt at this tried to add it to the end of the context structure instead, and that ended up being quite complex to track.
So
size == sizeof(u64)can be removed, off == 0 just impliesreg_typePTR_TO_TP_BUFFER?
I can't get rid of the size check, because I can emit an opcode like
0: (71) r6 = *(u8 *)(r1 +0)
and I don't want to accidentally mark a value as PTR_TO_TP_BUFFER unless it is a whole, valid pointer.
Quoted 25 lines
Quoted 25 lines
Quoted 25 lines
Quoted 25 lines
kernel/trace/bpf_trace.c +14
-0+return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
Re: [PATCH bpf-next v3 1/5] bpf: add writable context for raw tracepoints
Quoted 113 lines · Matt Mullins
Quoted 79 lines · Yonghong Song
Quoted 72 lines · Matt Mullins
Quoted 61 lines · Yonghong Song
Quoted 35 lines · Matt Mullins
This is an opt-in interface that allows a tracepoint to provide a safe buffer that can be written from a
BPF_PROG_TYPE_RAW_TRACEPOINTprogram. The size of the buffer must be a compile-time constant, and is checked before allowing a BPF program to attach to a tracepoint that uses this feature.The pointer to this buffer will be the first argument of tracepoints that opt in; the buffer is readable by both
BPF_PROG_TYPE_RAW_TRACEPOINTandBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEprograms that attach to such a tracepoint, but the buffer to which it points may only be written by the latter.Signed-off-by Matt Mullins <[email protected]>--- include/linux/bpf.h | 2 ++ include/linux/bpf_types.h | 1 + include/linux/tracepoint-defs.h | 1 + include/trace/bpf_probe.h | 27 +++++++++++++++++++++++++-- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 8 ++++++-- kernel/bpf/verifier.c | 31 +++++++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 21 +++++++++++++++++++++ 8 files changed, 88 insertions(+), 4 deletions(-)include/linux/bpf.h +1
-0@@ -263,6 +263,7 @@ enum bpf_reg_type {PTR_TO_SOCK_COMMON_OR_NULL ,/* reg points to sock_common or NULL */ PTR_TO_TCP_SOCK ,/* reg points to struct tcp_sock */ PTR_TO_TCP_SOCK_OR_NULL ,/* reg points to struct tcp_sock or NULL */ + PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */ };[...]
Quoted 22 lines
/* truncate register to smaller size (in bytes) * must be called with size < BPF_REG_SIZE */include/linux/bpf.h +4
-0@@ -2100,6 +2127,10 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_sock_access (env, insn_idx, regno, off, size, t);if (!err && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_TP_BUFFER ) { + err =check_tp_buffer_access (env, reg, regno, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);kernel/trace/bpf_trace.c +0
-0@@ -909,6 +909,24 @@ const struct bpf_verifier_ops raw_tracepoint_verifier_ops = {const struct bpf_prog_ops raw_tracepoint_prog_ops = { };Quoted 9 lines
kernel/trace/bpf_trace.c const struct bpf_verifier_ops raw_tracepoint_verifier_ops = { · line 918
Quoted 7 lines
kernel/trace/bpf_trace.c +7
-0+static bool raw_tp_writable_prog_is_valid_access (int off,int size, +enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off ==0 && size ==sizeof (u64)) + info->reg_type =PTR_TO_TP_BUFFER ;on 32bit system, the first argument pointer size could be sizeof(u32)?
Quoted 4 lines
As far as I can tell, pointers are always 64 bits wide from the perspective of the eBPF instruction set. I think the proper fixup is in
include/trace/events/nbd.h... I should use a u64 instead of a pointer type.Quoted 4 lines
u64 is okay. You may want to double check tracepoint definition to ensure the assign to the first argument converting to u64 as well to avoid potential garbage. It would be good if this is enforced during compilation time.
Now that I've looked into this further, this is already handled in
include/trace/bpf_probe.h:#undef
DECLARE_EVENT_CLASS
#defineDECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)\
static notrace void \
__bpf_trace_##call(void*__data, proto) \{ \ struct bpf_prog *prog = __data; \ CONCATENATE(bpf_trace_run, COUNT_ARGS(args))(prog, CAST_TO_U64(args)); \ }The 32-bit value of the struct
nbd_requestpointer will be zero- extended to 64-bits before the BPF program sees it, so there won't be any garbage in the upper half of the register. I'm going to leave the trace_* functions taking the pointer as-is, so that I can keep the compile-time checks thatwritable_size==sizeof(*first_argument).Quoted 9 lines
Quoted 6 lines
Quoted 2 lines
Should the first argument for
raw_tp_writable_progbe alwaysPTR_TO_TP_BUFFER?That is the purpose of this patch series, yes. My initial attempt at this tried to add it to the end of the context structure instead, and that ended up being quite complex to track.
So
size == sizeof(u64)can be removed, off == 0 just impliesreg_typePTR_TO_TP_BUFFER?
Quoted 6 lines
I can't get rid of the size check, because I can emit an opcode like
0: (71) r6 = *(u8 *)(r1 +0)and I don't want to accidentally mark a value as
PTR_TO_TP_BUFFERunless it is a whole, valid pointer.
We could reject if off == 0 && size != 8 to allow only whole pointer access. I cannot think that user will use r6 in a meaningful except the hash. But if you have a valid use case to permit such access, I am okay with that.
Quoted 26 lines
Quoted 26 lines
Quoted 26 lines
Quoted 26 lines
Quoted 26 lines
kernel/trace/bpf_trace.c +14
-0+return raw_tp_prog_is_valid_access (off, size, type, prog, info); +} + +const struct bpf_verifier_ops raw_tracepoint_writable_verifier_ops = { + .get_func_proto = raw_tp_prog_func_proto, + .is_valid_access = raw_tp_writable_prog_is_valid_access, +}; + +const struct bpf_prog_ops raw_tracepoint_writable_prog_ops = { +}; +static bool pe_prog_is_valid_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)@@ -1198,6 +1216,9 @@ static int __bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *if (prog->aux->max_ctx_offset > btp->num_args *sizeof (u64))return -EINVAL ; +if (prog->aux->max_tp_access > btp->writable_size) +return -EINVAL ; +return tracepoint_probe_register (tp, (void *)btp->bpf_func, prog); }
PATCH v3 2/5 nbd: trace sending nbd requests
In reply to Matt MullinsThis adds a tracepoint that can both observe the nbd request being sent to the server, as well as modify that request , e.g., setting a flag in the request that will cause the server to collect detailed tracing data.
The struct request * being handled is included to permit correlation with the block tracepoints.
--- MAINTAINERS | 1 + drivers/block/nbd.c | 5 ++++ include/trace/events/nbd.h | 56 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+) create mode 100644 include/trace/events/nbd.h
MAINTAINERS +1 -0
@@ -10737,6 +10737,7 @@ L: [email protected] L: [email protected] F: Documentation/blockdev/nbd.txt F: drivers/block/nbd.c +F: include/trace/events/nbd.h F: include/uapi/linux/nbd.h NETWORK DROP MONITOR
drivers/block/nbd.c +5 -0
@@ -44,6 +44,9 @@#include <linux/nbd-netlink.h> #include <net/genetlink.h> +#define CREATE_TRACE_POINTS +#include <trace/events/nbd.h> +static DEFINE_IDR (nbd_index_idr);static DEFINE_MUTEX (nbd_index_mutex);static int nbd_total_devices =0 ;
@@ -526,6 +529,8 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) handle =nbd_cmd_handle (cmd);memcpy (request.handle, &handle,sizeof (handle)); +trace_nbd_send_request (&request, nbd->index,blk_mq_rq_from_pdu (cmd)); +dev_dbg (nbd_to_dev (nbd),"request %p: sending control (%s@%llu,%uB)\n" , req,nbdcmd_to_ascii (type), (unsigned long long )blk_rq_pos (req) <<9 ,blk_rq_bytes (req));
include/trace/events/nbd.h new file +56 -0
56 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH bpf-next v3 2/5] nbd: trace sending nbd requests
Quoted 9 lines · Matt Mullins
This adds a tracepoint that can both observe the nbd request being sent to the server, as well as modify that request , e.g., setting a flag in the request that will cause the server to collect detailed tracing data.
The struct request * being handled is included to permit correlation with the block tracepoints.
Signed-off-by Matt Mullins <[email protected]>---
Thanks,
Josef
PATCH v3 3/5 nbd: add tracepoints for send/receive timing
In reply to Matt MullinsFrom: Andrew Hall <[email protected]>
This adds four tracepoints to nbd, enabling separate tracing of payload and header sending/receipt.
In the send path for headers that have already been sent, we also explicitly initialize the handle so it can be referenced by the later tracepoint.
--- drivers/block/nbd.c | 8 ++++++ include/trace/events/nbd.h | 51 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+)
drivers/block/nbd.c +8 -0
@@ -513,6 +513,10 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index)if (sent) {if (sent >=sizeof (request)) { skip = sent -sizeof (request); + +/* initialize handle for tracing purposes */ + handle =nbd_cmd_handle (cmd); + goto send_pages; }iov_iter_advance (&from, sent);
@@ -536,6 +540,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) (unsigned long long)blk_rq_pos(req) << 9, blk_rq_bytes(req)); result =sock_xmit (nbd, index,1 , &from, (type ==NBD_CMD_WRITE ) ?MSG_MORE :0 , &sent); +trace_nbd_header_sent (req, handle);if (result <=0 ) {if (was_interrupted (result)) {/* If we havne't sent anything we can just return BUSY,
@@ -608,6 +613,7 @@ static int nbd_send_cmd(struct nbd_device *nbd, struct nbd_cmd *cmd, int index) bio = next; } out: +trace_nbd_payload_sent (req, handle); nsock->pending =NULL ; nsock->sent =0 ;return 0 ;
@@ -655,6 +661,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index) tag, req);return ERR_PTR (-ENOENT ); } +trace_nbd_header_received (req, handle); cmd =blk_mq_rq_to_pdu (req);mutex_lock (&cmd->lock);
@@ -708,6 +715,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index) } } out: +trace_nbd_payload_received (req, handle);mutex_unlock (&cmd->lock);return ret ?ERR_PTR (ret) : cmd; }
include/trace/events/nbd.h +51 -0
57 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH bpf-next v3 3/5] nbd: add tracepoints for send/receive timing
Quoted 10 lines · Matt Mullins
From: Andrew Hall <[email protected]>
This adds four tracepoints to nbd, enabling separate tracing of payload and header sending/receipt.
In the send path for headers that have already been sent, we also explicitly initialize the handle so it can be referenced by the later tracepoint.
Signed-off-by Andrew Hall <[email protected]>
Thanks,
Josef
PATCH v3 4/5 tools: sync bpf.h
In reply to Matt MullinsThis adds BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, and fixes up the
error: enumeration value ‘BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE’ not handled in switch [-Werror=switch-enum]
build errors it would otherwise cause in libbpf.
--- tools/include/uapi/linux/bpf.h | 1 + tools/lib/bpf/libbpf.c | 1 + tools/lib/bpf/libbpf_probes.c | 1 + 3 files changed, 3 insertions(+)
tools/include/uapi/linux/bpf.h +1 -0
@@ -166,6 +166,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LIRC_MODE2 ,BPF_PROG_TYPE_SK_REUSEPORT ,BPF_PROG_TYPE_FLOW_DISSECTOR , + BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, }; enum bpf_attach_type {
tools/lib/bpf/libbpf.c +1 -0
@@ -1681,6 +1681,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)case BPF_PROG_TYPE_UNSPEC :case BPF_PROG_TYPE_TRACEPOINT :case BPF_PROG_TYPE_RAW_TRACEPOINT : +case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE :case BPF_PROG_TYPE_PERF_EVENT :return false;case BPF_PROG_TYPE_KPROBE :
tools/lib/bpf/libbpf_probes.c +1 -0
@@ -93,6 +93,7 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,case BPF_PROG_TYPE_CGROUP_DEVICE :case BPF_PROG_TYPE_SK_MSG :case BPF_PROG_TYPE_RAW_TRACEPOINT : +case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE :case BPF_PROG_TYPE_LWT_SEG6LOCAL :case BPF_PROG_TYPE_LIRC_MODE2 :case BPF_PROG_TYPE_SK_REUSEPORT :
Signature · 1 line
2.17.1
PATCH v3 5/5 selftests: bpf: test writable buffers in raw tps
In reply to Matt MullinsThis tests that:
* a BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE cannot be attached if it uses either:
* a variable offset to the tracepoint buffer, or
* an offset beyond the size of the tracepoint buffer
* a tracer can modify the buffer provided when attached to a writable tracepoint in bpf_prog_test_run
--- include/trace/events/bpf_test_run.h | 50 ++++++++++++ net/bpf/test_run.c | 4 + .../raw_tp_writable_reject_nbd_invalid.c | 40 ++++++++++ .../bpf/prog_tests/raw_tp_writable_test_run.c | 80 +++++++++++++++++++ .../selftests/bpf/verifier/raw_tp_writable.c | 34 ++++++++ 5 files changed, 208 insertions(+) create mode 100644 include/trace/events/bpf_test_run.h create mode 100644 tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c create mode 100644 tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c create mode 100644 tools/testing/selftests/bpf/verifier/raw_tp_writable.c
include/trace/events/bpf_test_run.h new file +50 -0
@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM bpf_test_run + +#if !defined(_TRACE_NBD_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_BPF_TEST_RUN_H + +#include <linux/tracepoint.h> + +DECLARE_EVENT_CLASS (bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +TP_STRUCT__entry ( +__field (int, err) + ), + +TP_fast_assign ( + __entry->err = *err; + ), + +TP_printk ("bpf_test_finish with err=%d" , __entry->err) +); + +#ifdef DEFINE_EVENT_WRITABLE +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT_WRITABLE(template, call, PARAMS(proto), \ + PARAMS(args), size) +#else +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args)) +#endif + +BPF_TEST_RUN_DEFINE_EVENT (bpf_test_finish, bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +sizeof (int ) +); + +#endif + +/* This part must be outside protection */ +#include <trace/define_trace.h>
net/bpf/test_run.c +4 -0
@@ -13,6 +13,9 @@#include <net/sock.h> #include <net/tcp.h> +#define CREATE_TRACE_POINTS +#include <trace/events/bpf_test_run.h> +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *retval,u32 *time) {
@@ -100,6 +103,7 @@ static int bpf_test_finish(const union bpf_attr *kattr,if (err != -ENOSPC ) err =0 ; out: +trace_bpf_test_finish (&err);return err; }
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +40 -0
@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h> + +void test_raw_tp_writable_reject_nbd_invalid (void ) +{ +__u32 duration =0 ; +char error[4096 ]; +int bpf_fd =-1 , tp_fd =-1 ; + +const struct bpf_insn program[] = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_DW ,BPF_REG_0 ,BPF_REG_6 ,128 ), +BPF_EXIT_INSN (), + }; + +struct bpf_load_program_attr load_attr = { + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .license ="GPL v2" , + .insns = program, + .insns_cnt =sizeof (program) /sizeof (struct bpf_insn ), + .log_level =2 , + }; + + bpf_fd =bpf_load_program_xattr (&load_attr, error,sizeof (error)); +if (CHECK (bpf_fd <0 ,"bpf_raw_tracepoint_writable loaded" , +"failed: %d errno %d\n" , bpf_fd, errno)) +return ; + + tp_fd =bpf_raw_tracepoint_open ("nbd_send_request" , bpf_fd); +if (CHECK (tp_fd >=0 ,"bpf_raw_tracepoint_writable opened" , +"erroneously succeeded\n" )) + goto out_bpffd; + +close (tp_fd); +out_bpffd: +close (bpf_fd); +}
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +80 -0
80 lines not on this page · raw message
tools/testing/selftests/bpf/verifier/raw_tp_writable.c new file +34 -0
@@ -0,0 +1,34 @@ +{ + "raw_tracepoint_writable: reject variable offset", + .insns = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), + +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +/* move the key (== 0) to r10-8 */ +BPF_MOV32_IMM (BPF_REG_0 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_0 ,0 ), +/* lookup in the map */ +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), + +/* exit clean if null */ +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), + +/* shift the buffer pointer to a variable location */ +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_0 ,0 ), +BPF_ALU64_REG (BPF_ADD ,BPF_REG_6 ,BPF_REG_0 ), +/* clobber whatever's there */ +BPF_MOV64_IMM (BPF_REG_7 ,4242 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_7 ,0 ), + +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_hash_8b = { 1, }, + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .errstr = "R6 invalid variable buffer offset: off=0, var_off=(0x0; 0xffffffff)", +},
Signature · 1 line
2.17.1
Re: [PATCH bpf-next v3 5/5] selftests: bpf: test writable buffers in raw tps
Quoted 110 lines · Matt Mullins
This tests that:
* aBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEcannot be attached if it uses either:
* a variable offset to the tracepoint buffer, or
* an offset beyond the size of the tracepoint buffer
* a tracer can modify the buffer provided when attached to a writable tracepoint inbpf_prog_test_runSigned-off-by Matt Mullins <mmullins at fb.com>--- include/trace/events/bpf_test_run.h | 50 ++++++++++++ net/bpf/test_run.c | 4 + .../raw_tp_writable_reject_nbd_invalid.c | 40 ++++++++++ .../bpf/prog_tests/raw_tp_writable_test_run.c | 80 +++++++++++++++++++ .../selftests/bpf/verifier/raw_tp_writable.c | 34 ++++++++ 5 files changed, 208 insertions(+)create mode 100644
include/trace/events/bpf_test_run.h
create mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.ccreate mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.ccreate mode 100644tools/testing/selftests/bpf/verifier/raw_tp_writable.cinclude/trace/events/bpf_test_run.h new file +50
-0@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM bpf_test_run + +#if !defined(_TRACE_NBD_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_BPF_TEST_RUN_H + +#include <linux/tracepoint.h> + +DECLARE_EVENT_CLASS (bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +TP_STRUCT__entry ( +__field (int, err) + ), + +TP_fast_assign ( + __entry->err = *err; + ), + +TP_printk ("bpf_test_finish with err=%d" , __entry->err) +); + +#ifdef DEFINE_EVENT_WRITABLE +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT_WRITABLE(template, call, PARAMS(proto), \ + PARAMS(args), size) +#else +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args)) +#endif + +BPF_TEST_RUN_DEFINE_EVENT (bpf_test_finish, bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +sizeof (int ) +); + +#endif + +/* This part must be outside protection */ +#include <trace/define_trace.h> net/bpf/test_run.c +4
-0@@ -13,6 +13,9 @@#include <net/sock.h> #include <net/tcp.h> +#define CREATE_TRACE_POINTS +#include <trace/events/bpf_test_run.h> +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *retval,u32 *time) {@@ -100,6 +103,7 @@ static int bpf_test_finish(const union bpf_attr *kattr,if (err != -ENOSPC ) err =0 ; out: +trace_bpf_test_finish (&err);return err; }tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +5
-0@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h> +
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c line 15
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +10
-0+void test_raw_tp_writable_reject_nbd_invalid (void ) +{ +__u32 duration =0 ; +char error[4096 ]; +int bpf_fd =-1 , tp_fd =-1 ; + +const struct bpf_insn program[] = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_DW ,BPF_REG_0 ,BPF_REG_6 ,128 ),
The number "128" is a little cryptic. Maybe you can use something like sizeof(struct nbd_request)?
Quoted 35 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +25
-0+ BPF_EXIT_INSN(), + }; + +struct bpf_load_program_attr load_attr = { + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .license ="GPL v2" , + .insns = program, + .insns_cnt =sizeof (program) /sizeof (struct bpf_insn ), + .log_level =2 , + }; + + bpf_fd =bpf_load_program_xattr (&load_attr, error,sizeof (error)); +if (CHECK (bpf_fd <0 ,"bpf_raw_tracepoint_writable loaded" , +"failed: %d errno %d\n" , bpf_fd, errno)) +return ; + + tp_fd =bpf_raw_tracepoint_open ("nbd_send_request" , bpf_fd); +if (CHECK (tp_fd >=0 ,"bpf_raw_tracepoint_writable opened" , +"erroneously succeeded\n" )) + goto out_bpffd; + +close (tp_fd); +out_bpffd: +close (bpf_fd); +}tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +4
-0@@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h>
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c line 14
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +10
-0+ +void test_raw_tp_writable_test_run (void ) +{ +__u32 duration =0 ; +char error[4096 ]; + +const struct bpf_insn trace_program[] = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_LD_IMM64 (BPF_REG_0 ,42 ),
You can use BPF_MOV64_IMM(BPF_REG_0, 42) instead of BPF_LD_IMM64. BPF_LD_IMM64 is fine, but probably BPF_MOV64_IMM is better. The same for a few below instances.
Quoted 107 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +66
-0+BPF_STX_MEM (BPF_W ,BPF_REG_6 ,BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }; + +struct bpf_load_program_attr load_attr = { + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .license ="GPL v2" , + .insns = trace_program, + .insns_cnt =sizeof (trace_program) /sizeof (struct bpf_insn ), + .log_level =2 , + }; + +int bpf_fd =bpf_load_program_xattr (&load_attr, error,sizeof (error)); +if (CHECK (bpf_fd <0 ,"bpf_raw_tracepoint_writable loaded" , +"failed: %d errno %d\n" , bpf_fd, errno)) +return ; + +const struct bpf_insn skb_program[] = { +BPF_LD_IMM64 (BPF_REG_0 ,0 ), +BPF_EXIT_INSN (), + }; + +struct bpf_load_program_attr skb_load_attr = { + .prog_type =BPF_PROG_TYPE_SOCKET_FILTER , + .license ="GPL v2" , + .insns = skb_program, + .insns_cnt =sizeof (skb_program) /sizeof (struct bpf_insn ), + }; + +int filter_fd = +bpf_load_program_xattr (&skb_load_attr, error,sizeof (error)); +if (CHECK (filter_fd <0 ,"test_program_loaded" ,"failed: %d errno %d\n" , + filter_fd, errno)) + goto out_bpffd; + +int tp_fd =bpf_raw_tracepoint_open ("bpf_test_finish" , bpf_fd); +if (CHECK (tp_fd <0 ,"bpf_raw_tracepoint_writable opened" , +"failed: %d errno %d\n" , tp_fd, errno)) + goto out_filterfd; + +char test_skb[128 ] = { +0 , + }; + +__u32 prog_ret; +int err =bpf_prog_test_run (filter_fd,1 , test_skb,sizeof (test_skb),0 , +0 , &prog_ret,0 ); +CHECK (err !=42 ,"test_run" , +"tracepoint did not modify return value\n" ); +CHECK (prog_ret !=0 ,"test_run_ret" , +"socket_filter did not return 0\n" ); + +close (tp_fd); + + err =bpf_prog_test_run (filter_fd,1 , test_skb,sizeof (test_skb),0 ,0 , + &prog_ret,0 ); +CHECK (err !=0 ,"test_run_notrace" , +"test_run failed with %d errno %d\n" , err, errno); +CHECK (prog_ret !=0 ,"test_run_ret_notrace" , +"socket_filter did not return 0\n" ); + +out_filterfd: +close (filter_fd); +out_bpffd: +close (bpf_fd); +}tools/testing/selftests/bpf/verifier/raw_tp_writable.c new file +34
-0@@ -0,0 +1,34 @@ +{ + "raw_tracepoint_writable: reject variable offset", + .insns = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), + +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +/* move the key (== 0) to r10-8 */ +BPF_MOV32_IMM (BPF_REG_0 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_0 ,0 ), +/* lookup in the map */ +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), + +/* exit clean if null */ +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), + +/* shift the buffer pointer to a variable location */ +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_0 ,0 ), +BPF_ALU64_REG (BPF_ADD ,BPF_REG_6 ,BPF_REG_0 ), +/* clobber whatever's there */ +BPF_MOV64_IMM (BPF_REG_7 ,4242 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_7 ,0 ), + +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_hash_8b = { 1, }, + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .errstr = "R6 invalid variable buffer offset: off=0, var_off=(0x0; 0xffffffff)", +},
Re: [PATCH bpf-next v3 5/5] selftests: bpf: test writable buffers in raw tps
Quoted 117 lines · Yonghong Song
Quoted 115 lines · Matt Mullins
This tests that:
* aBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEcannot be attached if it uses either:
* a variable offset to the tracepoint buffer, or
* an offset beyond the size of the tracepoint buffer
* a tracer can modify the buffer provided when attached to a writable tracepoint inbpf_prog_test_runSigned-off-by Matt Mullins <mmullins at fb.com>--- include/trace/events/bpf_test_run.h | 50 ++++++++++++ net/bpf/test_run.c | 4 + .../raw_tp_writable_reject_nbd_invalid.c | 40 ++++++++++ .../bpf/prog_tests/raw_tp_writable_test_run.c | 80 +++++++++++++++++++ .../selftests/bpf/verifier/raw_tp_writable.c | 34 ++++++++ 5 files changed, 208 insertions(+)create mode 100644
include/trace/events/bpf_test_run.h
create mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.ccreate mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.ccreate mode 100644tools/testing/selftests/bpf/verifier/raw_tp_writable.cinclude/trace/events/bpf_test_run.h new file +50
-0@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM bpf_test_run + +#if !defined(_TRACE_NBD_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_BPF_TEST_RUN_H + +#include <linux/tracepoint.h> + +DECLARE_EVENT_CLASS (bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +TP_STRUCT__entry ( +__field (int, err) + ), + +TP_fast_assign ( + __entry->err = *err; + ), + +TP_printk ("bpf_test_finish with err=%d" , __entry->err) +); + +#ifdef DEFINE_EVENT_WRITABLE +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT_WRITABLE(template, call, PARAMS(proto), \ + PARAMS(args), size) +#else +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args)) +#endif + +BPF_TEST_RUN_DEFINE_EVENT (bpf_test_finish, bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +sizeof (int ) +); + +#endif + +/* This part must be outside protection */ +#include <trace/define_trace.h> net/bpf/test_run.c +4
-0@@ -13,6 +13,9 @@#include <net/sock.h> #include <net/tcp.h> +#define CREATE_TRACE_POINTS +#include <trace/events/bpf_test_run.h> +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *retval,u32 *time) {@@ -100,6 +103,7 @@ static int bpf_test_finish(const union bpf_attr *kattr,if (err != -ENOSPC ) err =0 ; out: +trace_bpf_test_finish (&err);return err; }tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +10
-0@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h> + +void test_raw_tp_writable_reject_nbd_invalid (void ) +{ +__u32 duration =0 ; +char error[4096 ]; +int bpf_fd =-1 , tp_fd =-1 ;
Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c line 15
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +5
-0+ +const struct bpf_insn program[] = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_DW ,BPF_REG_0 ,BPF_REG_6 ,128 ),The number "128" is a little cryptic. Maybe you can use something like
sizeof(struct nbd_request)?
That was explicitly chosen to be (far) larger than an nbd_request, as this program should be rejected by the verifier. If you really want, I can do sizeof(struct nbd_request) + some constant and add a comment. But the size of an nbd request should never change, as that's a network protocol.
Quoted 42 lines
Quoted 42 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +25
-0+ BPF_EXIT_INSN(), + }; + +struct bpf_load_program_attr load_attr = { + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .license ="GPL v2" , + .insns = program, + .insns_cnt =sizeof (program) /sizeof (struct bpf_insn ), + .log_level =2 , + }; + + bpf_fd =bpf_load_program_xattr (&load_attr, error,sizeof (error)); +if (CHECK (bpf_fd <0 ,"bpf_raw_tracepoint_writable loaded" , +"failed: %d errno %d\n" , bpf_fd, errno)) +return ; + + tp_fd =bpf_raw_tracepoint_open ("nbd_send_request" , bpf_fd); +if (CHECK (tp_fd >=0 ,"bpf_raw_tracepoint_writable opened" , +"erroneously succeeded\n" )) + goto out_bpffd; + +close (tp_fd); +out_bpffd: +close (bpf_fd); +}tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +10
-0@@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h> + +void test_raw_tp_writable_test_run (void ) +{ +__u32 duration =0 ; +char error[4096 ]; +
Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c line 14
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +4
-0+const struct bpf_insn trace_program[] = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_6 ,0 ), +BPF_LD_IMM64 (BPF_REG_0 ,42 ),You can use
BPF_MOV64_IMM(BPF_REG_0, 42)instead ofBPF_LD_IMM64.BPF_LD_IMM64is fine, but probablyBPF_MOV64_IMMis better. The same for a few below instances.
Ah, right. I don't need the second opcode if the value can be zero- extended.
Quoted 108 lines
Quoted 108 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c new file +66
-0+BPF_STX_MEM (BPF_W ,BPF_REG_6 ,BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }; + +struct bpf_load_program_attr load_attr = { + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .license ="GPL v2" , + .insns = trace_program, + .insns_cnt =sizeof (trace_program) /sizeof (struct bpf_insn ), + .log_level =2 , + }; + +int bpf_fd =bpf_load_program_xattr (&load_attr, error,sizeof (error)); +if (CHECK (bpf_fd <0 ,"bpf_raw_tracepoint_writable loaded" , +"failed: %d errno %d\n" , bpf_fd, errno)) +return ; + +const struct bpf_insn skb_program[] = { +BPF_LD_IMM64 (BPF_REG_0 ,0 ), +BPF_EXIT_INSN (), + }; + +struct bpf_load_program_attr skb_load_attr = { + .prog_type =BPF_PROG_TYPE_SOCKET_FILTER , + .license ="GPL v2" , + .insns = skb_program, + .insns_cnt =sizeof (skb_program) /sizeof (struct bpf_insn ), + }; + +int filter_fd = +bpf_load_program_xattr (&skb_load_attr, error,sizeof (error)); +if (CHECK (filter_fd <0 ,"test_program_loaded" ,"failed: %d errno %d\n" , + filter_fd, errno)) + goto out_bpffd; + +int tp_fd =bpf_raw_tracepoint_open ("bpf_test_finish" , bpf_fd); +if (CHECK (tp_fd <0 ,"bpf_raw_tracepoint_writable opened" , +"failed: %d errno %d\n" , tp_fd, errno)) + goto out_filterfd; + +char test_skb[128 ] = { +0 , + }; + +__u32 prog_ret; +int err =bpf_prog_test_run (filter_fd,1 , test_skb,sizeof (test_skb),0 , +0 , &prog_ret,0 ); +CHECK (err !=42 ,"test_run" , +"tracepoint did not modify return value\n" ); +CHECK (prog_ret !=0 ,"test_run_ret" , +"socket_filter did not return 0\n" ); + +close (tp_fd); + + err =bpf_prog_test_run (filter_fd,1 , test_skb,sizeof (test_skb),0 ,0 , + &prog_ret,0 ); +CHECK (err !=0 ,"test_run_notrace" , +"test_run failed with %d errno %d\n" , err, errno); +CHECK (prog_ret !=0 ,"test_run_ret_notrace" , +"socket_filter did not return 0\n" ); + +out_filterfd: +close (filter_fd); +out_bpffd: +close (bpf_fd); +}tools/testing/selftests/bpf/verifier/raw_tp_writable.c new file +34
-0@@ -0,0 +1,34 @@ +{ + "raw_tracepoint_writable: reject variable offset", + .insns = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), + +BPF_LD_MAP_FD (BPF_REG_1 ,0 ), +/* move the key (== 0) to r10-8 */ +BPF_MOV32_IMM (BPF_REG_0 ,0 ), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_0 ,0 ), +/* lookup in the map */ +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , + BPF_FUNC_map_lookup_elem), + +/* exit clean if null */ +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,0 ,1 ), +BPF_EXIT_INSN (), + +/* shift the buffer pointer to a variable location */ +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_0 ,0 ), +BPF_ALU64_REG (BPF_ADD ,BPF_REG_6 ,BPF_REG_0 ), +/* clobber whatever's there */ +BPF_MOV64_IMM (BPF_REG_7 ,4242 ), +BPF_STX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_7 ,0 ), + +BPF_MOV64_IMM (BPF_REG_0 ,0 ), + BPF_EXIT_INSN(), + }, + .fixup_map_hash_8b = { 1, }, + .prog_type =BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE , + .errstr = "R6 invalid variable buffer offset: off=0, var_off=(0x0; 0xffffffff)", +},
Re: [PATCH bpf-next v3 5/5] selftests: bpf: test writable buffers in raw tps
Quoted 127 lines · Matt Mullins
Quoted 117 lines · Yonghong Song
Quoted 115 lines · Matt Mullins
This tests that:
* aBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLEcannot be attached if it uses either:
* a variable offset to the tracepoint buffer, or
* an offset beyond the size of the tracepoint buffer
* a tracer can modify the buffer provided when attached to a writable tracepoint inbpf_prog_test_runSigned-off-by Matt Mullins <mmullins at fb.com>--- include/trace/events/bpf_test_run.h | 50 ++++++++++++ net/bpf/test_run.c | 4 + .../raw_tp_writable_reject_nbd_invalid.c | 40 ++++++++++ .../bpf/prog_tests/raw_tp_writable_test_run.c | 80 +++++++++++++++++++ .../selftests/bpf/verifier/raw_tp_writable.c | 34 ++++++++ 5 files changed, 208 insertions(+)create mode 100644
include/trace/events/bpf_test_run.h
create mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.ccreate mode 100644tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.ccreate mode 100644tools/testing/selftests/bpf/verifier/raw_tp_writable.cinclude/trace/events/bpf_test_run.h new file +50
-0@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM bpf_test_run + +#if !defined(_TRACE_NBD_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_BPF_TEST_RUN_H + +#include <linux/tracepoint.h> + +DECLARE_EVENT_CLASS (bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +TP_STRUCT__entry ( +__field (int, err) + ), + +TP_fast_assign ( + __entry->err = *err; + ), + +TP_printk ("bpf_test_finish with err=%d" , __entry->err) +); + +#ifdef DEFINE_EVENT_WRITABLE +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT_WRITABLE(template, call, PARAMS(proto), \ + PARAMS(args), size) +#else +#undef BPF_TEST_RUN_DEFINE_EVENT +#define BPF_TEST_RUN_DEFINE_EVENT (template, call, proto, args, size) \ + DEFINE_EVENT(template, call, PARAMS(proto), PARAMS(args)) +#endif + +BPF_TEST_RUN_DEFINE_EVENT (bpf_test_finish, bpf_test_finish, + +TP_PROTO (int *err), + +TP_ARGS (err), + +sizeof (int ) +); + +#endif + +/* This part must be outside protection */ +#include <trace/define_trace.h> net/bpf/test_run.c +4
-0@@ -13,6 +13,9 @@#include <net/sock.h> #include <net/tcp.h> +#define CREATE_TRACE_POINTS +#include <trace/events/bpf_test_run.h> +static int bpf_test_run (struct bpf_prog *prog,void *ctx,u32 repeat,u32 *retval,u32 *time) {@@ -100,6 +103,7 @@ static int bpf_test_finish(const union bpf_attr *kattr,if (err != -ENOSPC ) err =0 ; out: +trace_bpf_test_finish (&err);return err; }tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +10
-0@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <linux/nbd.h> + +void test_raw_tp_writable_reject_nbd_invalid (void ) +{ +__u32 duration =0 ; +char error[4096 ]; +int bpf_fd =-1 , tp_fd =-1 ;Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c line 15
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c new file +5
-0+ +const struct bpf_insn program[] = { +/* r6 is our tp buffer */ +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ), +BPF_LDX_MEM (BPF_DW ,BPF_REG_0 ,BPF_REG_6 ,128 ),The number "128" is a little cryptic. Maybe you can use something like
sizeof(struct nbd_request)?
Quoted 5 lines
That was explicitly chosen to be (far) larger than an
nbd_request, as this program should be rejected by the verifier. If you really want, I can dosizeof(struct nbd_request) + some constantand add a comment. But the size of an nbd request should never change, as that's a network protocol.
I think sizeof(struct nbd_request) + some constant is better than number 128.