bpf: Support struct argument for trampoline base progs
v3 cover bpf: Support struct argument for trampoline base progs
Currently struct arguments are not supported for trampoline based progs. One of major reason is that struct argument may pass by value which may use more than one registers. This breaks trampoline progs where each argument is assumed to take one register. bcc community reported the issue ([1]) where struct argument is not supported for fentry program.
typedef struct {
uid_t val;
} kuid_t;
typedef struct {
gid_t val;
} kgid_t;
int security_path_chown(struct path *path, kuid_t uid, kgid_t gid);
Inside Meta, we also have a use case to attach to tcp_setsockopt()
typedef struct {
union {
void *kernel;
void __user *user;
};
bool is_kernel : 1;
} sockptr_t;
int tcp_setsockopt(struct sock *sk, int level, int optname,
sockptr_t optval, unsigned int optlen);This patch added struct value support for bpf tracing programs which uses trampoline. Only <= 16 byte struct size is supported for now which covers use cases in the above. For x86/arm64/bpf, <= 16 struct value will be passed in registers instead of by reference. Only x86_64 is supported in this patch. arm64 support can be added later.
[1] https://github.com/iovisor/bcc/issues/3657
Changelog:
v2 -> v3:
- previously struct arguments (<= 16 bytes) are passed by reference for bpf programs. Suggested by Alexei, it is passed by value now.
- in order to support passing <= 16 struct value, a new macro BPF_PROG2 is invented.
rfc v1 -> v2:
- changed bpf_func_model struct info fields to arg_flags[] to make it easy to iterate arguments in arch specific {save|restore}_regs() functions.
- added fexit tests to test return values with struct arguments.
Yonghong Song (7):
bpf: Allow struct argument in trampoline based programs
bpf: x86: Support in-register struct arguments in trampoline programs
bpf: Update descriptions for helpers bpf_get_func_arg[_cnt]()
bpf: arm64: No support of struct argument in trampoline programs
libbpf: Add new BPF_PROG2 macro
selftests/bpf: Add struct argument tests with fentry/fexit programs. selftests/bpf: Use BPF_PROG2 for some fentry programs without struct
arguments
arch/arm64/net/bpf_jit_comp.c | 8 +- arch/x86/net/bpf_jit_comp.c | 68 ++++++++--- include/linux/bpf.h | 4 + include/uapi/linux/bpf.h | 9 +- kernel/bpf/btf.c | 42 ++++++- tools/include/uapi/linux/bpf.h | 9 +- tools/lib/bpf/bpf_tracing.h | 82 +++++++++++++ .../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++ .../selftests/bpf/prog_tests/tracing_struct.c | 63 ++++++++++ tools/testing/selftests/bpf/progs/timer.c | 4 +- .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++ 11 files changed, 417 insertions(+), 34 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/tracing_struct.c create mode 100644 tools/testing/selftests/bpf/progs/tracing_struct.c
Signature · 1 line
2.30.2
PATCH v3 1/7 bpf: Allow struct argument in trampoline based programs
Allow struct argument in trampoline based programs where the struct size should be <= 16 bytes. In such cases, the argument will be put into up to 2 registers for bpf, x86_64 and arm64 architectures.
To support arch-specific trampoline manipulation,
add arg_flags for additional struct information about arguments in btf_func_model. Such information will be used in arch specific function arch_prepare_bpf_trampoline() to prepare argument access properly in trampoline.
--- include/linux/bpf.h | 4 ++++ kernel/bpf/btf.c | 42 ++++++++++++++++++++++++++++++++++++------ 2 files changed, 40 insertions(+), 6 deletions(-)
include/linux/bpf.h +4 -0
@@ -727,10 +727,14 @@ enum bpf_cgroup_storage_type {*/ #define MAX_BPF_FUNC_REG_ARGS 5 +/* The argument is a structure. */ +#define BTF_FMODEL_STRUCT_ARG BIT(0) +struct btf_func_model {u8 ret_size;u8 nr_args;u8 arg_size[MAX_BPF_FUNC_ARGS ]; +u8 arg_flags[MAX_BPF_FUNC_ARGS ]; };/* Restore arguments before returning from trampoline to let original function
kernel/bpf/btf.c +36 -6
91 lines not on this page · raw message
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v3 1/7] bpf: Allow struct argument in trampoline based programs
On Sat, Aug 27, 2022 at 07:54:43PM -0700, Yonghong Song wrote:
SNIP
Quoted 37 lines
kernel/bpf/btf.c +25
-0@@ -5328,6 +5328,31 @@ static bool is_int_ptr(struct btf *btf, const struct btf_type *t)return btf_type_is_int (t); } +static u32 get_ctx_arg_idx (struct btf *btf,const struct btf_type *func_proto, +int off) +{ +const struct btf_param *args; +const struct btf_type *t; +u32 offset =0 , nr_args; +int i; + + nr_args =btf_type_vlen (func_proto); + args = (const struct btf_param *)(func_proto +1 ); +for (i =0 ; i < nr_args; i++) { + t =btf_type_skip_modifiers (btf, args[i].type,NULL ); + offset +=btf_type_is_ptr (t) ?8 :roundup (t->size,8 ); +if (off < offset) +return i; + } + + t =btf_type_skip_modifiers (btf, func_proto->type,NULL ); + offset +=btf_type_is_ptr (t) ?8 :roundup (t->size,8 ); +if (off < offset) +return nr_args; + +return nr_args +1 ; +} +bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)
kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 5375
Quoted 5 lines
kernel/bpf/btf.c +1
-1@@ -5347,7 +5372,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, tname, off);return false; } - arg = off /8 ; + arg = t ==NULL ? (off /8 ) :get_ctx_arg_idx (btf, t, off);
is the t == NULL check needed? we relied on t being defined later in the code
jirka
Quoted 20 lines
kernel/bpf/btf.c +2
-2args = (const struct btf_param *)(t +1 );/* if (t == NULL) Fall back to default BPF prog with * MAX_BPF_FUNC_REG_ARGS u64 arguments. @@ -5417,7 +5442,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,/* skip modifiers */ while (btf_type_is_modifier (t)) t =btf_type_by_id (btf, t->type); -if (btf_type_is_small_int (t) ||btf_is_any_enum (t)) +if (btf_type_is_small_int (t) ||btf_is_any_enum (t) ||__btf_type_is_struct (t))/* accessing a scalar */ return true;if (!btf_type_is_ptr (t)) {@@ -5881,7 +5906,7 @@ static int __get_type_size(struct btf *btf, u32 btf_id,if (btf_type_is_ptr (t))/* kernel size of pointer. Not BPF's size of pointer*/ return sizeof (void *); -if (btf_type_is_int (t) ||btf_is_any_enum (t)) +if (btf_type_is_int (t) ||btf_is_any_enum (t) ||__btf_type_is_struct (t))return t->size;return -EINVAL ;
SNIP
Re: [PATCH bpf-next v3 1/7] bpf: Allow struct argument in trampoline based programs
Quoted 40 lines · Jiri Olsa
On Sat, Aug 27, 2022 at 07:54:43PM -0700, Yonghong Song wrote:
SNIP
Quoted 36 lines
kernel/bpf/btf.c +25
-0@@ -5328,6 +5328,31 @@ static bool is_int_ptr(struct btf *btf, const struct btf_type *t)return btf_type_is_int (t); } +static u32 get_ctx_arg_idx (struct btf *btf,const struct btf_type *func_proto, +int off) +{ +const struct btf_param *args; +const struct btf_type *t; +u32 offset =0 , nr_args; +int i; + + nr_args =btf_type_vlen (func_proto); + args = (const struct btf_param *)(func_proto +1 ); +for (i =0 ; i < nr_args; i++) { + t =btf_type_skip_modifiers (btf, args[i].type,NULL ); + offset +=btf_type_is_ptr (t) ?8 :roundup (t->size,8 ); +if (off < offset) +return i; + } + + t =btf_type_skip_modifiers (btf, func_proto->type,NULL ); + offset +=btf_type_is_ptr (t) ?8 :roundup (t->size,8 ); +if (off < offset) +return nr_args; + +return nr_args +1 ; +} +bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info)
Quoted 8 lines
kernel/bpf/btf.c bool btf_ctx_access(int off, int size, enum bpf_access_type type, · line 5375
Quoted 6 lines
kernel/bpf/btf.c +1
-1@@ -5347,7 +5372,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, tname, off);return false; } - arg = off /8 ; + arg = t ==NULL ? (off /8 ) :get_ctx_arg_idx (btf, t, off);is the t == NULL check needed? we relied on t being defined later in the code
t is defined earlier in
const struct btf_type *t = prog->aux->attach_func_proto;
so we should be fine.
I guess I will fold
if (!t) return off / 8;
inside get_ctx_arg_idx() to make interface cleaner. Will do this in the next revision.
Quoted 25 lines
jirka
Quoted 20 lines
kernel/bpf/btf.c +2
-2args = (const struct btf_param *)(t +1 );/* if (t == NULL) Fall back to default BPF prog with * MAX_BPF_FUNC_REG_ARGS u64 arguments. @@ -5417,7 +5442,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,/* skip modifiers */ while (btf_type_is_modifier (t)) t =btf_type_by_id (btf, t->type); -if (btf_type_is_small_int (t) ||btf_is_any_enum (t)) +if (btf_type_is_small_int (t) ||btf_is_any_enum (t) ||__btf_type_is_struct (t))/* accessing a scalar */ return true;if (!btf_type_is_ptr (t)) {@@ -5881,7 +5906,7 @@ static int __get_type_size(struct btf *btf, u32 btf_id,if (btf_type_is_ptr (t))/* kernel size of pointer. Not BPF's size of pointer*/ return sizeof (void *); -if (btf_type_is_int (t) ||btf_is_any_enum (t)) +if (btf_type_is_int (t) ||btf_is_any_enum (t) ||__btf_type_is_struct (t))return t->size;return -EINVAL ;SNIP
PATCH v3 2/7 bpf: x86: Support in-register struct arguments in trampoline programs
In reply to Yonghong SongIn C, struct value can be passed as a function argument. For small structs, struct value may be passed in
one or more registers. For trampoline based bpf programs, This would cause complication since one-to-one mapping between function argument and arch argument register is not valid any more.
The latest llvm16 added bpf support to pass by values for struct up to 16 bytes ([1]). This is also true for x86_64 architecture where two registers will hold the struct value if the struct size is >8 and <= 16. This may not be true if one of struct member is 'double' type but in current linux source code we don't have such instance yet, so we assume all >8 && <= 16 struct holds two general purpose argument registers.
Also change on-stack nr_args value to the number of registers holding the arguments. This will permit bpf_get_func_arg() helper to get all argument values.
[1] https://reviews.llvm.org/D132144
--- arch/x86/net/bpf_jit_comp.c | 68 +++++++++++++++++++++++++++---------- 1 file changed, 51 insertions(+), 17 deletions(-)
arch/x86/net/bpf_jit_comp.c +51 -17
@@ -1751,34 +1751,60 @@ st: if (is_imm8(insn->off))static void save_regs (const struct btf_func_model *m,u8 **prog,int nr_args,int stack_size) { -int i; +int i, j, arg_size, nr_regs;/* Store function arguments to stack. * For a function that accepts two pointers the sequence will be: * mov QWORD PTR [rbp-0x10],rdi * mov QWORD PTR [rbp-0x8],rsi */ -for (i =0 ; i <min (nr_args,6 ); i++) -emit_stx (prog,bytes_to_bpf_size (m->arg_size[i]), -BPF_REG_FP , - i ==5 ?X86_REG_R9 :BPF_REG_1 + i, - -(stack_size - i *8 )); +for (i =0 , j =0 ; i <min (nr_args,6 ); i++) { +if (m->arg_flags[i] &BTF_FMODEL_STRUCT_ARG ) { + nr_regs = (m->arg_size[i] +7 ) /8 ; + arg_size =8 ; + }else { + nr_regs =1 ; + arg_size = m->arg_size[i]; + } + +while (nr_regs) { +emit_stx (prog,bytes_to_bpf_size (arg_size), +BPF_REG_FP , + j ==5 ?X86_REG_R9 :BPF_REG_1 + j, + -(stack_size - j *8 )); + nr_regs--; + j++; + } + } }static void restore_regs (const struct btf_func_model *m,u8 **prog,int nr_args,int stack_size) { -int i; +int i, j, arg_size, nr_regs;/* Restore function arguments from stack. * For a function that accepts two pointers the sequence will be: * EMIT4(0x48, 0x8B, 0x7D, 0xF0); mov rdi,QWORD PTR [rbp-0x10] * EMIT4(0x48, 0x8B, 0x75, 0xF8); mov rsi,QWORD PTR [rbp-0x8] */ -for (i =0 ; i <min (nr_args,6 ); i++) -emit_ldx (prog,bytes_to_bpf_size (m->arg_size[i]), - i ==5 ?X86_REG_R9 :BPF_REG_1 + i, -BPF_REG_FP , - -(stack_size - i *8 )); +for (i =0 , j =0 ; i <min (nr_args,6 ); i++) { +if (m->arg_flags[i] &BTF_FMODEL_STRUCT_ARG ) { + nr_regs = (m->arg_size[i] +7 ) /8 ; + arg_size =8 ; + }else { + nr_regs =1 ; + arg_size = m->arg_size[i]; + } + +while (nr_regs) { +emit_ldx (prog,bytes_to_bpf_size (arg_size), + j ==5 ?X86_REG_R9 :BPF_REG_1 + j, +BPF_REG_FP , + -(stack_size - j *8 )); + nr_regs--; + j++; + } + } } static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog,
@@ -2015,7 +2041,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *istruct bpf_tramp_links *tlinks, void *orig_call) { - int ret, i, nr_args = m->nr_args; + int ret, i, nr_args = m->nr_args, extra_nregs = 0;int regs_off, ip_off, args_off, stack_size = nr_args *8 , run_ctx_off;struct bpf_tramp_links *fentry = &tlinks[BPF_TRAMP_FENTRY ];struct bpf_tramp_links *fexit = &tlinks[BPF_TRAMP_FEXIT ];
@@ -2028,6 +2054,14 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *iif (nr_args >6 )return -ENOTSUPP ; +for (i =0 ; i <MAX_BPF_FUNC_ARGS ; i++) { +if (m->arg_flags[i] &BTF_FMODEL_STRUCT_ARG ) + extra_nregs += (m->arg_size[i] +7 ) /8 -1 ; + } +if (nr_args + extra_nregs >6 ) +return -ENOTSUPP ; + stack_size += extra_nregs *8 ; +/* Generated trampoline stack layout: * * RBP + 8 [ return address ]
@@ -2040,7 +2074,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i* [ ... ] * RBP - regs_off [ reg_arg1 ] program's ctx pointer * -* RBP - args_off [ args count ] always +* RBP - args_off [ arg regs count ] always * * RBP - ip_off [ traced function ] BPF_TRAMP_F_IP_ARG flag *
@@ -2083,11 +2117,11 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *iEMIT4 (0x48 ,0x83 ,0xEC , stack_size);/* sub rsp, stack_size */ EMIT1 (0x53 );/* push rbx */ -/* Store number of arguments of the traced function: -* mov rax, nr_args +/* Store number of argument registers of the traced function: +* mov rax, nr_args + extra_nregs * mov QWORD PTR [rbp - args_off], rax */ -emit_mov_imm64 (&prog,BPF_REG_0 ,0 , (u32 ) nr_args); +emit_mov_imm64 (&prog,BPF_REG_0 ,0 , (u32 ) nr_args + extra_nregs);emit_stx (&prog,BPF_DW ,BPF_REG_FP ,BPF_REG_0 , -args_off);if (flags &BPF_TRAMP_F_IP_ARG ) {
Signature · 1 line
2.30.2
PATCH v3 3/7 bpf: Update descriptions for helpers bpf_get_func_arg[_cnt]()
In reply to Yonghong SongNow instead of the number of arguments, the number of registers holding argument values are stored in trampoline. Update the description of bpf_get_func_arg[_cnt]() helpers. Previous programs without struct arguments should continue to work as usual.
--- include/uapi/linux/bpf.h | 9 +++++---- tools/include/uapi/linux/bpf.h | 9 +++++---- 2 files changed, 10 insertions(+), 8 deletions(-)
include/uapi/linux/bpf.h +5 -4
@@ -5079,12 +5079,12 @@ union bpf_attr {* * long bpf_get_func_arg(void *ctx, u32 n, u64 *value) * Description -* Get **n**-th argument (zero based) of the traced function (for tracing programs) +* Get **n**-th argument register (zero based) of the traced function (for tracing programs) * returned in **value**. * * Return * 0 on success. -* **-EINVAL** if n >= arguments count of traced function. +* **-EINVAL** if n >= argument register count of traced function. * * long bpf_get_func_ret(void *ctx, u64 *value) * Description
@@ -5097,10 +5097,11 @@ union bpf_attr {* * long bpf_get_func_arg_cnt(void *ctx) * Description -* Get number of arguments of the traced function (for tracing programs). +* Get number of registers of the traced function (for tracing programs) where +* function arguments are stored in these registers. * * Return -* The number of arguments of the traced function. +* The number of argument registers of the traced function. * * int bpf_get_retval(void) * Description
tools/include/uapi/linux/bpf.h +5 -4
@@ -5079,12 +5079,12 @@ union bpf_attr {* * long bpf_get_func_arg(void *ctx, u32 n, u64 *value) * Description -* Get **n**-th argument (zero based) of the traced function (for tracing programs) +* Get **n**-th argument register (zero based) of the traced function (for tracing programs) * returned in **value**. * * Return * 0 on success. -* **-EINVAL** if n >= arguments count of traced function. +* **-EINVAL** if n >= argument register count of traced function. * * long bpf_get_func_ret(void *ctx, u64 *value) * Description
@@ -5097,10 +5097,11 @@ union bpf_attr {* * long bpf_get_func_arg_cnt(void *ctx) * Description -* Get number of arguments of the traced function (for tracing programs). +* Get number of registers of the traced function (for tracing programs) where +* function arguments are stored in these registers. * * Return -* The number of arguments of the traced function. +* The number of argument registers of the traced function. * * int bpf_get_retval(void) * Description
Signature · 1 line
2.30.2
PATCH v3 4/7 bpf: arm64: No support of struct argument in trampoline programs
In reply to Yonghong SongARM64 does not support struct argument for trampoline based bpf programs yet.
--- arch/arm64/net/bpf_jit_comp.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
arch/arm64/net/bpf_jit_comp.c +7 -1
@@ -1970,7 +1970,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, u32 flags, struct bpf_tramp_links *tlinks, void *orig_call) { - int ret; + int i, ret;int nargs = m->nr_args;int max_insns = ((long )image_end - (long )image) /AARCH64_INSN_SIZE ; struct jit_ctx ctx = {
@@ -1982,6 +1982,12 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image,if (nargs >8 )return -ENOTSUPP ; +/* don't support struct argument */ +for (i =0 ; i <MAX_BPF_FUNC_ARGS ; i++) { +if (m->arg_flags[i] &BTF_FMODEL_STRUCT_ARG ) +return -ENOTSUPP ; + } + ret =prepare_trampoline (&ctx, im, tlinks, orig_call, nargs, flags);if (ret <0 )return ret;
Signature · 1 line
2.30.2
PATCH v3 5/7 libbpf: Add new BPF_PROG2 macro
In reply to Yonghong SongTo support struct arguments in trampoline based programs, existing BPF_PROG doesn't work any more since the type size is needed to find whether a parameter takes one or two registers. So this patch added a new BPF_PROG2 macro to support such trampoline programs.
The idea is suggested by Andrii. For example, if the to-be-traced function has signature like
typedef struct {
void *x;
int t; } sockptr;
int blah(sockptr x, char y);
In the new BPF_PROG2 macro, the argument can be represented as
__bpf_prog_call(
({ union {
struct { __u64 x, y; } ___z;
sockptr x;
} ___tmp = { .___z = { ctx[0], ctx[1] }};
___tmp.x;
}),
({ union {
struct { __u8 x; } ___z;
char y;
} ___tmp = { .___z = { ctx[2] }};
___tmp.y;
}));In the above, the values stored on the stack are properly assigned to the actual argument type value by using 'union' magic. Note that the macro also works even if no arguments are with struct types.
--- tools/lib/bpf/bpf_tracing.h | 82 +++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+)
tools/lib/bpf/bpf_tracing.h +82 -0
@@ -438,6 +438,88 @@ typeof(name(0)) name(unsigned long long *ctx) \ static __always_inline typeof(name(0)) \ ____##name(unsigned long long *ctx, ##args) +#ifndef ____bpf_nth +#define ____bpf_nth (_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24,N , ...) N +#endif +#ifndef ____bpf_narg +#define ____bpf_narg (...) ____bpf_nth(_, ##__VA_ARGS__, 12, 12, 11, 11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0) +#endif + +#define BPF_REG_CNT (t) \ + (__builtin_choose_expr(sizeof(t) == 1, 1, \ + __builtin_choose_expr(sizeof(t) == 2, 1, \ + __builtin_choose_expr(sizeof(t) == 4, 1, \ + __builtin_choose_expr(sizeof(t) == 8, 1, \ + __builtin_choose_expr(sizeof(t) == 16, 2, \ + (void)0)))))) + +#define ____bpf_reg_cnt0 () (0) +#define ____bpf_reg_cnt1 (t, x) (____bpf_reg_cnt0() + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt2(t, x, args...) (____bpf_reg_cnt1(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt3(t, x, args...) (____bpf_reg_cnt2(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt4(t, x, args...) (____bpf_reg_cnt3(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt5(t, x, args...) (____bpf_reg_cnt4(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt6(t, x, args...) (____bpf_reg_cnt5(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt7(t, x, args...) (____bpf_reg_cnt6(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt8(t, x, args...) (____bpf_reg_cnt7(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt9(t, x, args...) (____bpf_reg_cnt8(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt10(t, x, args...) (____bpf_reg_cnt9(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt11(t, x, args...) (____bpf_reg_cnt10(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt12(t, x, args...) (____bpf_reg_cnt11(args) + BPF_REG_CNT(t)) +#define ____bpf_reg_cnt(args...) ___bpf_apply(____bpf_reg_cnt, ____bpf_narg(args))(args) + +#define ____bpf_union_arg (t, x, n) \ + __builtin_choose_expr(sizeof(t) == 1, ({ union { struct { __u8 x; } ___z; t x; } ___tmp = { .___z = {ctx[n]}}; ___tmp.x; }), \ + __builtin_choose_expr(sizeof(t) == 2, ({ union { struct { __u16 x; } ___z; t x; } ___tmp = { .___z = {ctx[n]} }; ___tmp.x; }), \ + __builtin_choose_expr(sizeof(t) == 4, ({ union { struct { __u32 x; } ___z; t x; } ___tmp = { .___z = {ctx[n]} }; ___tmp.x; }), \ + __builtin_choose_expr(sizeof(t) == 8, ({ union { struct { __u64 x; } ___z; t x; } ___tmp = {.___z = {ctx[n]} }; ___tmp.x; }), \ + __builtin_choose_expr(sizeof(t) == 16, ({ union { struct { __u64 x, y; } ___z; t x; } ___tmp = {.___z = {ctx[n], ctx[n + 1]} }; ___tmp.x; }), \ + (void)0))))) + +#define ____bpf_ctx_arg0(n, args...) +#define ____bpf_ctx_arg1 (n, t, x) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt1(t, x)) +#define ____bpf_ctx_arg2(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt2(t, x, args)) ____bpf_ctx_arg1(n, args) +#define ____bpf_ctx_arg3(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt3(t, x, args)) ____bpf_ctx_arg2(n, args) +#define ____bpf_ctx_arg4(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt4(t, x, args)) ____bpf_ctx_arg3(n, args) +#define ____bpf_ctx_arg5(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt5(t, x, args)) ____bpf_ctx_arg4(n, args) +#define ____bpf_ctx_arg6(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt6(t, x, args)) ____bpf_ctx_arg5(n, args) +#define ____bpf_ctx_arg7(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt7(t, x, args)) ____bpf_ctx_arg6(n, args) +#define ____bpf_ctx_arg8(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt8(t, x, args)) ____bpf_ctx_arg7(n, args) +#define ____bpf_ctx_arg9(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt9(t, x, args)) ____bpf_ctx_arg8(n, args) +#define ____bpf_ctx_arg10(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt10(t, x, args)) ____bpf_ctx_arg9(n, args) +#define ____bpf_ctx_arg11(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt11(t, x, args)) ____bpf_ctx_arg10(n, args) +#define ____bpf_ctx_arg12(n, t, x, args...) , ____bpf_union_arg(t, x, n - ____bpf_reg_cnt12(t, x, args)) ____bpf_ctx_arg11(n, args) +#define ____bpf_ctx_arg(n, args...) ___bpf_apply(____bpf_ctx_arg, ____bpf_narg(args))(n, args) + +#define ____bpf_ctx_decl0 () +#define ____bpf_ctx_decl1 (t, x) , t x +#define ____bpf_ctx_decl2(t, x, args...) , t x ____bpf_ctx_decl1(args) +#define ____bpf_ctx_decl3(t, x, args...) , t x ____bpf_ctx_decl2(args) +#define ____bpf_ctx_decl4(t, x, args...) , t x ____bpf_ctx_decl3(args) +#define ____bpf_ctx_decl5(t, x, args...) , t x ____bpf_ctx_decl4(args) +#define ____bpf_ctx_decl6(t, x, args...) , t x ____bpf_ctx_decl5(args) +#define ____bpf_ctx_decl7(t, x, args...) , t x ____bpf_ctx_decl6(args) +#define ____bpf_ctx_decl8(t, x, args...) , t x ____bpf_ctx_decl7(args) +#define ____bpf_ctx_decl9(t, x, args...) , t x ____bpf_ctx_decl8(args) +#define ____bpf_ctx_decl10(t, x, args...) , t x ____bpf_ctx_decl9(args) +#define ____bpf_ctx_decl11(t, x, args...) , t x ____bpf_ctx_decl10(args) +#define ____bpf_ctx_decl12(t, x, args...) , t x ____bpf_ctx_decl11(args) +#define ____bpf_ctx_decl(args...) ___bpf_apply(____bpf_ctx_decl, ____bpf_narg(args))(args) + +/* +* BPF_PROG2 can handle struct arguments. +*/ +#define BPF_PROG2(name, args...) \ +name(unsigned long long *ctx); \ +static __always_inline typeof(name(0)) \ +____##name(unsigned long long *ctx ____bpf_ctx_decl(args)); \ +typeof(name(0)) name(unsigned long long *ctx) \ +{ \ + return ____##name(ctx ____bpf_ctx_arg(____bpf_reg_cnt(args), args)); \ +} \ +static __always_inline typeof(name(0)) \ +____##name(unsigned long long *ctx ____bpf_ctx_decl(args)) +struct pt_regs ;#define ___bpf_kprobe_args0 () ctx
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v3 5/7] libbpf: Add new BPF_PROG2 macro
Quoted 53 lines · Yonghong Song
To support struct arguments in trampoline based programs, existing
BPF_PROGdoesn't work any more since the type size is needed to find whether a parameter takes one or two registers. So this patch added a newBPF_PROG2macro to support such trampoline programs.The idea is suggested by Andrii. For example, if the to-be-traced function has signature like typedef struct {
void *x;
int t;
} sockptr;
intblah(sockptr x, char y);In the new
BPF_PROG2macro, the argument can be represented as
__bpf_prog_call(
({ union {
struct {__u64x, y; }___z;
sockptr x;
}___tmp= { .___z = { ctx[0], ctx[1] }}; ___tmp.x;
}),
({ union {
struct {__u8x; }___z;
char y;
}___tmp= { .___z = { ctx[2] }}; ___tmp.y;
}));
In the above, the values stored on the stack are properly assigned to the actual argument type value by using 'union' magic. Note that the macro also works even if no arguments are with struct types.Signed-off-by Yonghong Song <[email protected]>---
tools/lib/bpf/bpf_tracing.h | 82
+++++++++++++++++++++++++++++++++++++1 file changed, 82 insertions(+)tools/lib/bpf/bpf_tracing.h +0
-0@@ -438,6 +438,88 @@ typeof(name(0)) name(unsigned long long *ctx) \static
__always_inline
typeof(name(0)) \
____##name(unsigned long long *ctx, ##args)tools/lib/bpf/bpf_tracing.h +2
-0+#ifndef ____bpf_nth +#define ____bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11,
Quoted 2 lines
_12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, N, ...) N
____bpf_nth() is a confusing name. I will expect to give any number n to return the nth argument. However, here it return the value of an argument at a specific/fixed position. ____bpf_25th() would make more sense for me.
tools/lib/bpf/bpf_tracing.h typeof(name(0)) name(unsigned long long *ctx) \ · line 454
Quoted 13 lines
tools/lib/bpf/bpf_tracing.h +3
-0+#endif +#ifndef ____bpf_narg +#define ____bpf_narg (...) ____bpf_nth(_, ##__VA_ARGS__, 12, 12, 11,11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0)
tools/lib/bpf/bpf_tracing.h +9
-0+#endif + +#define BPF_REG_CNT (t) \ + (__builtin_choose_expr(sizeof(t) == 1, 1, \ + __builtin_choose_expr(sizeof(t) == 2, 1, \ + __builtin_choose_expr(sizeof(t) == 4, 1, \ + __builtin_choose_expr(sizeof(t) == 8, 1, \ + __builtin_choose_expr(sizeof(t) == 16, 2, \ + (void)0))))))
nit: Using ternary operator will still work, right? For example,
(sizeof(t) == 1 || sizeof(t) == 2 || sizeof(t) == 4 || sizeof(t) == 8)
? 1 : (sizeof(t) == 16 ? 2 : 0)
Compilers should be able to optimize it as a const value.
Quoted 36 lines
tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_reg_cnt0 () (0) +#define ____bpf_reg_cnt1 (t, x) (____bpf_reg_cnt0() +
BPF_REG_CNT(t))
+#define ____bpf_reg_cnt2(t, x,
args...) (____bpf_reg_cnt1(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt3(t, x,
args...) (____bpf_reg_cnt2(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt4(t, x,
args...) (____bpf_reg_cnt3(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt5(t, x,
args...) (____bpf_reg_cnt4(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt6(t, x,
args...) (____bpf_reg_cnt5(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt7(t, x,
args...) (____bpf_reg_cnt6(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt8(t, x,
args...) (____bpf_reg_cnt7(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt9(t, x,
args...) (____bpf_reg_cnt8(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt10(t, x,
args...) (____bpf_reg_cnt9(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt11(t, x,
args...) (____bpf_reg_cnt10(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt12(t, x,
args...) (____bpf_reg_cnt11(args) +BPF_REG_CNT(t)) +#define____bpf_reg_cnt(args...)___bpf_apply(____bpf_reg_cnt, ____bpf_narg(args))(args)tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_union_arg (t, x, n) \ + __builtin_choose_expr(sizeof(t) == 1, ({ union { struct {
__u8x; }___z; t x; }___tmp= { .___z = {ctx[n]}}; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 2, ({ union { struct {__u16x; }___z; t x; }___tmp= { .___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 4, ({ union { struct {
Quoted 8 lines
__u32x; }___z; t x; }___tmp= { .___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 8, ({ union { struct {__u64x; }___z; t x; }___tmp= {.___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 16, ({ union { struct {__u64x, y; }___z; t x; }___tmp= {.___z = {ctx[n], ctx[n + 1]} }; ___tmp.x; }), \
+ (void)0)))))
Is it possible to cast &ctx[n] to the pointer of the target type? For example,
*(t*)&ctx[n]
Did I miss any thing?
Quoted 94 lines
tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_ctx_arg0(n, args...) +#define ____bpf_ctx_arg1 (n, t, x) ,
____bpf_union_arg(t, x, n - ____bpf_reg_cnt1(t, x))+#define____bpf_ctx_arg2(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt2(t, x, args))____bpf_ctx_arg1(n, args)
+#define____bpf_ctx_arg3(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt3(t, x, args))____bpf_ctx_arg2(n, args)
+#define____bpf_ctx_arg4(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt4(t, x, args))____bpf_ctx_arg3(n, args)
+#define____bpf_ctx_arg5(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt5(t, x, args))____bpf_ctx_arg4(n, args)
+#define____bpf_ctx_arg6(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt6(t, x, args))____bpf_ctx_arg5(n, args)
+#define____bpf_ctx_arg7(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt7(t, x, args))____bpf_ctx_arg6(n, args)
+#define____bpf_ctx_arg8(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt8(t, x, args))____bpf_ctx_arg7(n, args)
+#define____bpf_ctx_arg9(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt9(t, x, args))____bpf_ctx_arg8(n, args)
+#define____bpf_ctx_arg10(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt10(t, x, args))____bpf_ctx_arg9(n, args)
+#define____bpf_ctx_arg11(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt11(t, x, args))____bpf_ctx_arg10(n, args)
+#define____bpf_ctx_arg12(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt12(t, x, args))____bpf_ctx_arg11(n, args)
+#define____bpf_ctx_arg(n, args...)___bpf_apply(____bpf_ctx_arg, ____bpf_narg(args))(n, args)tools/lib/bpf/bpf_tracing.h +4
-0+ +#define ____bpf_ctx_decl0 () +#define ____bpf_ctx_decl1 (t, x) , t x +#define ____bpf_ctx_decl2(t, x, args...) , t x
____bpf_ctx_decl1(args)
+#define____bpf_ctx_decl3(t, x, args...), t x____bpf_ctx_decl2(args)
+#define____bpf_ctx_decl4(t, x, args...), t x____bpf_ctx_decl3(args)
+#define____bpf_ctx_decl5(t, x, args...), t x____bpf_ctx_decl4(args)
+#define____bpf_ctx_decl6(t, x, args...), t x____bpf_ctx_decl5(args)
+#define____bpf_ctx_decl7(t, x, args...), t x____bpf_ctx_decl6(args)
+#define____bpf_ctx_decl8(t, x, args...), t x____bpf_ctx_decl7(args)
+#define____bpf_ctx_decl9(t, x, args...), t x____bpf_ctx_decl8(args)
+#define____bpf_ctx_decl10(t, x, args...), t x____bpf_ctx_decl9(args)
+#define____bpf_ctx_decl11(t, x, args...), t x____bpf_ctx_decl10(args)
+#define____bpf_ctx_decl12(t, x, args...), t x____bpf_ctx_decl11(args)
+#define
____bpf_ctx_decl(args...) ___bpf_apply(____bpf_ctx_decl, ____bpf_narg(args))(args)tools/lib/bpf/bpf_tracing.h +5
-0+ +/* +* BPF_PROG2 can handle struct arguments. +*/ +#define BPF_PROG2(name,args...) \
+name(unsigned long long
*ctx); \
+static__always_inline
typeof(name(0)) \
+____##name(unsigned long long *ctx ____bpf_ctx_decl(args)); \
+typeof(name(0)) name(unsigned long long
*ctx) \
+{
\
+ return ____##name(ctx____bpf_ctx_arg(____bpf_reg_cnt(args), args)); \
+}
\
+static__always_inline
typeof(name(0)) \tools/lib/bpf/bpf_tracing.h +2
-0+____##name(unsigned long long *ctx ____bpf_ctx_decl(args)) +struct
pt_regs;
#define ___bpf_kprobe_args0() ctx
Re: [PATCH bpf-next v3 5/7] libbpf: Add new BPF_PROG2 macro
Quoted 52 lines · Kui-Feng Lee
Quoted 51 lines · Yonghong Song
To support struct arguments in trampoline based programs, existing
BPF_PROGdoesn't work any more since the type size is needed to find whether a parameter takes one or two registers. So this patch added a newBPF_PROG2macro to support such trampoline programs.The idea is suggested by Andrii. For example, if the to-be-traced function has signature like
typedef struct {
void *x;
int t;
} sockptr;
intblah(sockptr x, char y);In the new
BPF_PROG2macro, the argument can be represented as
__bpf_prog_call(
({ union {
struct {__u64x, y; }___z;
sockptr x;
}___tmp= { .___z = { ctx[0], ctx[1] }}; ___tmp.x;
}),
({ union {
struct {__u8x; }___z;
char y;
}___tmp= { .___z = { ctx[2] }}; ___tmp.y;
}));
In the above, the values stored on the stack are properly assigned to the actual argument type value by using 'union' magic. Note that the macro also works even if no arguments are with struct types.Signed-off-by Yonghong Song <[email protected]>--- tools/lib/bpf/bpf_tracing.h | 82 +++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+)tools/lib/bpf/bpf_tracing.h +0
-0@@ -438,6 +438,88 @@ typeof(name(0)) name(unsigned long long *ctx) \ static __always_inline typeof(name(0)) \ ____##name(unsigned long long *ctx, ##args)
Quoted 9 lines
Quoted 4 lines
tools/lib/bpf/bpf_tracing.h +2
-0+#ifndef ____bpf_nth +#define ____bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, N,...) N
____bpf_nth()is a confusing name. I will expect to give any number n to return the nth argument. However, here it return the value of an argument at a specific/fixed position.____bpf_25th()would make more sense for me.
In bpf_tracing.h, we have
#define ___bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _a, _b, _c, N, ...) N for 12 arguments.
The above is similar to ___bpf_nth (with one less _ compared to ____bpf_nth).
On the other hand, I can just modify the existing ___bpf_nth for 24 arguments so we don't need ____bpf_nth any more. Will do this in the next revision.
Quoted 18 lines
Quoted 5 lines
tools/lib/bpf/bpf_tracing.h +3
-0+#endif +#ifndef ____bpf_narg +#define ____bpf_narg (...) ____bpf_nth(_, ##__VA_ARGS__, 12, 12, 11,11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0)
tools/lib/bpf/bpf_tracing.h typeof(name(0)) name(unsigned long long *ctx) \ · line 454
Quoted 9 lines
tools/lib/bpf/bpf_tracing.h +9
-0+#endif + +#define BPF_REG_CNT (t) \ + (__builtin_choose_expr(sizeof(t) == 1, 1, \ + __builtin_choose_expr(sizeof(t) == 2, 1, \ + __builtin_choose_expr(sizeof(t) == 4, 1, \ + __builtin_choose_expr(sizeof(t) == 8, 1, \ + __builtin_choose_expr(sizeof(t) == 16, 2, \ + (void)0))))))nit: Using ternary operator will still work, right? For example,
Quoted 4 lines
(sizeof(t) == 1 || sizeof(t) == 2 || sizeof(t) == 4 || sizeof(t) == 8)
? 1 : (sizeof(t) == 16 ? 2 : 0)Compilers should be able to optimize it as a const value.
Good idea. Will change in the next revision.
Quoted 49 lines
Quoted 37 lines
tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_reg_cnt0 () (0) +#define ____bpf_reg_cnt1 (t, x) (____bpf_reg_cnt0() +
BPF_REG_CNT(t))
+#define ____bpf_reg_cnt2(t, x,
args...) (____bpf_reg_cnt1(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt3(t, x,
args...) (____bpf_reg_cnt2(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt4(t, x,
args...) (____bpf_reg_cnt3(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt5(t, x,
args...) (____bpf_reg_cnt4(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt6(t, x,
args...) (____bpf_reg_cnt5(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt7(t, x,
args...) (____bpf_reg_cnt6(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt8(t, x,
args...) (____bpf_reg_cnt7(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt9(t, x,
args...) (____bpf_reg_cnt8(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt10(t, x,
args...) (____bpf_reg_cnt9(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt11(t, x,
args...) (____bpf_reg_cnt10(args) +BPF_REG_CNT(t)) +#define ____bpf_reg_cnt12(t, x,
args...) (____bpf_reg_cnt11(args) +BPF_REG_CNT(t)) +#define____bpf_reg_cnt(args...)___bpf_apply(____bpf_reg_cnt, ____bpf_narg(args))(args)tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_union_arg (t, x, n) \ + __builtin_choose_expr(sizeof(t) == 1, ({ union { struct {
__u8x; }___z; t x; }___tmp= { .___z = {ctx[n]}}; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 2, ({ union { struct {__u16x; }___z; t x; }___tmp= { .___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 4, ({ union { struct {Quoted 8 lines
__u32x; }___z; t x; }___tmp= { .___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 8, ({ union { struct {__u64x; }___z; t x; }___tmp= {.___z = {ctx[n]} }; ___tmp.x; }), \
+ __builtin_choose_expr(sizeof(t) == 16, ({ union { struct {__u64x, y; }___z; t x; }___tmp= {.___z = {ctx[n], ctx[n + 1]} }; ___tmp.x; }), \
+ (void)0)))))Is it possible to cast &ctx[n] to the pointer of the target type? For example,
Quoted 3 lines
*(t*)&ctx[n]Did I miss any thing?
This won't work.
ctx[n] represents a u64 value.
Let us say type is 'u32'. *(u32 *)&ctx[n]
works for little endian, but won't work for big endian system.
Quoted 11 lines
Quoted 11 lines
tools/lib/bpf/bpf_tracing.h +3
-0+ +#define ____bpf_ctx_arg0(n, args...) +#define ____bpf_ctx_arg1 (n, t, x) ,
____bpf_union_arg(t, x, n - ____bpf_reg_cnt1(t, x))+#define____bpf_ctx_arg2(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt2(t, x, args))____bpf_ctx_arg1(n, args)
+#define____bpf_ctx_arg3(n, t, x, args...),____bpf_union_arg(t, x, n - ____bpf_reg_cnt3(t, x, args))____bpf_ctx_arg2(n, args)
[...]
PATCH v3 6/7 selftests/bpf: Add struct argument tests with fentry/fexit programs.
In reply to Yonghong SongAdd various struct argument tests with fentry/fexit programs. Also add one test with a kernel func which does not have any argument to test BPF_PROG2 macro in such situation.
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++ .../selftests/bpf/prog_tests/tracing_struct.c | 63 ++++++++++ .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++ 3 files changed, 225 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/tracing_struct.c create mode 100644 tools/testing/selftests/bpf/progs/tracing_struct.c
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +48 -0
@@ -18,6 +18,46 @@ typedef int (*func_proto_typedef_nested1)(func_proto_typedef);typedef int (*func_proto_typedef_nested2 )(func_proto_typedef_nested1 );DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; +long bpf_testmod_test_struct_arg_result; + +struct bpf_testmod_struct_arg_1 { +int a; +}; +struct bpf_testmod_struct_arg_2 { +long a; +long b; +}; + +noinline int +bpf_testmod_test_struct_arg_1 (struct bpf_testmod_struct_arg_2 a,int b,int c) { + bpf_testmod_test_struct_arg_result = a.a + a.b + b + c; +return bpf_testmod_test_struct_arg_result; +} + +noinline int +bpf_testmod_test_struct_arg_2 (int a,struct bpf_testmod_struct_arg_2 b,int c) { + bpf_testmod_test_struct_arg_result = a + b.a + b.b + c; +return bpf_testmod_test_struct_arg_result; +} + +noinline int +bpf_testmod_test_struct_arg_3 (int a,int b,struct bpf_testmod_struct_arg_2 c) { + bpf_testmod_test_struct_arg_result = a + b + c.a + c.b; +return bpf_testmod_test_struct_arg_result; +} + +noinline int +bpf_testmod_test_struct_arg_4 (struct bpf_testmod_struct_arg_1 a,int b, +int c,int d,struct bpf_testmod_struct_arg_2 e) { + bpf_testmod_test_struct_arg_result = a.a + b + c + d + e.a + e.b; +return bpf_testmod_test_struct_arg_result; +} + +noinline int +bpf_testmod_test_struct_arg_5 (void ) { + bpf_testmod_test_struct_arg_result =1 ; +return bpf_testmod_test_struct_arg_result; +} noinline voidbpf_testmod_test_mod_kfunc (int i)
@@ -98,11 +138,19 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, .off = off, .len = len, }; +struct bpf_testmod_struct_arg_1 struct_arg1 = {10 }; +struct bpf_testmod_struct_arg_2 struct_arg2 = {2 ,3 };int i =1 ;while (bpf_testmod_return_ptr (i)) i++; + (void )bpf_testmod_test_struct_arg_1 (struct_arg2,1 ,4 ); + (void )bpf_testmod_test_struct_arg_2 (1 , struct_arg2,4 ); + (void )bpf_testmod_test_struct_arg_3 (1 ,4 , struct_arg2); + (void )bpf_testmod_test_struct_arg_4 (struct_arg1,1 ,2 ,3 , struct_arg2); + (void )bpf_testmod_test_struct_arg_5 (); +/* This is always true. Use the check to make sure the compiler * doesn't remove bpf_testmod_loop_test. */
tools/testing/selftests/bpf/prog_tests/tracing_struct.c new file +63 -0
63 lines not on this page · raw message
tools/testing/selftests/bpf/progs/tracing_struct.c new file +114 -0
114 lines not on this page · raw message
Signature · 1 line
2.30.2
Daniel Borkmann
maintainerRe: [PATCH bpf-next v3 6/7] selftests/bpf: Add struct argument tests with fentry/fexit programs.
Quoted 4 lines · Yonghong Song
Add various struct argument tests with fentry/fexit programs. Also add one test with a kernel func which does not have any argument to test
BPF_PROG2macro in such situation.
Quoted 9 lines
Signed-off-by Yonghong Song <[email protected]>--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++ .../selftests/bpf/prog_tests/tracing_struct.c | 63 ++++++++++ .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++ 3 files changed, 225 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/tracing_struct.ccreate mode 100644tools/testing/selftests/bpf/progs/tracing_struct.c
For s390x these tests need to be deny-listed due to missing trampoline support..
All error logs:
test_fentry:PASS:tracing_struct__open_and_load 0 nsec
libbpf: prog 'test_struct_arg_1': failed to attach: ERROR: strerror_r(-524)=22
libbpf: prog 'test_struct_arg_1': failed to auto-attach: -524 test_fentry:FAIL:tracing_struct__attach unexpected error: -524 (errno 524)
#209 tracing_struct:FAIL
Summary: 189/972 PASSED, 27 SKIPPED, 1 FAILED
However, looks like the no_alu32 ones on x86 fail:
[...]
#207 trace_printk:OK
#208 trace_vprintk:OK
test_fentry:PASS:tracing_struct__open_and_load 0 nsec test_fentry:PASS:tracing_struct__attach 0 nsec trigger_module_test_read:PASS:testmod_file_open 0 nsec test_fentry:PASS:trigger_read 0 nsec
test_fentry:PASS:t1:a.a 0 nsec
test_fentry:PASS:t1:a.b 0 nsec
test_fentry:PASS:t1:b 0 nsec
test_fentry:PASS:t1:c 0 nsec
test_fentry:PASS:t1 nregs 0 nsec
test_fentry:PASS:t1 reg0 0 nsec
test_fentry:PASS:t1 reg1 0 nsec
test_fentry:FAIL:t1 reg2 unexpected t1 reg2: actual 7327499336969879553 != expected 1 test_fentry:PASS:t1 reg3 0 nsec
test_fentry:PASS:t1 ret 0 nsec
test_fentry:PASS:t2:a 0 nsec
test_fentry:PASS:t2:b.a 0 nsec
test_fentry:PASS:t2:b.b 0 nsec
test_fentry:PASS:t2:c 0 nsec
test_fentry:PASS:t2 ret 0 nsec
test_fentry:PASS:t3:a 0 nsec
test_fentry:PASS:t3:b 0 nsec
test_fentry:PASS:t3:c.a 0 nsec
test_fentry:PASS:t3:c.b 0 nsec
test_fentry:PASS:t3 ret 0 nsec
test_fentry:PASS:t4:a.a 0 nsec
test_fentry:PASS:t4:b 0 nsec
test_fentry:PASS:t4:c 0 nsec
test_fentry:PASS:t4:d 0 nsec
test_fentry:PASS:t4:e.a 0 nsec
test_fentry:PASS:t4:e.b 0 nsec
test_fentry:PASS:t4 ret 0 nsec
test_fentry:PASS:t5 ret 0 nsec
#209 tracing_struct:FAIL
#210 trampoline_count:OK
[...]
Re: [PATCH bpf-next v3 6/7] selftests/bpf: Add struct argument tests with fentry/fexit programs.
Quoted 27 lines · Daniel Borkmann
Quoted 4 lines · Yonghong Song
Add various struct argument tests with fentry/fexit programs. Also add one test with a kernel func which does not have any argument to test
BPF_PROG2macro in such situation.Quoted 9 lines
Signed-off-by Yonghong Song <[email protected]>--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++ .../selftests/bpf/prog_tests/tracing_struct.c | 63 ++++++++++ .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++ 3 files changed, 225 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/tracing_struct.ccreate mode 100644tools/testing/selftests/bpf/progs/tracing_struct.cFor s390x these tests need to be deny-listed due to missing trampoline support..
All error logs:
test_fentry:PASS:tracing_struct__open_and_load 0 nsec
libbpf: prog 'test_struct_arg_1': failed to attach: ERROR: strerror_r(-524)=22
libbpf: prog 'test_struct_arg_1': failed to auto-attach: -524 test_fentry:FAIL:tracing_struct__attach unexpected error: -524 (errno 524)
#209 tracing_struct:FAIL
Summary: 189/972 PASSED, 27 SKIPPED, 1 FAILEDHowever, looks like the
no_alu32ones on x86 fail:
Quoted 15 lines
[...]
#207 trace_printk:OK
#208 trace_vprintk:OK
test_fentry:PASS:tracing_struct__open_and_load 0 nsec test_fentry:PASS:tracing_struct__attach 0 nsec trigger_module_test_read:PASS:testmod_file_open 0 nsec test_fentry:PASS:trigger_read 0 nsec
test_fentry:PASS:t1:a.a 0 nsec
test_fentry:PASS:t1:a.b 0 nsec
test_fentry:PASS:t1:b 0 nsec
test_fentry:PASS:t1:c 0 nsec
test_fentry:PASS:t1 nregs 0 nsec
test_fentry:PASS:t1 reg0 0 nsec
test_fentry:PASS:t1 reg1 0 nsec
test_fentry:FAIL:t1 reg2 unexpected t1 reg2: actual 7327499336969879553 != expected 1
I'm getting the same, I think it's because the argument is int (4 bytes) while the register is 8, we need to cast to int before we check for the argument value
jirka
Quoted 23 lines
test_fentry:PASS:t1 reg3 0 nsec
test_fentry:PASS:t1 ret 0 nsec
test_fentry:PASS:t2:a 0 nsec
test_fentry:PASS:t2:b.a 0 nsec
test_fentry:PASS:t2:b.b 0 nsec
test_fentry:PASS:t2:c 0 nsec
test_fentry:PASS:t2 ret 0 nsec
test_fentry:PASS:t3:a 0 nsec
test_fentry:PASS:t3:b 0 nsec
test_fentry:PASS:t3:c.a 0 nsec
test_fentry:PASS:t3:c.b 0 nsec
test_fentry:PASS:t3 ret 0 nsec
test_fentry:PASS:t4:a.a 0 nsec
test_fentry:PASS:t4:b 0 nsec
test_fentry:PASS:t4:c 0 nsec
test_fentry:PASS:t4:d 0 nsec
test_fentry:PASS:t4:e.a 0 nsec
test_fentry:PASS:t4:e.b 0 nsec
test_fentry:PASS:t4 ret 0 nsec
test_fentry:PASS:t5 ret 0 nsec
#209 tracing_struct:FAIL
#210 trampoline_count:OK
[...]
Re: [PATCH bpf-next v3 6/7] selftests/bpf: Add struct argument tests with fentry/fexit programs.
Quoted 44 lines · Jiri Olsa
Quoted 27 lines · Daniel Borkmann
Quoted 4 lines · Yonghong Song
Add various struct argument tests with fentry/fexit programs. Also add one test with a kernel func which does not have any argument to test
BPF_PROG2macro in such situation.Quoted 9 lines
Signed-off-by Yonghong Song <[email protected]>--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++ .../selftests/bpf/prog_tests/tracing_struct.c | 63 ++++++++++ .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++ 3 files changed, 225 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/tracing_struct.ccreate mode 100644tools/testing/selftests/bpf/progs/tracing_struct.cFor s390x these tests need to be deny-listed due to missing trampoline support..
All error logs:
test_fentry:PASS:tracing_struct__open_and_load 0 nsec
libbpf: prog 'test_struct_arg_1': failed to attach: ERROR: strerror_r(-524)=22
libbpf: prog 'test_struct_arg_1': failed to auto-attach: -524 test_fentry:FAIL:tracing_struct__attach unexpected error: -524 (errno 524)
#209 tracing_struct:FAIL
Summary: 189/972 PASSED, 27 SKIPPED, 1 FAILEDHowever, looks like the
no_alu32ones on x86 fail:Quoted 15 lines
[...]
#207 trace_printk:OK
#208 trace_vprintk:OK
test_fentry:PASS:tracing_struct__open_and_load 0 nsec test_fentry:PASS:tracing_struct__attach 0 nsec trigger_module_test_read:PASS:testmod_file_open 0 nsec test_fentry:PASS:trigger_read 0 nsec
test_fentry:PASS:t1:a.a 0 nsec
test_fentry:PASS:t1:a.b 0 nsec
test_fentry:PASS:t1:b 0 nsec
test_fentry:PASS:t1:c 0 nsec
test_fentry:PASS:t1 nregs 0 nsec
test_fentry:PASS:t1 reg0 0 nsec
test_fentry:PASS:t1 reg1 0 nsec
test_fentry:FAIL:t1 reg2 unexpected t1 reg2: actual 7327499336969879553 != expected 1
Quoted 3 lines
I'm getting the same, I think it's because the argument is int (4 bytes) while the register is 8, we need to cast to int before we check for the argument value
Good point! Indeed bpf_get_func_arg() gets a 64bit value and I need to cast it to 32bit.
Quoted 26 lines
jirka
Quoted 23 lines
test_fentry:PASS:t1 reg3 0 nsec
test_fentry:PASS:t1 ret 0 nsec
test_fentry:PASS:t2:a 0 nsec
test_fentry:PASS:t2:b.a 0 nsec
test_fentry:PASS:t2:b.b 0 nsec
test_fentry:PASS:t2:c 0 nsec
test_fentry:PASS:t2 ret 0 nsec
test_fentry:PASS:t3:a 0 nsec
test_fentry:PASS:t3:b 0 nsec
test_fentry:PASS:t3:c.a 0 nsec
test_fentry:PASS:t3:c.b 0 nsec
test_fentry:PASS:t3 ret 0 nsec
test_fentry:PASS:t4:a.a 0 nsec
test_fentry:PASS:t4:b 0 nsec
test_fentry:PASS:t4:c 0 nsec
test_fentry:PASS:t4:d 0 nsec
test_fentry:PASS:t4:e.a 0 nsec
test_fentry:PASS:t4:e.b 0 nsec
test_fentry:PASS:t4 ret 0 nsec
test_fentry:PASS:t5 ret 0 nsec
#209 tracing_struct:FAIL
#210 trampoline_count:OK
[...]
Re: [PATCH bpf-next v3 6/7] selftests/bpf: Add struct argument tests with fentry/fexit programs.
In reply to Daniel BorkmannQuoted 17 lines · Daniel Borkmann
Quoted 4 lines · Yonghong Song
Add various struct argument tests with fentry/fexit programs. Also add one test with a kernel func which does not have any argument to test
BPF_PROG2macro in such situation.Quoted 9 lines
Signed-off-by Yonghong Song <[email protected]>---
.../selftests/bpf/bpf_testmod/bpf_testmod.c | 48 ++++++++.../selftests/bpf/prog_tests/tracing_struct.c| 63 ++++++++++ .../selftests/bpf/progs/tracing_struct.c | 114 ++++++++++++++++++3 files changed, 225 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/tracing_struct.ccreate mode 100644tools/testing/selftests/bpf/progs/tracing_struct.cFor s390x these tests need to be deny-listed due to missing trampoline support..
Quoted 9 lines
All error logs:
test_fentry:PASS:tracing_struct__open_and_load 0 nsec
libbpf: prog 'test_struct_arg_1': failed to attach: ERROR:
strerror_r(-524)=22
libbpf: prog 'test_struct_arg_1': failed to auto-attach: -524 test_fentry:FAIL:tracing_struct__attach unexpected error: -524 (errno
524)
#209 tracing_struct:FAIL
Summary: 189/972 PASSED, 27 SKIPPED, 1 FAILED
Thanks. will add the test to deny list.
Quoted 34 lines
However, looks like the
no_alu32ones on x86 fail:[...]
#207 trace_printk:OK
#208 trace_vprintk:OK test_fentry:PASS:tracing_struct__open_and_load 0 nsec test_fentry:PASS:tracing_struct__attach 0 nsec trigger_module_test_read:PASS:testmod_file_open 0 nsec test_fentry:PASS:trigger_read 0 nsec test_fentry:PASS:t1:a.a 0 nsec test_fentry:PASS:t1:a.b 0 nsec test_fentry:PASS:t1:b 0 nsec test_fentry:PASS:t1:c 0 nsec test_fentry:PASS:t1 nregs 0 nsec test_fentry:PASS:t1 reg0 0 nsec test_fentry:PASS:t1 reg1 0 nsec test_fentry:FAIL:t1 reg2 unexpected t1 reg2: actual
7327499336969879553 != expected 1
test_fentry:PASS:t1 reg3 0 nsec test_fentry:PASS:t1 ret 0 nsec test_fentry:PASS:t2:a 0 nsec test_fentry:PASS:t2:b.a 0 nsec test_fentry:PASS:t2:b.b 0 nsec test_fentry:PASS:t2:c 0 nsec test_fentry:PASS:t2 ret 0 nsec test_fentry:PASS:t3:a 0 nsec test_fentry:PASS:t3:b 0 nsec test_fentry:PASS:t3:c.a 0 nsec test_fentry:PASS:t3:c.b 0 nsec test_fentry:PASS:t3 ret 0 nsec test_fentry:PASS:t4:a.a 0 nsec test_fentry:PASS:t4:b 0 nsec test_fentry:PASS:t4:c 0 nsec
Quoted 8 lines
test_fentry:PASS:t4:d 0 nsec
test_fentry:PASS:t4:e.a 0 nsec
test_fentry:PASS:t4:e.b 0 nsec
test_fentry:PASS:t4 ret 0 nsec
test_fentry:PASS:t5 ret 0 nsec
#209 tracing_struct:FAIL
#210 trampoline_count:OK
[...]
Thanks for the headsup. Will check.
PATCH v3 7/7 selftests/bpf: Use BPF_PROG2 for some fentry programs without struct arguments
In reply to Yonghong SongUse BPF_PROG2 instead of BPF_PROG for programs in progs/timer.c to test BPF_PROG2 for cases without struct arguments.
--- tools/testing/selftests/bpf/progs/timer.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
tools/testing/selftests/bpf/progs/timer.c +2 -2
@@ -120,7 +120,7 @@ static int timer_cb1(void *map, int *key, struct bpf_timer *timer) } SEC("fentry/bpf_fentry_test1") -int BPF_PROG (test1 ,int a) +int BPF_PROG2 (test1 ,int ,a ) {struct bpf_timer *arr_timer, *lru_timer;struct elem init = {};
@@ -247,7 +247,7 @@ int bpf_timer_test(void) } SEC("fentry/bpf_fentry_test2") -int BPF_PROG (test2 ,int a,int b) +int BPF_PROG2 (test2 ,int ,a ,int ,b ) {struct hmap_elem init = {}, *val;int key =HTAB , key_malloc =HTAB_MALLOC ;
Signature · 1 line
2.30.2