* [PATCH bpf-next v8 0/3] bpf, x86: allow function arguments up to 12 for TRACING
@ 2023-06-27 11:53 menglong8.dong
2023-06-27 11:53 ` [PATCH bpf-next v8 1/3] bpf, x86: save/restore regs with BPF_DW size menglong8.dong
` (2 more replies)
0 siblings, 3 replies; 5+ messages in thread
From: menglong8.dong @ 2023-06-27 11:53 UTC (permalink / raw)
To: daniel, yhs, alexei.starovoitov
Cc: ast, andrii, martin.lau, song, yhs, john.fastabend, kpsingh, sdf,
haoluo, jolsa, bpf, linux-kernel, linux-arm-kernel, Menglong Dong
From: Menglong Dong <imagedong@tencent.com>
For now, the BPF program of type BPF_PROG_TYPE_TRACING can only be used
on the kernel functions whose arguments count less than or equal to 6, if
not considering '> 8 bytes' struct argument. This is not friendly at all,
as too many functions have arguments count more than 6. According to the
current kernel version, below is a statistics of the function arguments
count:
argument count | function count
7 | 704
8 | 270
9 | 84
10 | 47
11 | 47
12 | 27
13 | 22
14 | 5
15 | 0
16 | 1
Therefore, let's enhance it by increasing the function arguments count
allowed in arch_prepare_bpf_trampoline(), for now, only x86_64.
In the 1st patch, we save/restore regs with BPF_DW size to make the code
in save_regs()/restore_regs() simpler.
In the 2nd patch, we make arch_prepare_bpf_trampoline() support to copy
function arguments in stack for x86 arch. Therefore, the maximum
arguments can be up to MAX_BPF_FUNC_ARGS for FENTRY, FEXIT and
MODIFY_RETURN. Meanwhile, we clean the potential garbage value when we
copy the arguments on-stack.
And the 3rd patch is for the testcases of the this series.
Changes since v7:
- split the testcases, and add fentry_many_args/fexit_many_args to
DENYLIST.aarch64 in 3rd patch
Changes since v6:
- somit nits from commit message and comment in the 1st patch
- remove the inline in get_nr_regs() in the 1st patch
- rename some function and various in the 1st patch
Changes since v5:
- adjust the commit log of the 1st patch, avoiding confusing people that
bugs exist in current code
- introduce get_nr_regs() to get the space that used to pass args on
stack correct in the 2nd patch
- add testcases to tracing_struct.c instead of fentry_test.c and
fexit_test.c
Changes since v4:
- consider the case of the struct in arguments can't be hold by regs
- add comment for some code
- add testcases for MODIFY_RETURN
- rebase to the latest
Changes since v3:
- try make the stack pointer 16-byte aligned. Not sure if I'm right :)
- introduce clean_garbage() to clean the grabage when argument count is 7
- use different data type in bpf_testmod_fentry_test{7,12}
- add testcase for grabage values in ctx
Changes since v2:
- keep MAX_BPF_FUNC_ARGS still
- clean garbage value in upper bytes in the 2nd patch
- move bpf_fentry_test{7,12} to bpf_testmod.c and rename them to
bpf_testmod_fentry_test{7,12} meanwhile in the 3rd patch
Changes since v1:
- change the maximun function arguments to 14 from 12
- add testcases (Jiri Olsa)
- instead EMIT4 with EMIT3_off32 for "lea" to prevent overflow
Menglong Dong (3):
bpf, x86: save/restore regs with BPF_DW size
bpf, x86: allow function arguments up to 12 for TRACING
selftests/bpf: add testcase for TRACING with 6+ arguments
arch/x86/net/bpf_jit_comp.c | 246 +++++++++++++++---
net/bpf/test_run.c | 23 +-
tools/testing/selftests/bpf/DENYLIST.aarch64 | 2 +
.../selftests/bpf/bpf_testmod/bpf_testmod.c | 49 +++-
.../selftests/bpf/prog_tests/fentry_test.c | 43 ++-
.../selftests/bpf/prog_tests/fexit_test.c | 43 ++-
.../selftests/bpf/prog_tests/modify_return.c | 20 +-
.../selftests/bpf/prog_tests/tracing_struct.c | 19 ++
.../selftests/bpf/progs/fentry_many_args.c | 39 +++
.../selftests/bpf/progs/fexit_many_args.c | 40 +++
.../selftests/bpf/progs/modify_return.c | 40 +++
.../selftests/bpf/progs/tracing_struct.c | 54 ++++
12 files changed, 561 insertions(+), 57 deletions(-)
create mode 100644 tools/testing/selftests/bpf/progs/fentry_many_args.c
create mode 100644 tools/testing/selftests/bpf/progs/fexit_many_args.c
--
2.40.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 5+ messages in thread* [PATCH bpf-next v8 1/3] bpf, x86: save/restore regs with BPF_DW size 2023-06-27 11:53 [PATCH bpf-next v8 0/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong @ 2023-06-27 11:53 ` menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 2/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments menglong8.dong 2 siblings, 0 replies; 5+ messages in thread From: menglong8.dong @ 2023-06-27 11:53 UTC (permalink / raw) To: daniel, yhs, alexei.starovoitov Cc: ast, andrii, martin.lau, song, yhs, john.fastabend, kpsingh, sdf, haoluo, jolsa, bpf, linux-kernel, linux-arm-kernel, Menglong Dong From: Menglong Dong <imagedong@tencent.com> As we already reserve 8 byte in the stack for each reg, it is ok to store/restore the regs in BPF_DW size. This will make the code in save_regs()/restore_regs() simpler. Signed-off-by: Menglong Dong <imagedong@tencent.com> Acked-by: Yonghong Song <yhs@fb.com> --- v6: - adjust the commit log --- arch/x86/net/bpf_jit_comp.c | 35 ++++++----------------------------- 1 file changed, 6 insertions(+), 29 deletions(-) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index 1056bbf55b17..a407fbbffecd 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -1860,57 +1860,34 @@ st: if (is_imm8(insn->off)) static void save_regs(const struct btf_func_model *m, u8 **prog, int nr_regs, int stack_size) { - int i, j, arg_size; - bool next_same_struct = false; + int i; /* 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, j = 0; i < min(nr_regs, 6); i++) { - /* The arg_size is at most 16 bytes, enforced by the verifier. */ - arg_size = m->arg_size[j]; - if (arg_size > 8) { - arg_size = 8; - next_same_struct = !next_same_struct; - } - - emit_stx(prog, bytes_to_bpf_size(arg_size), - BPF_REG_FP, + for (i = 0; i < min(nr_regs, 6); i++) + emit_stx(prog, BPF_DW, BPF_REG_FP, i == 5 ? X86_REG_R9 : BPF_REG_1 + i, -(stack_size - i * 8)); - - j = next_same_struct ? j : j + 1; - } } static void restore_regs(const struct btf_func_model *m, u8 **prog, int nr_regs, int stack_size) { - int i, j, arg_size; - bool next_same_struct = false; + int i; /* 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, j = 0; i < min(nr_regs, 6); i++) { - /* The arg_size is at most 16 bytes, enforced by the verifier. */ - arg_size = m->arg_size[j]; - if (arg_size > 8) { - arg_size = 8; - next_same_struct = !next_same_struct; - } - - emit_ldx(prog, bytes_to_bpf_size(arg_size), + for (i = 0; i < min(nr_regs, 6); i++) + emit_ldx(prog, BPF_DW, i == 5 ? X86_REG_R9 : BPF_REG_1 + i, BPF_REG_FP, -(stack_size - i * 8)); - - j = next_same_struct ? j : j + 1; - } } static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, -- 2.40.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH bpf-next v8 2/3] bpf, x86: allow function arguments up to 12 for TRACING 2023-06-27 11:53 [PATCH bpf-next v8 0/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 1/3] bpf, x86: save/restore regs with BPF_DW size menglong8.dong @ 2023-06-27 11:53 ` menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments menglong8.dong 2 siblings, 0 replies; 5+ messages in thread From: menglong8.dong @ 2023-06-27 11:53 UTC (permalink / raw) To: daniel, yhs, alexei.starovoitov Cc: ast, andrii, martin.lau, song, yhs, john.fastabend, kpsingh, sdf, haoluo, jolsa, bpf, linux-kernel, linux-arm-kernel, Menglong Dong From: Menglong Dong <imagedong@tencent.com> For now, the BPF program of type BPF_PROG_TYPE_TRACING can only be used on the kernel functions whose arguments count less than or equal to 6, if not considering '> 8 bytes' struct argument. This is not friendly at all, as too many functions have arguments count more than 6. According to the current kernel version, below is a statistics of the function arguments count: argument count | function count 7 | 704 8 | 270 9 | 84 10 | 47 11 | 47 12 | 27 13 | 22 14 | 5 15 | 0 16 | 1 Therefore, let's enhance it by increasing the function arguments count allowed in arch_prepare_bpf_trampoline(), for now, only x86_64. For the case that we don't need to call origin function, which means without BPF_TRAMP_F_CALL_ORIG, we need only copy the function arguments that stored in the frame of the caller to current frame. The 7th and later arguments are stored in "$rbp + 0x18", and they will be copied to the stack area following where register values are saved. For the case with BPF_TRAMP_F_CALL_ORIG, we need prepare the arguments in stack before call origin function, which means we need alloc extra "8 * (arg_count - 6)" memory in the top of the stack. Note, there should not be any data be pushed to the stack before calling the origin function. So 'rbx' value will be stored on a stack position higher than where stack arguments are stored for BPF_TRAMP_F_CALL_ORIG. According to the research of Yonghong, struct members should be all in register or all on the stack. Meanwhile, the compiler will pass the argument on regs if the remaining regs can hold the argument. Therefore, we need save the arguments in order. Otherwise, disorder of the args can happen. For example: struct foo_struct { long a; int b; }; int foo(char, char, char, char, char, struct foo_struct, char); the arg1-5,arg7 will be passed by regs, and arg6 will by stack. Therefore, we should save/restore the arguments in the same order with the declaration of foo(). And the args used as ctx in stack will be like this: reg_arg6 -- copy from regs stack_arg2 -- copy from stack stack_arg1 reg_arg5 -- copy from regs reg_arg4 reg_arg3 reg_arg2 reg_arg1 We use EMIT3_off32() or EMIT4() for "lea" and "sub". The range of the imm in "lea" and "sub" is [-128, 127] if EMIT4() is used. Therefore, we use EMIT3_off32() instead if the imm out of the range. It works well for the FENTRY/FEXIT/MODIFY_RETURN. Signed-off-by: Menglong Dong <imagedong@tencent.com> Acked-by: Yonghong Song <yhs@fb.com> --- v7: - somit nits from commit message and comment - remove the inline in get_nr_regs() - rename some function and various v6: - introduce get_nr_regs() to get the space that used to pass args on stack correct - rename some args and fix some spelling mistake v5: - consider the case of the struct in arguments can't be hold by regs v4: - make the stack 16-byte aligned if passing args on-stack is needed - add the function arguments statistics to the commit log v3: - use EMIT3_off32() for "lea" and "sub" only on necessary - make 12 as the maximum arguments count v2: - instead EMIT4 with EMIT3_off32 for "lea" to prevent overflow - make MAX_BPF_FUNC_ARGS as the maximum argument count --- arch/x86/net/bpf_jit_comp.c | 235 ++++++++++++++++++++++++++++++++---- 1 file changed, 209 insertions(+), 26 deletions(-) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index a407fbbffecd..08608284041a 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -1857,37 +1857,178 @@ st: if (is_imm8(insn->off)) return proglen; } -static void save_regs(const struct btf_func_model *m, u8 **prog, int nr_regs, - int stack_size) +static void clean_stack_garbage(const struct btf_func_model *m, + u8 **pprog, int nr_stack_slots, + int stack_size) { - int i; + int arg_size, off; + u8 *prog; + + /* Generally speaking, the compiler will pass the arguments + * on-stack with "push" instruction, which will take 8-byte + * on the stack. In this case, there won't be garbage values + * while we copy the arguments from origin stack frame to current + * in BPF_DW. + * + * However, sometimes the compiler will only allocate 4-byte on + * the stack for the arguments. For now, this case will only + * happen if there is only one argument on-stack and its size + * not more than 4 byte. In this case, there will be garbage + * values on the upper 4-byte where we store the argument on + * current stack frame. + * + * arguments on origin stack: + * + * stack_arg_1(4-byte) xxx(4-byte) + * + * what we copy: + * + * stack_arg_1(8-byte): stack_arg_1(origin) xxx + * + * and the xxx is the garbage values which we should clean here. + */ + if (nr_stack_slots != 1) + return; + + /* the size of the last argument */ + arg_size = m->arg_size[m->nr_args - 1]; + if (arg_size <= 4) { + off = -(stack_size - 4); + prog = *pprog; + /* mov DWORD PTR [rbp + off], 0 */ + if (!is_imm8(off)) + EMIT2_off32(0xC7, 0x85, off); + else + EMIT3(0xC7, 0x45, off); + EMIT(0, 4); + *pprog = prog; + } +} + +/* get the count of the regs that are used to pass arguments */ +static int get_nr_used_regs(const struct btf_func_model *m) +{ + int i, arg_regs, nr_used_regs = 0; + + for (i = 0; i < min_t(int, m->nr_args, MAX_BPF_FUNC_ARGS); i++) { + arg_regs = (m->arg_size[i] + 7) / 8; + if (nr_used_regs + arg_regs <= 6) + nr_used_regs += arg_regs; + + if (nr_used_regs >= 6) + break; + } + + return nr_used_regs; +} + +static void save_args(const struct btf_func_model *m, u8 **prog, + int stack_size, bool for_call_origin) +{ + int arg_regs, first_off, nr_regs = 0, nr_stack_slots = 0; + int i, j; /* 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_regs, 6); i++) - emit_stx(prog, BPF_DW, BPF_REG_FP, - i == 5 ? X86_REG_R9 : BPF_REG_1 + i, - -(stack_size - i * 8)); + for (i = 0; i < min_t(int, m->nr_args, MAX_BPF_FUNC_ARGS); i++) { + arg_regs = (m->arg_size[i] + 7) / 8; + + /* According to the research of Yonghong, struct members + * should be all in register or all on the stack. + * Meanwhile, the compiler will pass the argument on regs + * if the remaining regs can hold the argument. + * + * Disorder of the args can happen. For example: + * + * struct foo_struct { + * long a; + * int b; + * }; + * int foo(char, char, char, char, char, struct foo_struct, + * char); + * + * the arg1-5,arg7 will be passed by regs, and arg6 will + * by stack. + */ + if (nr_regs + arg_regs > 6) { + /* copy function arguments from origin stack frame + * into current stack frame. + * + * The starting address of the arguments on-stack + * is: + * rbp + 8(push rbp) + + * 8(return addr of origin call) + + * 8(return addr of the caller) + * which means: rbp + 24 + */ + for (j = 0; j < arg_regs; j++) { + emit_ldx(prog, BPF_DW, BPF_REG_0, BPF_REG_FP, + nr_stack_slots * 8 + 0x18); + emit_stx(prog, BPF_DW, BPF_REG_FP, BPF_REG_0, + -stack_size); + + if (!nr_stack_slots) + first_off = stack_size; + stack_size -= 8; + nr_stack_slots++; + } + } else { + /* Only copy the arguments on-stack to current + * 'stack_size' and ignore the regs, used to + * prepare the arguments on-stack for orign call. + */ + if (for_call_origin) { + nr_regs += arg_regs; + continue; + } + + /* copy the arguments from regs into stack */ + for (j = 0; j < arg_regs; j++) { + emit_stx(prog, BPF_DW, BPF_REG_FP, + nr_regs == 5 ? X86_REG_R9 : BPF_REG_1 + nr_regs, + -stack_size); + stack_size -= 8; + nr_regs++; + } + } + } + + clean_stack_garbage(m, prog, nr_stack_slots, first_off); } -static void restore_regs(const struct btf_func_model *m, u8 **prog, int nr_regs, +static void restore_regs(const struct btf_func_model *m, u8 **prog, int stack_size) { - int i; + int i, j, arg_regs, nr_regs = 0; /* 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] + * + * The logic here is similar to what we do in save_args() */ - for (i = 0; i < min(nr_regs, 6); i++) - emit_ldx(prog, BPF_DW, - i == 5 ? X86_REG_R9 : BPF_REG_1 + i, - BPF_REG_FP, - -(stack_size - i * 8)); + for (i = 0; i < min_t(int, m->nr_args, MAX_BPF_FUNC_ARGS); i++) { + arg_regs = (m->arg_size[i] + 7) / 8; + if (nr_regs + arg_regs <= 6) { + for (j = 0; j < arg_regs; j++) { + emit_ldx(prog, BPF_DW, + nr_regs == 5 ? X86_REG_R9 : BPF_REG_1 + nr_regs, + BPF_REG_FP, + -stack_size); + stack_size -= 8; + nr_regs++; + } + } else { + stack_size -= 8 * arg_regs; + } + + if (nr_regs >= 6) + break; + } } static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, @@ -1915,7 +2056,10 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, /* arg1: mov rdi, progs[i] */ emit_mov_imm64(&prog, BPF_REG_1, (long) p >> 32, (u32) (long) p); /* arg2: lea rsi, [rbp - ctx_cookie_off] */ - EMIT4(0x48, 0x8D, 0x75, -run_ctx_off); + if (!is_imm8(-run_ctx_off)) + EMIT3_off32(0x48, 0x8D, 0xB5, -run_ctx_off); + else + EMIT4(0x48, 0x8D, 0x75, -run_ctx_off); if (emit_rsb_call(&prog, bpf_trampoline_enter(p), prog)) return -EINVAL; @@ -1931,7 +2075,10 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, emit_nops(&prog, 2); /* arg1: lea rdi, [rbp - stack_size] */ - EMIT4(0x48, 0x8D, 0x7D, -stack_size); + if (!is_imm8(-stack_size)) + EMIT3_off32(0x48, 0x8D, 0xBD, -stack_size); + else + EMIT4(0x48, 0x8D, 0x7D, -stack_size); /* arg2: progs[i]->insnsi for interpreter */ if (!p->jited) emit_mov_imm64(&prog, BPF_REG_2, @@ -1961,7 +2108,10 @@ static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, /* arg2: mov rsi, rbx <- start time in nsec */ emit_mov_reg(&prog, true, BPF_REG_2, BPF_REG_6); /* arg3: lea rdx, [rbp - run_ctx_off] */ - EMIT4(0x48, 0x8D, 0x55, -run_ctx_off); + if (!is_imm8(-run_ctx_off)) + EMIT3_off32(0x48, 0x8D, 0x95, -run_ctx_off); + else + EMIT4(0x48, 0x8D, 0x55, -run_ctx_off); if (emit_rsb_call(&prog, bpf_trampoline_exit(p), prog)) return -EINVAL; @@ -2113,7 +2263,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i void *func_addr) { int i, ret, nr_regs = m->nr_args, stack_size = 0; - int regs_off, nregs_off, ip_off, run_ctx_off; + int regs_off, nregs_off, ip_off, run_ctx_off, arg_stack_off, rbx_off; struct bpf_tramp_links *fentry = &tlinks[BPF_TRAMP_FENTRY]; struct bpf_tramp_links *fexit = &tlinks[BPF_TRAMP_FEXIT]; struct bpf_tramp_links *fmod_ret = &tlinks[BPF_TRAMP_MODIFY_RETURN]; @@ -2127,8 +2277,10 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i if (m->arg_flags[i] & BTF_FMODEL_STRUCT_ARG) nr_regs += (m->arg_size[i] + 7) / 8 - 1; - /* x86-64 supports up to 6 arguments. 7+ can be added in the future */ - if (nr_regs > 6) + /* x86-64 supports up to MAX_BPF_FUNC_ARGS arguments. 1-6 + * are passed through regs, the remains are through stack. + */ + if (nr_regs > MAX_BPF_FUNC_ARGS) return -ENOTSUPP; /* Generated trampoline stack layout: @@ -2147,7 +2299,14 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i * * RBP - ip_off [ traced function ] BPF_TRAMP_F_IP_ARG flag * + * RBP - rbx_off [ rbx value ] always + * * RBP - run_ctx_off [ bpf_tramp_run_ctx ] + * + * [ stack_argN ] BPF_TRAMP_F_CALL_ORIG + * [ ... ] + * [ stack_arg2 ] + * RBP - arg_stack_off [ stack_arg1 ] */ /* room for return value of orig_call or fentry prog */ @@ -2167,9 +2326,26 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i ip_off = stack_size; + stack_size += 8; + rbx_off = stack_size; + stack_size += (sizeof(struct bpf_tramp_run_ctx) + 7) & ~0x7; run_ctx_off = stack_size; + if (nr_regs > 6 && (flags & BPF_TRAMP_F_CALL_ORIG)) { + /* the space that used to pass arguments on-stack */ + stack_size += (nr_regs - get_nr_used_regs(m)) * 8; + /* make sure the stack pointer is 16-byte aligned if we + * need pass arguments on stack, which means + * [stack_size + 8(rbp) + 8(rip) + 8(origin rip)] + * should be 16-byte aligned. Following code depend on + * that stack_size is already 8-byte aligned. + */ + stack_size += (stack_size % 16) ? 0 : 8; + } + + arg_stack_off = stack_size; + if (flags & BPF_TRAMP_F_SKIP_FRAME) { /* skip patched call instruction and point orig_call to actual * body of the kernel function. @@ -2189,8 +2365,14 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i x86_call_depth_emit_accounting(&prog, NULL); EMIT1(0x55); /* push rbp */ EMIT3(0x48, 0x89, 0xE5); /* mov rbp, rsp */ - EMIT4(0x48, 0x83, 0xEC, stack_size); /* sub rsp, stack_size */ - EMIT1(0x53); /* push rbx */ + if (!is_imm8(stack_size)) + /* sub rsp, stack_size */ + EMIT3_off32(0x48, 0x81, 0xEC, stack_size); + else + /* sub rsp, stack_size */ + EMIT4(0x48, 0x83, 0xEC, stack_size); + /* mov QWORD PTR [rbp - rbx_off], rbx */ + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_6, -rbx_off); /* Store number of argument registers of the traced function: * mov rax, nr_regs @@ -2208,7 +2390,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -ip_off); } - save_regs(m, &prog, nr_regs, regs_off); + save_args(m, &prog, regs_off, false); if (flags & BPF_TRAMP_F_CALL_ORIG) { /* arg1: mov rdi, im */ @@ -2238,7 +2420,8 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i } if (flags & BPF_TRAMP_F_CALL_ORIG) { - restore_regs(m, &prog, nr_regs, regs_off); + restore_regs(m, &prog, regs_off); + save_args(m, &prog, arg_stack_off, true); if (flags & BPF_TRAMP_F_ORIG_STACK) { emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, 8); @@ -2279,7 +2462,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i } if (flags & BPF_TRAMP_F_RESTORE_REGS) - restore_regs(m, &prog, nr_regs, regs_off); + restore_regs(m, &prog, regs_off); /* This needs to be done regardless. If there were fmod_ret programs, * the return value is only updated on the stack and still needs to be @@ -2298,7 +2481,7 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_image *im, void *image, void *i if (save_ret) emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8); - EMIT1(0x5B); /* pop rbx */ + emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, -rbx_off); EMIT1(0xC9); /* leave */ if (flags & BPF_TRAMP_F_SKIP_FRAME) /* skip our return address and return to parent */ -- 2.40.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments 2023-06-27 11:53 [PATCH bpf-next v8 0/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 1/3] bpf, x86: save/restore regs with BPF_DW size menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 2/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong @ 2023-06-27 11:53 ` menglong8.dong 2023-07-05 1:47 ` Menglong Dong 2 siblings, 1 reply; 5+ messages in thread From: menglong8.dong @ 2023-06-27 11:53 UTC (permalink / raw) To: daniel, yhs, alexei.starovoitov Cc: ast, andrii, martin.lau, song, yhs, john.fastabend, kpsingh, sdf, haoluo, jolsa, bpf, linux-kernel, linux-arm-kernel, Menglong Dong From: Menglong Dong <imagedong@tencent.com> Add fentry_many_args.c and fexit_many_args.c to test the fentry/fexit with 7/11 arguments. As this feature is not supported by arm64 yet, we disable these testcases for arm64 in DENYLIST.aarch64. We can combine them with fentry_test.c/fexit_test.c when arm64 is supported too. Correspondingly, add bpf_testmod_fentry_test7() and bpf_testmod_fentry_test11() to bpf_testmod.c Meanwhile, add bpf_modify_return_test2() to test_run.c to test the MODIFY_RETURN with 7 arguments. Add bpf_testmod_test_struct_arg_7/bpf_testmod_test_struct_arg_7 in bpf_testmod.c to test the struct in the arguments. And the testcases passed on x86_64: ./test_progs -t fexit Summary: 5/14 PASSED, 0 SKIPPED, 0 FAILED ./test_progs -t fentry Summary: 3/2 PASSED, 0 SKIPPED, 0 FAILED ./test_progs -t modify_return Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED ./test_progs -t tracing_struct Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED Signed-off-by: Menglong Dong <imagedong@tencent.com> Acked-by: Yonghong Song <yhs@fb.com> --- v7: - split the testcases, and add fentry_many_args/fexit_many_args to DENYLIST.aarch64 v6: - add testcases to tracing_struct.c instead of fentry_test.c and fexit_test.c v5: - add testcases for MODIFY_RETURN v4: - use different type for args in bpf_testmod_fentry_test{7,12} - add testcase for grabage values in ctx v3: - move bpf_fentry_test{7,12} to bpf_testmod.c and rename them to bpf_testmod_fentry_test{7,12} meanwhile - get return value by bpf_get_func_ret() in "fexit/bpf_testmod_fentry_test12", as we don't change ___bpf_ctx_cast() in this version --- net/bpf/test_run.c | 23 ++++++-- tools/testing/selftests/bpf/DENYLIST.aarch64 | 2 + .../selftests/bpf/bpf_testmod/bpf_testmod.c | 49 ++++++++++++++++- .../selftests/bpf/prog_tests/fentry_test.c | 43 +++++++++++++-- .../selftests/bpf/prog_tests/fexit_test.c | 43 +++++++++++++-- .../selftests/bpf/prog_tests/modify_return.c | 20 ++++++- .../selftests/bpf/prog_tests/tracing_struct.c | 19 +++++++ .../selftests/bpf/progs/fentry_many_args.c | 39 ++++++++++++++ .../selftests/bpf/progs/fexit_many_args.c | 40 ++++++++++++++ .../selftests/bpf/progs/modify_return.c | 40 ++++++++++++++ .../selftests/bpf/progs/tracing_struct.c | 54 +++++++++++++++++++ 11 files changed, 358 insertions(+), 14 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/fentry_many_args.c create mode 100644 tools/testing/selftests/bpf/progs/fexit_many_args.c diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 2321bd2f9964..df58e8bf5e07 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -561,6 +561,13 @@ __bpf_kfunc int bpf_modify_return_test(int a, int *b) return a + *b; } +__bpf_kfunc int bpf_modify_return_test2(int a, int *b, short c, int d, + void *e, char f, int g) +{ + *b += 1; + return a + *b + c + d + (long)e + f + g; +} + int noinline bpf_fentry_shadow_test(int a) { return a + 1; @@ -596,9 +603,13 @@ __diag_pop(); BTF_SET8_START(bpf_test_modify_return_ids) BTF_ID_FLAGS(func, bpf_modify_return_test) +BTF_ID_FLAGS(func, bpf_modify_return_test2) BTF_ID_FLAGS(func, bpf_fentry_test1, KF_SLEEPABLE) BTF_SET8_END(bpf_test_modify_return_ids) +BTF_ID_LIST(bpf_modify_return_test_id) +BTF_ID(func, bpf_modify_return_test) + static const struct btf_kfunc_id_set bpf_test_modify_return_set = { .owner = THIS_MODULE, .set = &bpf_test_modify_return_ids, @@ -661,9 +672,15 @@ int bpf_prog_test_run_tracing(struct bpf_prog *prog, goto out; break; case BPF_MODIFY_RETURN: - ret = bpf_modify_return_test(1, &b); - if (b != 2) - side_effect = 1; + if (prog->aux->attach_btf_id == *bpf_modify_return_test_id) { + ret = bpf_modify_return_test(1, &b); + if (b != 2) + side_effect = 1; + } else { + ret = bpf_modify_return_test2(1, &b, 3, 4, (void *)5, 6, 7); + if (b != 2) + side_effect = 1; + } break; default: goto out; diff --git a/tools/testing/selftests/bpf/DENYLIST.aarch64 b/tools/testing/selftests/bpf/DENYLIST.aarch64 index 08adc805878b..3b61e8b35d62 100644 --- a/tools/testing/selftests/bpf/DENYLIST.aarch64 +++ b/tools/testing/selftests/bpf/DENYLIST.aarch64 @@ -10,3 +10,5 @@ kprobe_multi_test/link_api_addrs # link_fd unexpected link_fd: a kprobe_multi_test/link_api_syms # link_fd unexpected link_fd: actual -95 < expected 0 kprobe_multi_test/skel_api # libbpf: failed to load BPF skeleton 'kprobe_multi': -3 module_attach # prog 'kprobe_multi': failed to auto-attach: -95 +fentry_test/fentry_many_args # fentry_many_args:FAIL:fentry_many_args_attach unexpected error: -524 +fexit_test/fexit_many_args # fexit_many_args:FAIL:fexit_many_args_attach unexpected error: -524 diff --git a/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c b/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c index aaf6ef1201c7..a6f991b56345 100644 --- a/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +++ b/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c @@ -34,6 +34,11 @@ struct bpf_testmod_struct_arg_3 { int b[]; }; +struct bpf_testmod_struct_arg_4 { + u64 a; + int b; +}; + __diag_push(); __diag_ignore_all("-Wmissing-prototypes", "Global functions as their definitions will be in bpf_testmod.ko BTF"); @@ -75,6 +80,24 @@ bpf_testmod_test_struct_arg_6(struct bpf_testmod_struct_arg_3 *a) { return bpf_testmod_test_struct_arg_result; } +noinline int +bpf_testmod_test_struct_arg_7(u64 a, void *b, short c, int d, void *e, + struct bpf_testmod_struct_arg_4 f) +{ + bpf_testmod_test_struct_arg_result = a + (long)b + c + d + + (long)e + f.a + f.b; + return bpf_testmod_test_struct_arg_result; +} + +noinline int +bpf_testmod_test_struct_arg_8(u64 a, void *b, short c, int d, void *e, + struct bpf_testmod_struct_arg_4 f, int g) +{ + bpf_testmod_test_struct_arg_result = a + (long)b + c + d + + (long)e + f.a + f.b + g; + return bpf_testmod_test_struct_arg_result; +} + __bpf_kfunc void bpf_testmod_test_mod_kfunc(int i) { @@ -191,6 +214,20 @@ noinline int bpf_testmod_fentry_test3(char a, int b, u64 c) return a + b + c; } +noinline int bpf_testmod_fentry_test7(u64 a, void *b, short c, int d, + void *e, char f, int g) +{ + return a + (long)b + c + d + (long)e + f + g; +} + +noinline int bpf_testmod_fentry_test11(u64 a, void *b, short c, int d, + void *e, char f, int g, + unsigned int h, long i, __u64 j, + unsigned long k) +{ + return a + (long)b + c + d + (long)e + f + g + h + i + j + k; +} + int bpf_testmod_fentry_ok; noinline ssize_t @@ -206,6 +243,7 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bpf_testmod_struct_arg_1 struct_arg1 = {10}; struct bpf_testmod_struct_arg_2 struct_arg2 = {2, 3}; struct bpf_testmod_struct_arg_3 *struct_arg3; + struct bpf_testmod_struct_arg_4 struct_arg4 = {21, 22}; int i = 1; while (bpf_testmod_return_ptr(i)) @@ -216,6 +254,11 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, (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(); + (void)bpf_testmod_test_struct_arg_7(16, (void *)17, 18, 19, + (void *)20, struct_arg4); + (void)bpf_testmod_test_struct_arg_8(16, (void *)17, 18, 19, + (void *)20, struct_arg4, 23); + struct_arg3 = kmalloc((sizeof(struct bpf_testmod_struct_arg_3) + sizeof(int)), GFP_KERNEL); @@ -243,7 +286,11 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, if (bpf_testmod_fentry_test1(1) != 2 || bpf_testmod_fentry_test2(2, 3) != 5 || - bpf_testmod_fentry_test3(4, 5, 6) != 15) + bpf_testmod_fentry_test3(4, 5, 6) != 15 || + bpf_testmod_fentry_test7(16, (void *)17, 18, 19, (void *)20, + 21, 22) != 133 || + bpf_testmod_fentry_test11(16, (void *)17, 18, 19, (void *)20, + 21, 22, 23, 24, 25, 26) != 231) goto out; bpf_testmod_fentry_ok = 1; diff --git a/tools/testing/selftests/bpf/prog_tests/fentry_test.c b/tools/testing/selftests/bpf/prog_tests/fentry_test.c index c0d1d61d5f66..aee1bc77a17f 100644 --- a/tools/testing/selftests/bpf/prog_tests/fentry_test.c +++ b/tools/testing/selftests/bpf/prog_tests/fentry_test.c @@ -2,8 +2,9 @@ /* Copyright (c) 2019 Facebook */ #include <test_progs.h> #include "fentry_test.lskel.h" +#include "fentry_many_args.skel.h" -static int fentry_test(struct fentry_test_lskel *fentry_skel) +static int fentry_test_common(struct fentry_test_lskel *fentry_skel) { int err, prog_fd, i; int link_fd; @@ -37,7 +38,7 @@ static int fentry_test(struct fentry_test_lskel *fentry_skel) return 0; } -void test_fentry_test(void) +static void fentry_test(void) { struct fentry_test_lskel *fentry_skel = NULL; int err; @@ -46,13 +47,47 @@ void test_fentry_test(void) if (!ASSERT_OK_PTR(fentry_skel, "fentry_skel_load")) goto cleanup; - err = fentry_test(fentry_skel); + err = fentry_test_common(fentry_skel); if (!ASSERT_OK(err, "fentry_first_attach")) goto cleanup; - err = fentry_test(fentry_skel); + err = fentry_test_common(fentry_skel); ASSERT_OK(err, "fentry_second_attach"); cleanup: fentry_test_lskel__destroy(fentry_skel); } + +static void fentry_many_args(void) +{ + struct fentry_many_args *fentry_skel = NULL; + int err; + + fentry_skel = fentry_many_args__open_and_load(); + if (!ASSERT_OK_PTR(fentry_skel, "fentry_many_args_skel_load")) + goto cleanup; + + err = fentry_many_args__attach(fentry_skel); + if (!ASSERT_OK(err, "fentry_many_args_attach")) + goto cleanup; + + ASSERT_OK(trigger_module_test_read(1), "trigger_read"); + + ASSERT_EQ(fentry_skel->bss->test1_result, 1, + "fentry_many_args_result1"); + ASSERT_EQ(fentry_skel->bss->test2_result, 1, + "fentry_many_args_result2"); + ASSERT_EQ(fentry_skel->bss->test3_result, 1, + "fentry_many_args_result3"); + +cleanup: + fentry_many_args__destroy(fentry_skel); +} + +void test_fentry_test(void) +{ + if (test__start_subtest("fentry")) + fentry_test(); + if (test__start_subtest("fentry_many_args")) + fentry_many_args(); +} diff --git a/tools/testing/selftests/bpf/prog_tests/fexit_test.c b/tools/testing/selftests/bpf/prog_tests/fexit_test.c index 101b7343036b..1c13007e37dd 100644 --- a/tools/testing/selftests/bpf/prog_tests/fexit_test.c +++ b/tools/testing/selftests/bpf/prog_tests/fexit_test.c @@ -2,8 +2,9 @@ /* Copyright (c) 2019 Facebook */ #include <test_progs.h> #include "fexit_test.lskel.h" +#include "fexit_many_args.skel.h" -static int fexit_test(struct fexit_test_lskel *fexit_skel) +static int fexit_test_common(struct fexit_test_lskel *fexit_skel) { int err, prog_fd, i; int link_fd; @@ -37,7 +38,7 @@ static int fexit_test(struct fexit_test_lskel *fexit_skel) return 0; } -void test_fexit_test(void) +static void fexit_test(void) { struct fexit_test_lskel *fexit_skel = NULL; int err; @@ -46,13 +47,47 @@ void test_fexit_test(void) if (!ASSERT_OK_PTR(fexit_skel, "fexit_skel_load")) goto cleanup; - err = fexit_test(fexit_skel); + err = fexit_test_common(fexit_skel); if (!ASSERT_OK(err, "fexit_first_attach")) goto cleanup; - err = fexit_test(fexit_skel); + err = fexit_test_common(fexit_skel); ASSERT_OK(err, "fexit_second_attach"); cleanup: fexit_test_lskel__destroy(fexit_skel); } + +static void fexit_many_args(void) +{ + struct fexit_many_args *fexit_skel = NULL; + int err; + + fexit_skel = fexit_many_args__open_and_load(); + if (!ASSERT_OK_PTR(fexit_skel, "fexit_many_args_skel_load")) + goto cleanup; + + err = fexit_many_args__attach(fexit_skel); + if (!ASSERT_OK(err, "fexit_many_args_attach")) + goto cleanup; + + ASSERT_OK(trigger_module_test_read(1), "trigger_read"); + + ASSERT_EQ(fexit_skel->bss->test1_result, 1, + "fexit_many_args_result1"); + ASSERT_EQ(fexit_skel->bss->test2_result, 1, + "fexit_many_args_result2"); + ASSERT_EQ(fexit_skel->bss->test3_result, 1, + "fexit_many_args_result3"); + +cleanup: + fexit_many_args__destroy(fexit_skel); +} + +void test_fexit_test(void) +{ + if (test__start_subtest("fexit")) + fexit_test(); + if (test__start_subtest("fexit_many_args")) + fexit_many_args(); +} diff --git a/tools/testing/selftests/bpf/prog_tests/modify_return.c b/tools/testing/selftests/bpf/prog_tests/modify_return.c index 5d9955af6247..93febb6d81ef 100644 --- a/tools/testing/selftests/bpf/prog_tests/modify_return.c +++ b/tools/testing/selftests/bpf/prog_tests/modify_return.c @@ -11,7 +11,8 @@ #define UPPER(x) ((x) >> 16) -static void run_test(__u32 input_retval, __u16 want_side_effect, __s16 want_ret) +static void run_test(__u32 input_retval, __u16 want_side_effect, + __s16 want_ret, __s16 want_ret2) { struct modify_return *skel = NULL; int err, prog_fd; @@ -41,6 +42,19 @@ static void run_test(__u32 input_retval, __u16 want_side_effect, __s16 want_ret) ASSERT_EQ(skel->bss->fexit_result, 1, "modify_return fexit_result"); ASSERT_EQ(skel->bss->fmod_ret_result, 1, "modify_return fmod_ret_result"); + prog_fd = bpf_program__fd(skel->progs.fmod_ret_test2); + err = bpf_prog_test_run_opts(prog_fd, &topts); + ASSERT_OK(err, "test_run"); + + side_effect = UPPER(topts.retval); + ret = LOWER(topts.retval); + + ASSERT_EQ(ret, want_ret2, "test_run ret2"); + ASSERT_EQ(side_effect, want_side_effect, "modify_return side_effect2"); + ASSERT_EQ(skel->bss->fentry_result2, 1, "modify_return fentry_result2"); + ASSERT_EQ(skel->bss->fexit_result2, 1, "modify_return fexit_result2"); + ASSERT_EQ(skel->bss->fmod_ret_result2, 1, "modify_return fmod_ret_result2"); + cleanup: modify_return__destroy(skel); } @@ -50,8 +64,10 @@ void serial_test_modify_return(void) { run_test(0 /* input_retval */, 1 /* want_side_effect */, - 4 /* want_ret */); + 4 /* want_ret */, + 29 /* want_ret */); run_test(-EINVAL /* input_retval */, 0 /* want_side_effect */, + -EINVAL /* want_ret */, -EINVAL /* want_ret */); } diff --git a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c index 1c75a32186d6..fe0fb0c9849a 100644 --- a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c +++ b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c @@ -55,6 +55,25 @@ static void test_fentry(void) ASSERT_EQ(skel->bss->t6, 1, "t6 ret"); + ASSERT_EQ(skel->bss->t7_a, 16, "t7:a"); + ASSERT_EQ(skel->bss->t7_b, 17, "t7:b"); + ASSERT_EQ(skel->bss->t7_c, 18, "t7:c"); + ASSERT_EQ(skel->bss->t7_d, 19, "t7:d"); + ASSERT_EQ(skel->bss->t7_e, 20, "t7:e"); + ASSERT_EQ(skel->bss->t7_f_a, 21, "t7:f.a"); + ASSERT_EQ(skel->bss->t7_f_b, 22, "t7:f.b"); + ASSERT_EQ(skel->bss->t7_ret, 133, "t7 ret"); + + ASSERT_EQ(skel->bss->t8_a, 16, "t8:a"); + ASSERT_EQ(skel->bss->t8_b, 17, "t8:b"); + ASSERT_EQ(skel->bss->t8_c, 18, "t8:c"); + ASSERT_EQ(skel->bss->t8_d, 19, "t8:d"); + ASSERT_EQ(skel->bss->t8_e, 20, "t8:e"); + ASSERT_EQ(skel->bss->t8_f_a, 21, "t8:f.a"); + ASSERT_EQ(skel->bss->t8_f_b, 22, "t8:f.b"); + ASSERT_EQ(skel->bss->t8_g, 23, "t8:g"); + ASSERT_EQ(skel->bss->t8_ret, 156, "t8 ret"); + tracing_struct__detach(skel); destroy_skel: tracing_struct__destroy(skel); diff --git a/tools/testing/selftests/bpf/progs/fentry_many_args.c b/tools/testing/selftests/bpf/progs/fentry_many_args.c new file mode 100644 index 000000000000..b61bb92fee2c --- /dev/null +++ b/tools/testing/selftests/bpf/progs/fentry_many_args.c @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2023 Tencent */ +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +__u64 test1_result = 0; +SEC("fentry/bpf_testmod_fentry_test7") +int BPF_PROG(test1, __u64 a, void *b, short c, int d, void *e, char f, + int g) +{ + test1_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && + e == (void *)20 && f == 21 && g == 22; + return 0; +} + +__u64 test2_result = 0; +SEC("fentry/bpf_testmod_fentry_test11") +int BPF_PROG(test2, __u64 a, void *b, short c, int d, void *e, char f, + int g, unsigned int h, long i, __u64 j, unsigned long k) +{ + test2_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && + e == (void *)20 && f == 21 && g == 22 && h == 23 && + i == 24 && j == 25 && k == 26; + return 0; +} + +__u64 test3_result = 0; +SEC("fentry/bpf_testmod_fentry_test11") +int BPF_PROG(test3, __u64 a, __u64 b, __u64 c, __u64 d, __u64 e, __u64 f, + __u64 g, __u64 h, __u64 i, __u64 j, __u64 k) +{ + test3_result = a == 16 && b == 17 && c == 18 && d == 19 && + e == 20 && f == 21 && g == 22 && h == 23 && + i == 24 && j == 25 && k == 26; + return 0; +} diff --git a/tools/testing/selftests/bpf/progs/fexit_many_args.c b/tools/testing/selftests/bpf/progs/fexit_many_args.c new file mode 100644 index 000000000000..53b335c2dafb --- /dev/null +++ b/tools/testing/selftests/bpf/progs/fexit_many_args.c @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2023 Tencent */ +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +__u64 test1_result = 0; +SEC("fexit/bpf_testmod_fentry_test7") +int BPF_PROG(test1, __u64 a, void *b, short c, int d, void *e, char f, + int g, int ret) +{ + test1_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && + e == (void *)20 && f == 21 && g == 22 && ret == 133; + return 0; +} + +__u64 test2_result = 0; +SEC("fexit/bpf_testmod_fentry_test11") +int BPF_PROG(test2, __u64 a, void *b, short c, int d, void *e, char f, + int g, unsigned int h, long i, __u64 j, unsigned long k, + int ret) +{ + test2_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && + e == (void *)20 && f == 21 && g == 22 && h == 23 && + i == 24 && j == 25 && k == 26 && ret == 231; + return 0; +} + +__u64 test3_result = 0; +SEC("fexit/bpf_testmod_fentry_test11") +int BPF_PROG(test3, __u64 a, __u64 b, __u64 c, __u64 d, __u64 e, __u64 f, + __u64 g, __u64 h, __u64 i, __u64 j, __u64 k, __u64 ret) +{ + test3_result = a == 16 && b == 17 && c == 18 && d == 19 && + e == 20 && f == 21 && g == 22 && h == 23 && + i == 24 && j == 25 && k == 26 && ret == 231; + return 0; +} diff --git a/tools/testing/selftests/bpf/progs/modify_return.c b/tools/testing/selftests/bpf/progs/modify_return.c index 8b7466a15c6b..3376d4849f58 100644 --- a/tools/testing/selftests/bpf/progs/modify_return.c +++ b/tools/testing/selftests/bpf/progs/modify_return.c @@ -47,3 +47,43 @@ int BPF_PROG(fexit_test, int a, __u64 b, int ret) return 0; } + +static int sequence2; + +__u64 fentry_result2 = 0; +SEC("fentry/bpf_modify_return_test2") +int BPF_PROG(fentry_test2, int a, int *b, short c, int d, void *e, char f, + int g) +{ + sequence2++; + fentry_result2 = (sequence2 == 1); + return 0; +} + +__u64 fmod_ret_result2 = 0; +SEC("fmod_ret/bpf_modify_return_test2") +int BPF_PROG(fmod_ret_test2, int a, int *b, short c, int d, void *e, char f, + int g, int ret) +{ + sequence2++; + /* This is the first fmod_ret program, the ret passed should be 0 */ + fmod_ret_result2 = (sequence2 == 2 && ret == 0); + return input_retval; +} + +__u64 fexit_result2 = 0; +SEC("fexit/bpf_modify_return_test2") +int BPF_PROG(fexit_test2, int a, int *b, short c, int d, void *e, char f, + int g, int ret) +{ + sequence2++; + /* If the input_reval is non-zero a successful modification should have + * occurred. + */ + if (input_retval) + fexit_result2 = (sequence2 == 3 && ret == input_retval); + else + fexit_result2 = (sequence2 == 3 && ret == 29); + + return 0; +} diff --git a/tools/testing/selftests/bpf/progs/tracing_struct.c b/tools/testing/selftests/bpf/progs/tracing_struct.c index c435a3a8328a..515daef3c84b 100644 --- a/tools/testing/selftests/bpf/progs/tracing_struct.c +++ b/tools/testing/selftests/bpf/progs/tracing_struct.c @@ -18,6 +18,11 @@ struct bpf_testmod_struct_arg_3 { int b[]; }; +struct bpf_testmod_struct_arg_4 { + u64 a; + int b; +}; + long t1_a_a, t1_a_b, t1_b, t1_c, t1_ret, t1_nregs; __u64 t1_reg0, t1_reg1, t1_reg2, t1_reg3; long t2_a, t2_b_a, t2_b_b, t2_c, t2_ret; @@ -25,6 +30,9 @@ long t3_a, t3_b, t3_c_a, t3_c_b, t3_ret; long t4_a_a, t4_b, t4_c, t4_d, t4_e_a, t4_e_b, t4_ret; long t5_ret; int t6; +long t7_a, t7_b, t7_c, t7_d, t7_e, t7_f_a, t7_f_b, t7_ret; +long t8_a, t8_b, t8_c, t8_d, t8_e, t8_f_a, t8_f_b, t8_g, t8_ret; + SEC("fentry/bpf_testmod_test_struct_arg_1") int BPF_PROG2(test_struct_arg_1, struct bpf_testmod_struct_arg_2, a, int, b, int, c) @@ -130,4 +138,50 @@ int BPF_PROG2(test_struct_arg_11, struct bpf_testmod_struct_arg_3 *, a) return 0; } +SEC("fentry/bpf_testmod_test_struct_arg_7") +int BPF_PROG2(test_struct_arg_12, __u64, a, void *, b, short, c, int, d, + void *, e, struct bpf_testmod_struct_arg_4, f) +{ + t7_a = a; + t7_b = (long)b; + t7_c = c; + t7_d = d; + t7_e = (long)e; + t7_f_a = f.a; + t7_f_b = f.b; + return 0; +} + +SEC("fexit/bpf_testmod_test_struct_arg_7") +int BPF_PROG2(test_struct_arg_13, __u64, a, void *, b, short, c, int, d, + void *, e, struct bpf_testmod_struct_arg_4, f, int, ret) +{ + t7_ret = ret; + return 0; +} + +SEC("fentry/bpf_testmod_test_struct_arg_8") +int BPF_PROG2(test_struct_arg_14, __u64, a, void *, b, short, c, int, d, + void *, e, struct bpf_testmod_struct_arg_4, f, int, g) +{ + t8_a = a; + t8_b = (long)b; + t8_c = c; + t8_d = d; + t8_e = (long)e; + t8_f_a = f.a; + t8_f_b = f.b; + t8_g = g; + return 0; +} + +SEC("fexit/bpf_testmod_test_struct_arg_8") +int BPF_PROG2(test_struct_arg_15, __u64, a, void *, b, short, c, int, d, + void *, e, struct bpf_testmod_struct_arg_4, f, int, g, + int, ret) +{ + t8_ret = ret; + return 0; +} + char _license[] SEC("license") = "GPL"; -- 2.40.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments 2023-06-27 11:53 ` [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments menglong8.dong @ 2023-07-05 1:47 ` Menglong Dong 0 siblings, 0 replies; 5+ messages in thread From: Menglong Dong @ 2023-07-05 1:47 UTC (permalink / raw) To: daniel, yhs Cc: ast, andrii, alexei.starovoitov, martin.lau, song, yhs, john.fastabend, kpsingh, sdf, haoluo, jolsa, bpf, linux-kernel, linux-arm-kernel, Menglong Dong On Tue, Jun 27, 2023 at 7:54 PM <menglong8.dong@gmail.com> wrote: > > From: Menglong Dong <imagedong@tencent.com> > > Add fentry_many_args.c and fexit_many_args.c to test the fentry/fexit > with 7/11 arguments. As this feature is not supported by arm64 yet, we > disable these testcases for arm64 in DENYLIST.aarch64. We can combine > them with fentry_test.c/fexit_test.c when arm64 is supported too. > > Correspondingly, add bpf_testmod_fentry_test7() and > bpf_testmod_fentry_test11() to bpf_testmod.c > > Meanwhile, add bpf_modify_return_test2() to test_run.c to test the > MODIFY_RETURN with 7 arguments. > > Add bpf_testmod_test_struct_arg_7/bpf_testmod_test_struct_arg_7 in > bpf_testmod.c to test the struct in the arguments. > > And the testcases passed on x86_64: > > ./test_progs -t fexit > Summary: 5/14 PASSED, 0 SKIPPED, 0 FAILED > > ./test_progs -t fentry > Summary: 3/2 PASSED, 0 SKIPPED, 0 FAILED > > ./test_progs -t modify_return > Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED > > ./test_progs -t tracing_struct > Summary: 1/0 PASSED, 0 SKIPPED, 0 FAILED > > Signed-off-by: Menglong Dong <imagedong@tencent.com> > Acked-by: Yonghong Song <yhs@fb.com> > --- > v7: > - split the testcases, and add fentry_many_args/fexit_many_args to > DENYLIST.aarch64 > v6: > - add testcases to tracing_struct.c instead of fentry_test.c and > fexit_test.c > v5: > - add testcases for MODIFY_RETURN > v4: > - use different type for args in bpf_testmod_fentry_test{7,12} > - add testcase for grabage values in ctx > v3: > - move bpf_fentry_test{7,12} to bpf_testmod.c and rename them to > bpf_testmod_fentry_test{7,12} meanwhile > - get return value by bpf_get_func_ret() in > "fexit/bpf_testmod_fentry_test12", as we don't change ___bpf_ctx_cast() > in this version > --- > net/bpf/test_run.c | 23 ++++++-- > tools/testing/selftests/bpf/DENYLIST.aarch64 | 2 + > .../selftests/bpf/bpf_testmod/bpf_testmod.c | 49 ++++++++++++++++- > .../selftests/bpf/prog_tests/fentry_test.c | 43 +++++++++++++-- > .../selftests/bpf/prog_tests/fexit_test.c | 43 +++++++++++++-- > .../selftests/bpf/prog_tests/modify_return.c | 20 ++++++- > .../selftests/bpf/prog_tests/tracing_struct.c | 19 +++++++ > .../selftests/bpf/progs/fentry_many_args.c | 39 ++++++++++++++ > .../selftests/bpf/progs/fexit_many_args.c | 40 ++++++++++++++ > .../selftests/bpf/progs/modify_return.c | 40 ++++++++++++++ > .../selftests/bpf/progs/tracing_struct.c | 54 +++++++++++++++++++ > 11 files changed, 358 insertions(+), 14 deletions(-) > create mode 100644 tools/testing/selftests/bpf/progs/fentry_many_args.c > create mode 100644 tools/testing/selftests/bpf/progs/fexit_many_args.c > > diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c > index 2321bd2f9964..df58e8bf5e07 100644 > --- a/net/bpf/test_run.c > +++ b/net/bpf/test_run.c > @@ -561,6 +561,13 @@ __bpf_kfunc int bpf_modify_return_test(int a, int *b) > return a + *b; > } > > +__bpf_kfunc int bpf_modify_return_test2(int a, int *b, short c, int d, > + void *e, char f, int g) > +{ > + *b += 1; > + return a + *b + c + d + (long)e + f + g; > +} > + > int noinline bpf_fentry_shadow_test(int a) > { > return a + 1; > @@ -596,9 +603,13 @@ __diag_pop(); > > BTF_SET8_START(bpf_test_modify_return_ids) > BTF_ID_FLAGS(func, bpf_modify_return_test) > +BTF_ID_FLAGS(func, bpf_modify_return_test2) > BTF_ID_FLAGS(func, bpf_fentry_test1, KF_SLEEPABLE) > BTF_SET8_END(bpf_test_modify_return_ids) > > +BTF_ID_LIST(bpf_modify_return_test_id) > +BTF_ID(func, bpf_modify_return_test) > + > static const struct btf_kfunc_id_set bpf_test_modify_return_set = { > .owner = THIS_MODULE, > .set = &bpf_test_modify_return_ids, > @@ -661,9 +672,15 @@ int bpf_prog_test_run_tracing(struct bpf_prog *prog, > goto out; > break; > case BPF_MODIFY_RETURN: > - ret = bpf_modify_return_test(1, &b); > - if (b != 2) > - side_effect = 1; > + if (prog->aux->attach_btf_id == *bpf_modify_return_test_id) { > + ret = bpf_modify_return_test(1, &b); > + if (b != 2) > + side_effect = 1; > + } else { > + ret = bpf_modify_return_test2(1, &b, 3, 4, (void *)5, 6, 7); > + if (b != 2) > + side_effect = 1; > + } > break; > default: > goto out; > diff --git a/tools/testing/selftests/bpf/DENYLIST.aarch64 b/tools/testing/selftests/bpf/DENYLIST.aarch64 > index 08adc805878b..3b61e8b35d62 100644 > --- a/tools/testing/selftests/bpf/DENYLIST.aarch64 > +++ b/tools/testing/selftests/bpf/DENYLIST.aarch64 > @@ -10,3 +10,5 @@ kprobe_multi_test/link_api_addrs # link_fd unexpected link_fd: a > kprobe_multi_test/link_api_syms # link_fd unexpected link_fd: actual -95 < expected 0 > kprobe_multi_test/skel_api # libbpf: failed to load BPF skeleton 'kprobe_multi': -3 > module_attach # prog 'kprobe_multi': failed to auto-attach: -95 > +fentry_test/fentry_many_args # fentry_many_args:FAIL:fentry_many_args_attach unexpected error: -524 > +fexit_test/fexit_many_args # fexit_many_args:FAIL:fexit_many_args_attach unexpected error: -524 > diff --git a/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c b/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c > index aaf6ef1201c7..a6f991b56345 100644 > --- a/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c > +++ b/tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c > @@ -34,6 +34,11 @@ struct bpf_testmod_struct_arg_3 { > int b[]; > }; > > +struct bpf_testmod_struct_arg_4 { > + u64 a; > + int b; > +}; > + > __diag_push(); > __diag_ignore_all("-Wmissing-prototypes", > "Global functions as their definitions will be in bpf_testmod.ko BTF"); > @@ -75,6 +80,24 @@ bpf_testmod_test_struct_arg_6(struct bpf_testmod_struct_arg_3 *a) { > return bpf_testmod_test_struct_arg_result; > } > > +noinline int > +bpf_testmod_test_struct_arg_7(u64 a, void *b, short c, int d, void *e, > + struct bpf_testmod_struct_arg_4 f) > +{ > + bpf_testmod_test_struct_arg_result = a + (long)b + c + d + > + (long)e + f.a + f.b; > + return bpf_testmod_test_struct_arg_result; > +} > + > +noinline int > +bpf_testmod_test_struct_arg_8(u64 a, void *b, short c, int d, void *e, > + struct bpf_testmod_struct_arg_4 f, int g) > +{ > + bpf_testmod_test_struct_arg_result = a + (long)b + c + d + > + (long)e + f.a + f.b + g; > + return bpf_testmod_test_struct_arg_result; > +} > + > __bpf_kfunc void > bpf_testmod_test_mod_kfunc(int i) > { > @@ -191,6 +214,20 @@ noinline int bpf_testmod_fentry_test3(char a, int b, u64 c) > return a + b + c; > } > > +noinline int bpf_testmod_fentry_test7(u64 a, void *b, short c, int d, > + void *e, char f, int g) > +{ > + return a + (long)b + c + d + (long)e + f + g; > +} > + > +noinline int bpf_testmod_fentry_test11(u64 a, void *b, short c, int d, > + void *e, char f, int g, > + unsigned int h, long i, __u64 j, > + unsigned long k) > +{ > + return a + (long)b + c + d + (long)e + f + g + h + i + j + k; > +} > + > int bpf_testmod_fentry_ok; > > noinline ssize_t > @@ -206,6 +243,7 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, > struct bpf_testmod_struct_arg_1 struct_arg1 = {10}; > struct bpf_testmod_struct_arg_2 struct_arg2 = {2, 3}; > struct bpf_testmod_struct_arg_3 *struct_arg3; > + struct bpf_testmod_struct_arg_4 struct_arg4 = {21, 22}; > int i = 1; > > while (bpf_testmod_return_ptr(i)) > @@ -216,6 +254,11 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, > (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(); > + (void)bpf_testmod_test_struct_arg_7(16, (void *)17, 18, 19, > + (void *)20, struct_arg4); > + (void)bpf_testmod_test_struct_arg_8(16, (void *)17, 18, 19, > + (void *)20, struct_arg4, 23); > + > > struct_arg3 = kmalloc((sizeof(struct bpf_testmod_struct_arg_3) + > sizeof(int)), GFP_KERNEL); > @@ -243,7 +286,11 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, > > if (bpf_testmod_fentry_test1(1) != 2 || > bpf_testmod_fentry_test2(2, 3) != 5 || > - bpf_testmod_fentry_test3(4, 5, 6) != 15) > + bpf_testmod_fentry_test3(4, 5, 6) != 15 || > + bpf_testmod_fentry_test7(16, (void *)17, 18, 19, (void *)20, > + 21, 22) != 133 || > + bpf_testmod_fentry_test11(16, (void *)17, 18, 19, (void *)20, > + 21, 22, 23, 24, 25, 26) != 231) > goto out; > > bpf_testmod_fentry_ok = 1; > diff --git a/tools/testing/selftests/bpf/prog_tests/fentry_test.c b/tools/testing/selftests/bpf/prog_tests/fentry_test.c > index c0d1d61d5f66..aee1bc77a17f 100644 > --- a/tools/testing/selftests/bpf/prog_tests/fentry_test.c > +++ b/tools/testing/selftests/bpf/prog_tests/fentry_test.c > @@ -2,8 +2,9 @@ > /* Copyright (c) 2019 Facebook */ > #include <test_progs.h> > #include "fentry_test.lskel.h" > +#include "fentry_many_args.skel.h" > > -static int fentry_test(struct fentry_test_lskel *fentry_skel) > +static int fentry_test_common(struct fentry_test_lskel *fentry_skel) > { > int err, prog_fd, i; > int link_fd; > @@ -37,7 +38,7 @@ static int fentry_test(struct fentry_test_lskel *fentry_skel) > return 0; > } > > -void test_fentry_test(void) > +static void fentry_test(void) > { > struct fentry_test_lskel *fentry_skel = NULL; > int err; > @@ -46,13 +47,47 @@ void test_fentry_test(void) > if (!ASSERT_OK_PTR(fentry_skel, "fentry_skel_load")) > goto cleanup; > > - err = fentry_test(fentry_skel); > + err = fentry_test_common(fentry_skel); > if (!ASSERT_OK(err, "fentry_first_attach")) > goto cleanup; > > - err = fentry_test(fentry_skel); > + err = fentry_test_common(fentry_skel); > ASSERT_OK(err, "fentry_second_attach"); > > cleanup: > fentry_test_lskel__destroy(fentry_skel); > } > + > +static void fentry_many_args(void) > +{ > + struct fentry_many_args *fentry_skel = NULL; > + int err; > + > + fentry_skel = fentry_many_args__open_and_load(); > + if (!ASSERT_OK_PTR(fentry_skel, "fentry_many_args_skel_load")) > + goto cleanup; > + > + err = fentry_many_args__attach(fentry_skel); > + if (!ASSERT_OK(err, "fentry_many_args_attach")) > + goto cleanup; > + > + ASSERT_OK(trigger_module_test_read(1), "trigger_read"); > + > + ASSERT_EQ(fentry_skel->bss->test1_result, 1, > + "fentry_many_args_result1"); > + ASSERT_EQ(fentry_skel->bss->test2_result, 1, > + "fentry_many_args_result2"); > + ASSERT_EQ(fentry_skel->bss->test3_result, 1, > + "fentry_many_args_result3"); > + > +cleanup: > + fentry_many_args__destroy(fentry_skel); > +} > + Hello, Is there anything else that needs to be improved in this series? Is it about the ugly function naming of "fentry_many_args"? Sorry for the bother, but it has been pending for a while :) Thanks! Menglong Dong > +void test_fentry_test(void) > +{ > + if (test__start_subtest("fentry")) > + fentry_test(); > + if (test__start_subtest("fentry_many_args")) > + fentry_many_args(); > +} > diff --git a/tools/testing/selftests/bpf/prog_tests/fexit_test.c b/tools/testing/selftests/bpf/prog_tests/fexit_test.c > index 101b7343036b..1c13007e37dd 100644 > --- a/tools/testing/selftests/bpf/prog_tests/fexit_test.c > +++ b/tools/testing/selftests/bpf/prog_tests/fexit_test.c > @@ -2,8 +2,9 @@ > /* Copyright (c) 2019 Facebook */ > #include <test_progs.h> > #include "fexit_test.lskel.h" > +#include "fexit_many_args.skel.h" > > -static int fexit_test(struct fexit_test_lskel *fexit_skel) > +static int fexit_test_common(struct fexit_test_lskel *fexit_skel) > { > int err, prog_fd, i; > int link_fd; > @@ -37,7 +38,7 @@ static int fexit_test(struct fexit_test_lskel *fexit_skel) > return 0; > } > > -void test_fexit_test(void) > +static void fexit_test(void) > { > struct fexit_test_lskel *fexit_skel = NULL; > int err; > @@ -46,13 +47,47 @@ void test_fexit_test(void) > if (!ASSERT_OK_PTR(fexit_skel, "fexit_skel_load")) > goto cleanup; > > - err = fexit_test(fexit_skel); > + err = fexit_test_common(fexit_skel); > if (!ASSERT_OK(err, "fexit_first_attach")) > goto cleanup; > > - err = fexit_test(fexit_skel); > + err = fexit_test_common(fexit_skel); > ASSERT_OK(err, "fexit_second_attach"); > > cleanup: > fexit_test_lskel__destroy(fexit_skel); > } > + > +static void fexit_many_args(void) > +{ > + struct fexit_many_args *fexit_skel = NULL; > + int err; > + > + fexit_skel = fexit_many_args__open_and_load(); > + if (!ASSERT_OK_PTR(fexit_skel, "fexit_many_args_skel_load")) > + goto cleanup; > + > + err = fexit_many_args__attach(fexit_skel); > + if (!ASSERT_OK(err, "fexit_many_args_attach")) > + goto cleanup; > + > + ASSERT_OK(trigger_module_test_read(1), "trigger_read"); > + > + ASSERT_EQ(fexit_skel->bss->test1_result, 1, > + "fexit_many_args_result1"); > + ASSERT_EQ(fexit_skel->bss->test2_result, 1, > + "fexit_many_args_result2"); > + ASSERT_EQ(fexit_skel->bss->test3_result, 1, > + "fexit_many_args_result3"); > + > +cleanup: > + fexit_many_args__destroy(fexit_skel); > +} > + > +void test_fexit_test(void) > +{ > + if (test__start_subtest("fexit")) > + fexit_test(); > + if (test__start_subtest("fexit_many_args")) > + fexit_many_args(); > +} > diff --git a/tools/testing/selftests/bpf/prog_tests/modify_return.c b/tools/testing/selftests/bpf/prog_tests/modify_return.c > index 5d9955af6247..93febb6d81ef 100644 > --- a/tools/testing/selftests/bpf/prog_tests/modify_return.c > +++ b/tools/testing/selftests/bpf/prog_tests/modify_return.c > @@ -11,7 +11,8 @@ > #define UPPER(x) ((x) >> 16) > > > -static void run_test(__u32 input_retval, __u16 want_side_effect, __s16 want_ret) > +static void run_test(__u32 input_retval, __u16 want_side_effect, > + __s16 want_ret, __s16 want_ret2) > { > struct modify_return *skel = NULL; > int err, prog_fd; > @@ -41,6 +42,19 @@ static void run_test(__u32 input_retval, __u16 want_side_effect, __s16 want_ret) > ASSERT_EQ(skel->bss->fexit_result, 1, "modify_return fexit_result"); > ASSERT_EQ(skel->bss->fmod_ret_result, 1, "modify_return fmod_ret_result"); > > + prog_fd = bpf_program__fd(skel->progs.fmod_ret_test2); > + err = bpf_prog_test_run_opts(prog_fd, &topts); > + ASSERT_OK(err, "test_run"); > + > + side_effect = UPPER(topts.retval); > + ret = LOWER(topts.retval); > + > + ASSERT_EQ(ret, want_ret2, "test_run ret2"); > + ASSERT_EQ(side_effect, want_side_effect, "modify_return side_effect2"); > + ASSERT_EQ(skel->bss->fentry_result2, 1, "modify_return fentry_result2"); > + ASSERT_EQ(skel->bss->fexit_result2, 1, "modify_return fexit_result2"); > + ASSERT_EQ(skel->bss->fmod_ret_result2, 1, "modify_return fmod_ret_result2"); > + > cleanup: > modify_return__destroy(skel); > } > @@ -50,8 +64,10 @@ void serial_test_modify_return(void) > { > run_test(0 /* input_retval */, > 1 /* want_side_effect */, > - 4 /* want_ret */); > + 4 /* want_ret */, > + 29 /* want_ret */); > run_test(-EINVAL /* input_retval */, > 0 /* want_side_effect */, > + -EINVAL /* want_ret */, > -EINVAL /* want_ret */); > } > diff --git a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c > index 1c75a32186d6..fe0fb0c9849a 100644 > --- a/tools/testing/selftests/bpf/prog_tests/tracing_struct.c > +++ b/tools/testing/selftests/bpf/prog_tests/tracing_struct.c > @@ -55,6 +55,25 @@ static void test_fentry(void) > > ASSERT_EQ(skel->bss->t6, 1, "t6 ret"); > > + ASSERT_EQ(skel->bss->t7_a, 16, "t7:a"); > + ASSERT_EQ(skel->bss->t7_b, 17, "t7:b"); > + ASSERT_EQ(skel->bss->t7_c, 18, "t7:c"); > + ASSERT_EQ(skel->bss->t7_d, 19, "t7:d"); > + ASSERT_EQ(skel->bss->t7_e, 20, "t7:e"); > + ASSERT_EQ(skel->bss->t7_f_a, 21, "t7:f.a"); > + ASSERT_EQ(skel->bss->t7_f_b, 22, "t7:f.b"); > + ASSERT_EQ(skel->bss->t7_ret, 133, "t7 ret"); > + > + ASSERT_EQ(skel->bss->t8_a, 16, "t8:a"); > + ASSERT_EQ(skel->bss->t8_b, 17, "t8:b"); > + ASSERT_EQ(skel->bss->t8_c, 18, "t8:c"); > + ASSERT_EQ(skel->bss->t8_d, 19, "t8:d"); > + ASSERT_EQ(skel->bss->t8_e, 20, "t8:e"); > + ASSERT_EQ(skel->bss->t8_f_a, 21, "t8:f.a"); > + ASSERT_EQ(skel->bss->t8_f_b, 22, "t8:f.b"); > + ASSERT_EQ(skel->bss->t8_g, 23, "t8:g"); > + ASSERT_EQ(skel->bss->t8_ret, 156, "t8 ret"); > + > tracing_struct__detach(skel); > destroy_skel: > tracing_struct__destroy(skel); > diff --git a/tools/testing/selftests/bpf/progs/fentry_many_args.c b/tools/testing/selftests/bpf/progs/fentry_many_args.c > new file mode 100644 > index 000000000000..b61bb92fee2c > --- /dev/null > +++ b/tools/testing/selftests/bpf/progs/fentry_many_args.c > @@ -0,0 +1,39 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* Copyright (c) 2023 Tencent */ > +#include <linux/bpf.h> > +#include <bpf/bpf_helpers.h> > +#include <bpf/bpf_tracing.h> > + > +char _license[] SEC("license") = "GPL"; > + > +__u64 test1_result = 0; > +SEC("fentry/bpf_testmod_fentry_test7") > +int BPF_PROG(test1, __u64 a, void *b, short c, int d, void *e, char f, > + int g) > +{ > + test1_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && > + e == (void *)20 && f == 21 && g == 22; > + return 0; > +} > + > +__u64 test2_result = 0; > +SEC("fentry/bpf_testmod_fentry_test11") > +int BPF_PROG(test2, __u64 a, void *b, short c, int d, void *e, char f, > + int g, unsigned int h, long i, __u64 j, unsigned long k) > +{ > + test2_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && > + e == (void *)20 && f == 21 && g == 22 && h == 23 && > + i == 24 && j == 25 && k == 26; > + return 0; > +} > + > +__u64 test3_result = 0; > +SEC("fentry/bpf_testmod_fentry_test11") > +int BPF_PROG(test3, __u64 a, __u64 b, __u64 c, __u64 d, __u64 e, __u64 f, > + __u64 g, __u64 h, __u64 i, __u64 j, __u64 k) > +{ > + test3_result = a == 16 && b == 17 && c == 18 && d == 19 && > + e == 20 && f == 21 && g == 22 && h == 23 && > + i == 24 && j == 25 && k == 26; > + return 0; > +} > diff --git a/tools/testing/selftests/bpf/progs/fexit_many_args.c b/tools/testing/selftests/bpf/progs/fexit_many_args.c > new file mode 100644 > index 000000000000..53b335c2dafb > --- /dev/null > +++ b/tools/testing/selftests/bpf/progs/fexit_many_args.c > @@ -0,0 +1,40 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* Copyright (c) 2023 Tencent */ > +#include <linux/bpf.h> > +#include <bpf/bpf_helpers.h> > +#include <bpf/bpf_tracing.h> > + > +char _license[] SEC("license") = "GPL"; > + > +__u64 test1_result = 0; > +SEC("fexit/bpf_testmod_fentry_test7") > +int BPF_PROG(test1, __u64 a, void *b, short c, int d, void *e, char f, > + int g, int ret) > +{ > + test1_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && > + e == (void *)20 && f == 21 && g == 22 && ret == 133; > + return 0; > +} > + > +__u64 test2_result = 0; > +SEC("fexit/bpf_testmod_fentry_test11") > +int BPF_PROG(test2, __u64 a, void *b, short c, int d, void *e, char f, > + int g, unsigned int h, long i, __u64 j, unsigned long k, > + int ret) > +{ > + test2_result = a == 16 && b == (void *)17 && c == 18 && d == 19 && > + e == (void *)20 && f == 21 && g == 22 && h == 23 && > + i == 24 && j == 25 && k == 26 && ret == 231; > + return 0; > +} > + > +__u64 test3_result = 0; > +SEC("fexit/bpf_testmod_fentry_test11") > +int BPF_PROG(test3, __u64 a, __u64 b, __u64 c, __u64 d, __u64 e, __u64 f, > + __u64 g, __u64 h, __u64 i, __u64 j, __u64 k, __u64 ret) > +{ > + test3_result = a == 16 && b == 17 && c == 18 && d == 19 && > + e == 20 && f == 21 && g == 22 && h == 23 && > + i == 24 && j == 25 && k == 26 && ret == 231; > + return 0; > +} > diff --git a/tools/testing/selftests/bpf/progs/modify_return.c b/tools/testing/selftests/bpf/progs/modify_return.c > index 8b7466a15c6b..3376d4849f58 100644 > --- a/tools/testing/selftests/bpf/progs/modify_return.c > +++ b/tools/testing/selftests/bpf/progs/modify_return.c > @@ -47,3 +47,43 @@ int BPF_PROG(fexit_test, int a, __u64 b, int ret) > > return 0; > } > + > +static int sequence2; > + > +__u64 fentry_result2 = 0; > +SEC("fentry/bpf_modify_return_test2") > +int BPF_PROG(fentry_test2, int a, int *b, short c, int d, void *e, char f, > + int g) > +{ > + sequence2++; > + fentry_result2 = (sequence2 == 1); > + return 0; > +} > + > +__u64 fmod_ret_result2 = 0; > +SEC("fmod_ret/bpf_modify_return_test2") > +int BPF_PROG(fmod_ret_test2, int a, int *b, short c, int d, void *e, char f, > + int g, int ret) > +{ > + sequence2++; > + /* This is the first fmod_ret program, the ret passed should be 0 */ > + fmod_ret_result2 = (sequence2 == 2 && ret == 0); > + return input_retval; > +} > + > +__u64 fexit_result2 = 0; > +SEC("fexit/bpf_modify_return_test2") > +int BPF_PROG(fexit_test2, int a, int *b, short c, int d, void *e, char f, > + int g, int ret) > +{ > + sequence2++; > + /* If the input_reval is non-zero a successful modification should have > + * occurred. > + */ > + if (input_retval) > + fexit_result2 = (sequence2 == 3 && ret == input_retval); > + else > + fexit_result2 = (sequence2 == 3 && ret == 29); > + > + return 0; > +} > diff --git a/tools/testing/selftests/bpf/progs/tracing_struct.c b/tools/testing/selftests/bpf/progs/tracing_struct.c > index c435a3a8328a..515daef3c84b 100644 > --- a/tools/testing/selftests/bpf/progs/tracing_struct.c > +++ b/tools/testing/selftests/bpf/progs/tracing_struct.c > @@ -18,6 +18,11 @@ struct bpf_testmod_struct_arg_3 { > int b[]; > }; > > +struct bpf_testmod_struct_arg_4 { > + u64 a; > + int b; > +}; > + > long t1_a_a, t1_a_b, t1_b, t1_c, t1_ret, t1_nregs; > __u64 t1_reg0, t1_reg1, t1_reg2, t1_reg3; > long t2_a, t2_b_a, t2_b_b, t2_c, t2_ret; > @@ -25,6 +30,9 @@ long t3_a, t3_b, t3_c_a, t3_c_b, t3_ret; > long t4_a_a, t4_b, t4_c, t4_d, t4_e_a, t4_e_b, t4_ret; > long t5_ret; > int t6; > +long t7_a, t7_b, t7_c, t7_d, t7_e, t7_f_a, t7_f_b, t7_ret; > +long t8_a, t8_b, t8_c, t8_d, t8_e, t8_f_a, t8_f_b, t8_g, t8_ret; > + > > SEC("fentry/bpf_testmod_test_struct_arg_1") > int BPF_PROG2(test_struct_arg_1, struct bpf_testmod_struct_arg_2, a, int, b, int, c) > @@ -130,4 +138,50 @@ int BPF_PROG2(test_struct_arg_11, struct bpf_testmod_struct_arg_3 *, a) > return 0; > } > > +SEC("fentry/bpf_testmod_test_struct_arg_7") > +int BPF_PROG2(test_struct_arg_12, __u64, a, void *, b, short, c, int, d, > + void *, e, struct bpf_testmod_struct_arg_4, f) > +{ > + t7_a = a; > + t7_b = (long)b; > + t7_c = c; > + t7_d = d; > + t7_e = (long)e; > + t7_f_a = f.a; > + t7_f_b = f.b; > + return 0; > +} > + > +SEC("fexit/bpf_testmod_test_struct_arg_7") > +int BPF_PROG2(test_struct_arg_13, __u64, a, void *, b, short, c, int, d, > + void *, e, struct bpf_testmod_struct_arg_4, f, int, ret) > +{ > + t7_ret = ret; > + return 0; > +} > + > +SEC("fentry/bpf_testmod_test_struct_arg_8") > +int BPF_PROG2(test_struct_arg_14, __u64, a, void *, b, short, c, int, d, > + void *, e, struct bpf_testmod_struct_arg_4, f, int, g) > +{ > + t8_a = a; > + t8_b = (long)b; > + t8_c = c; > + t8_d = d; > + t8_e = (long)e; > + t8_f_a = f.a; > + t8_f_b = f.b; > + t8_g = g; > + return 0; > +} > + > +SEC("fexit/bpf_testmod_test_struct_arg_8") > +int BPF_PROG2(test_struct_arg_15, __u64, a, void *, b, short, c, int, d, > + void *, e, struct bpf_testmod_struct_arg_4, f, int, g, > + int, ret) > +{ > + t8_ret = ret; > + return 0; > +} > + > char _license[] SEC("license") = "GPL"; > -- > 2.40.1 > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2023-07-05 1:48 UTC | newest] Thread overview: 5+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2023-06-27 11:53 [PATCH bpf-next v8 0/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 1/3] bpf, x86: save/restore regs with BPF_DW size menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 2/3] bpf, x86: allow function arguments up to 12 for TRACING menglong8.dong 2023-06-27 11:53 ` [PATCH bpf-next v8 3/3] selftests/bpf: add testcase for TRACING with 6+ arguments menglong8.dong 2023-07-05 1:47 ` Menglong Dong
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).