bpf: Add gen_epilogue to bpf_verifier_ops
Subsystems (5)
Martin KaFai Lau
reviewerv5 cover bpf: Add gen_epilogue to bpf_verifier_ops
From: Martin KaFai Lau <[email protected]>
This set allows the subsystem to patch codes before BPF_EXIT. The verifier ops, .gen_epilogue, is added for this purpose. One of the use case will be in the bpf qdisc, the bpf qdisc subsystem can ensure the skb->dev is in the correct value. The bpf qdisc subsystem can either inline fixing it in the epilogue or call another kernel function to handle it (e.g. drop) in the epilogue. Another use case could be in bpf_tcp_ca.c to enforce snd_cwnd has valid value (e.g. positive value).
v5:
* Removed the skip_cnt argument from adjust_jmp_off() in patch 2. Instead, reuse the delta argument and skip
the [tgt_idx, tgt_idx + delta) instructions.
* Added a BPF_JMP32_A macro in patch 3.
* Removed pro_epilogue_subprog.c in patch 6.
The pro_epilogue_kfunc.c has covered the subprog case. Renamed the file pro_epilogue_kfunc.c to pro_epilogue.c. Some of the SEC names and function names are changed accordingly (mainly shorten them by removing the _kfunc suffix).
* Added comments to explain the tail_call result in patch 7.
* Fixed the following bpf CI breakages. I ran it in CI manually to confirm:
https://github.com/kernel-patches/bpf/actions/runs/10590714532
* s390 zext added "w3 = w3". Adjusted the test to
use all ALU64 and BPF_DW to avoid zext.
Also changed the "int a" in the "struct st_ops_args" to "u64 a".
* llvm17 does not take:
*(u64 *)(r1 +0) = 0;
so it is changed to:
r3 = 0;
*(u64 *)(r1 +0) = r3;v4:
* Fixed a bug in the memcpy in patch 3
The size in the memcpy should be
epilogue_cnt * sizeof(*epilogue_buf)
v3:
* Moved epilogue_buf[16] to env.
Patch 1 is added to move the existing insn_buf[16] to env.
* Fixed a case that the bpf prog has a BPF_JMP that goes back to the first instruction of the main prog.
The jump back to 1st insn case also applies to the prologue. Patch 2 is added to handle it.
* If the bpf main prog has multiple BPF_EXIT, use a BPF_JA to goto the earlier patched epilogue.
Note that there are (BPF_JMP32 | BPF_JA) vs (BPF_JMP | BPF_JA) details in the patch 3 commit message.
* There are subtle changes in patch 3, so I reset the Reviewed-by.
* Added patch 8 and patch 9 to cover the changes in patch 2 and patch 3.
* Dropped the kfunc call from pro/epilogue and its selftests.
v2:
* Remove the RFC tag. Keep the ordering at where .gen_epilogue is called in the verifier relative to the check_max_stack_depth(). This will be consistent with the other extra stack_depth usage like optimize_bpf_loop().
* Use __xlated check provided by the test_loader to check the patched instructions after gen_pro/epilogue (Eduard).
* Added Patch 3 by Eduard (Thanks!).
Eduard Zingerman (1):
selftests/bpf: attach struct_ops maps before test prog runs
Martin KaFai Lau (8):
bpf: Move insn_buf[16] to bpf_verifier_env
bpf: Adjust BPF_JMP that jumps to the 1st insn of the prologue
bpf: Add gen_epilogue to bpf_verifier_ops
bpf: Export bpf_base_func_proto
selftests/bpf: Test gen_prologue and gen_epilogue selftests/bpf: Add tailcall epilogue test
selftests/bpf: A pro/epilogue test when the main prog jumps back to
the 1st insn
selftests/bpf: Test epilogue patching when the main prog has multiple
BPF_EXIT
include/linux/bpf.h | 2 + include/linux/bpf_verifier.h | 4 + include/linux/filter.h | 10 + kernel/bpf/helpers.c | 1 + kernel/bpf/verifier.c | 67 +++++- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 190 ++++++++++++++++++ .../selftests/bpf/bpf_testmod/bpf_testmod.h | 11 + .../bpf/bpf_testmod/bpf_testmod_kfunc.h | 6 + .../selftests/bpf/prog_tests/pro_epilogue.c | 60 ++++++ .../selftests/bpf/progs/epilogue_exit.c | 82 ++++++++ .../selftests/bpf/progs/epilogue_tailcall.c | 58 ++++++ .../selftests/bpf/progs/pro_epilogue.c | 154 ++++++++++++++ .../bpf/progs/pro_epilogue_goto_start.c | 149 ++++++++++++++ tools/testing/selftests/bpf/test_loader.c | 27 +++ 14 files changed, 813 insertions(+), 8 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/pro_epilogue.c create mode 100644 tools/testing/selftests/bpf/progs/epilogue_exit.c create mode 100644 tools/testing/selftests/bpf/progs/epilogue_tailcall.c create mode 100644 tools/testing/selftests/bpf/progs/pro_epilogue.c create mode 100644 tools/testing/selftests/bpf/progs/pro_epilogue_goto_start.c
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 1/9 bpf: Move insn_buf[16] to bpf_verifier_env
From: Martin KaFai Lau <[email protected]>
This patch moves the 'struct bpf_insn insn_buf[16]' stack usage to the bpf_verifier_env. A '#define INSN_BUF_SIZE 16' is also added to replace the ARRAY_SIZE(insn_buf) usages.
Both convert_ctx_accesses() and do_misc_fixup() are changed to use the env->insn_buf.
It is a refactoring work for adding the epilogue_buf[16] in a later patch.
With this patch, the stack size usage decreased.
Before:./kernel/bpf/verifier.c:22133:5: warning: stack frame size (2584)
After:./kernel/bpf/verifier.c:22184:5: warning: stack frame size (2264)
--- include/linux/bpf_verifier.h | 3 +++ kernel/bpf/verifier.c | 15 ++++++++------- 2 files changed, 11 insertions(+), 7 deletions(-)
include/linux/bpf_verifier.h +3 -0
@@ -23,6 +23,8 @@* (in the "-8,-16,...,-512" form) */ #define TMP_STR_BUF_LEN 320 +/* Patch buffer size */ +#define INSN_BUF_SIZE 16/* Liveness marks, used for registers and spilled-regs (in stack slots). * Read marks propagate upwards until they find a write mark; they record that
@@ -780,6 +782,7 @@ struct bpf_verifier_env {* e.g., in reg_type_str() to generate reg_type string */ char tmp_str_buf[TMP_STR_BUF_LEN ]; +struct bpf_insn insn_buf[INSN_BUF_SIZE ]; };static inline struct bpf_func_info_aux *subprog_aux (struct bpf_verifier_env *env,int subprog)
kernel/bpf/verifier.c +8 -7
@@ -19677,7 +19677,8 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)const struct bpf_verifier_ops *ops = env->ops;int i, cnt, size, ctx_field_size, delta =0 ;const int insn_cnt = env->prog->len; -struct bpf_insn insn_buf[16 ], *insn; +struct bpf_insn *insn_buf = env->insn_buf; +struct bpf_insn *insn;u32 target_size, size_default, off;struct bpf_prog *new_prog;enum bpf_access_type type;
@@ -19690,7 +19691,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) } cnt = ops->gen_prologue (insn_buf, env->seen_direct_write, env->prog); -if (cnt >=ARRAY_SIZE (insn_buf)) { +if (cnt >=INSN_BUF_SIZE ) {verbose (env,"bpf verifier is misconfigured\n" );return -EINVAL ; }else if (cnt) {
@@ -19837,7 +19838,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) target_size =0 ; cnt =convert_ctx_access (type, insn, insn_buf, env->prog, &target_size); -if (cnt ==0 || cnt >=ARRAY_SIZE (insn_buf) || +if (cnt ==0 || cnt >=INSN_BUF_SIZE || (ctx_field_size && !target_size)) {verbose (env,"bpf verifier is misconfigured\n" );return -EINVAL ;
@@ -19846,7 +19847,7 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)if (is_narrower_load && size < target_size) {u8 shift =bpf_ctx_narrow_access_offset ( off, size, size_default) *8 ; -if (shift && cnt +1 >=ARRAY_SIZE (insn_buf)) { +if (shift && cnt +1 >=INSN_BUF_SIZE ) {verbose (env,"bpf verifier narrow ctx load misconfigured\n" );return -EINVAL ; }
@@ -20391,7 +20392,7 @@ static int do_misc_fixups(struct bpf_verifier_env *env)const int insn_cnt = prog->len;const struct bpf_map_ops *ops;struct bpf_insn_aux_data *aux; -struct bpf_insn insn_buf[16 ]; +struct bpf_insn *insn_buf = env->insn_buf;struct bpf_prog *new_prog;struct bpf_map *map_ptr;int i, ret, cnt, delta =0 , cur_subprog =0 ;
@@ -20510,7 +20511,7 @@ static int do_misc_fixups(struct bpf_verifier_env *env) (BPF_MODE(insn->code) == BPF_ABS || BPF_MODE(insn->code) == BPF_IND)) { cnt = env->ops->gen_ld_abs (insn, insn_buf); -if (cnt ==0 || cnt >=ARRAY_SIZE (insn_buf)) { +if (cnt ==0 || cnt >=INSN_BUF_SIZE ) {verbose (env,"bpf verifier is misconfigured\n" );return -EINVAL ; }
@@ -20803,7 +20804,7 @@ static int do_misc_fixups(struct bpf_verifier_env *env) cnt = ops->map_gen_lookup (map_ptr, insn_buf);if (cnt == -EOPNOTSUPP ) goto patch_map_ops_generic; -if (cnt <=0 || cnt >=ARRAY_SIZE (insn_buf)) { +if (cnt <=0 || cnt >=INSN_BUF_SIZE ) {verbose (env,"bpf verifier is misconfigured\n" );return -EINVAL ; }
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 2/9 bpf: Adjust BPF_JMP that jumps to the 1st insn of the prologue
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
The next patch will add a ctx ptr saving instruction "(r1 = *(u64 *)(r10 -8)" at the beginning for the main prog when there is an epilogue patch (by the .gen_epilogue() verifier ops added in the next patch).
There is one corner case if the bpf prog has a BPF_JMP that jumps
to the 1st instruction. It needs an adjustment such that
those BPF_JMP instructions won't jump to the newly added
ctx saving instruction.
The commit 5337ac4c9b80 ("bpf: Fix the corner case with may_goto and jump to the 1st insn.") has the details on this case.
Note that the jump back to 1st instruction is not limited to the ctx ptr saving instruction. The same also applies to the prologue. A later test, pro_epilogue_goto_start.c, has a test for the prologue only case.
Thus, this patch does one adjustment after gen_prologue and the future ctx ptr saving. It is done by adjust_jmp_off(env->prog, 0, delta) where delta has the total number of instructions in the prologue and
the future ctx ptr saving instruction.
The adjust_jmp_off(env->prog, 0, delta) assumes that the prologue does not have a goto 1st instruction itself. To accommodate the prologue might have a goto 1st insn itself, this patch changes the adjust_jmp_off() to skip considering the instructions between [tgt_idx, tgt_idx + delta).
--- kernel/bpf/verifier.c | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/bpf/verifier.c +6 -0
@@ -19286,6 +19286,9 @@ static int adjust_jmp_off(struct bpf_prog *prog, u32 tgt_idx, u32 delta)for (i =0 ; i < insn_cnt; i++, insn++) {u8 code = insn->code; +if (tgt_idx <= i && i < tgt_idx + delta) +continue ; +if ((BPF_CLASS (code) !=BPF_JMP &&BPF_CLASS (code) !=BPF_JMP32 ) ||BPF_OP (code) ==BPF_CALL ||BPF_OP (code) ==BPF_EXIT )continue ;
@@ -19704,6 +19707,9 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) } } +if (delta) +WARN_ON (adjust_jmp_off (env->prog,0 , delta)); +if (bpf_prog_is_offloaded (env->prog->aux))return 0 ;
Signature · 1 line
2.43.5
Eduard Zingerman
maintainerRe: [PATCH v5 bpf-next 2/9] bpf: Adjust BPF_JMP that jumps to the 1st insn of the prologue
On Thu, 2024-08-29 at 14:08 -0700, Martin KaFai Lau wrote:
[...]
Quoted 15 lines
kernel/bpf/verifier.c +3
-0@@ -19286,6 +19286,9 @@ static int adjust_jmp_off(struct bpf_prog *prog, u32 tgt_idx, u32 delta)for (i =0 ; i < insn_cnt; i++, insn++) {u8 code = insn->code; +if (tgt_idx <= i && i < tgt_idx + delta) +continue ; +if ((BPF_CLASS (code) !=BPF_JMP &&BPF_CLASS (code) !=BPF_JMP32 ) ||BPF_OP (code) ==BPF_CALL ||BPF_OP (code) ==BPF_EXIT )continue ;
kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) · line 19711
Quoted 5 lines
kernel/bpf/verifier.c +2
-0@@ -19704,6 +19707,9 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) } } +if (delta) +WARN_ON (adjust_jmp_off (env->prog,0 , delta));
Just noticed this.
Suppose prologue is three instructions long and no epilogue, then cnt == 3 and delta == 2, adjust_jmp_off() would skip instructions in range [0..2), while inserted instructions range is [0..2]. So, this would work only if the last statement in the prologue/epilogue generator is:
*insn++ = prog->insnsi[0];
which seems to be true for prologue generators in the tree, but looks a bit unintuitive...
Quoted 4 lines
kernel/bpf/verifier.c +1
-0+if (bpf_prog_is_offloaded (env->prog->aux))return 0 ;
Martin KaFai Lau
reviewerRe: [PATCH v5 bpf-next 2/9] bpf: Adjust BPF_JMP that jumps to the 1st insn of the prologue
Quoted 32 lines · Eduard Zingerman
On Thu, 2024-08-29 at 14:08 -0700, Martin KaFai Lau wrote:
[...]
Quoted 15 lines
kernel/bpf/verifier.c +3
-0@@ -19286,6 +19286,9 @@ static int adjust_jmp_off(struct bpf_prog *prog, u32 tgt_idx, u32 delta)for (i =0 ; i < insn_cnt; i++, insn++) {u8 code = insn->code; +if (tgt_idx <= i && i < tgt_idx + delta) +continue ; +if ((BPF_CLASS (code) !=BPF_JMP &&BPF_CLASS (code) !=BPF_JMP32 ) ||BPF_OP (code) ==BPF_CALL ||BPF_OP (code) ==BPF_EXIT )continue ;kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) · line 19711
Quoted 5 lines
kernel/bpf/verifier.c +2
-0@@ -19704,6 +19707,9 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env) } } +if (delta) +WARN_ON (adjust_jmp_off (env->prog,0 , delta));Just noticed this.
Suppose prologue is three instructions long and no epilogue, then cnt == 3 and delta == 2,adjust_jmp_off()would skip instructions in range [0..2), while inserted instructions range is [0..2]. So, this would work only if the last statement in the prologue/epilogue generator is:
Quoted 4 lines
*insn++ = prog->insnsi[0];which seems to be true for prologue generators in the tree, but looks a bit unintuitive...
Right, it is the current requirement/setup for the existing gen_prologue. It should be obvious to spot if the gen_prologue does not do this and more unlikely also somehow needs to jump back to itself.
Thanks for looking at the patches!
Quoted 7 lines
Quoted 5 lines
kernel/bpf/verifier.c +1
-0+if (bpf_prog_is_offloaded (env->prog->aux))return 0 ;
Martin KaFai Lau
reviewerPATCH v5 3/9 bpf: Add gen_epilogue to bpf_verifier_ops
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
This patch adds a .gen_epilogue to the bpf_verifier_ops. It is similar to the existing .gen_prologue. Instead of allowing a subsystem to run code at the beginning of a bpf prog, it allows the subsystem to run code just before the bpf prog exit.
One of the use case is to allow the upcoming bpf qdisc to ensure that the skb->dev is the same as the qdisc->dev_queue->dev. The bpf qdisc struct_ops implementation could either fix it up or drop the skb. Another use case could be in bpf_tcp_ca.c to enforce snd_cwnd has sane value (e.g. non zero).
The epilogue can do the useful thing (like checking skb->dev) if it can access the bpf prog's ctx. Unlike prologue, r1 may not hold the ctx pointer. This patch saves the r1 in the stack if the .gen_epilogue has returned some instructions in the "epilogue_buf".
The existing .gen_prologue is done in convert_ctx_accesses(). The new .gen_epilogue is done in the convert_ctx_accesses() also. When it sees the (BPF_JMP | BPF_EXIT) instruction, it will be patched with the earlier generated "epilogue_buf". The epilogue patching is only done for the main prog.
Only one epilogue will be patched to the main program. When the bpf prog has multiple BPF_EXIT instructions, a BPF_JA is used to goto the earlier patched epilogue. Majority of the archs support (BPF_JMP32 | BPF_JA): x86, arm, s390, risv64, loongarch, powerpc and arc. This patch keeps it simple and always use (BPF_JMP32 | BPF_JA). A new macro BPF_JMP32_A is added to generate the (BPF_JMP32 | BPF_JA) insn.
--- include/linux/bpf.h | 2 ++ include/linux/bpf_verifier.h | 1 + include/linux/filter.h | 10 ++++++++ kernel/bpf/verifier.c | 46 +++++++++++++++++++++++++++++++++++- 4 files changed, 58 insertions(+), 1 deletion(-)
include/linux/bpf.h +2 -0
@@ -974,6 +974,8 @@ struct bpf_verifier_ops { struct bpf_insn_access_aux *info);int (*gen_prologue)(struct bpf_insn *insn,bool direct_write,const struct bpf_prog *prog); +int (*gen_epilogue)(struct bpf_insn *insn,const struct bpf_prog *prog, +s16 ctx_stack_off);int (*gen_ld_abs)(const struct bpf_insn *orig,struct bpf_insn *insn_buf); u32 (*convert_ctx_access)(enum bpf_access_type type,
include/linux/bpf_verifier.h +1 -0
@@ -783,6 +783,7 @@ struct bpf_verifier_env {*/ char tmp_str_buf[TMP_STR_BUF_LEN ];struct bpf_insn insn_buf[INSN_BUF_SIZE ]; +struct bpf_insn epilogue_buf[INSN_BUF_SIZE ]; };static inline struct bpf_func_info_aux *subprog_aux (struct bpf_verifier_env *env,int subprog)
include/linux/filter.h +10 -0
@@ -437,6 +437,16 @@ static inline bool insn_is_cast_user(const struct bpf_insn *insn) .off = OFF, \ .imm = 0 }) +/* Unconditional jumps, gotol pc + imm32 */ + +#define BPF_JMP32_A (IMM ) \ + ((struct bpf_insn) { \ + .code = BPF_JMP32 | BPF_JA, \ + .dst_reg = 0, \ + .src_reg = 0, \ + .off = 0, \ + .imm = IMM }) +/* Relative call */ #define BPF_CALL_REL (TGT ) \
kernel/bpf/verifier.c +45 -1
72 lines not on this page · raw message
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 4/9 bpf: Export bpf_base_func_proto
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
The bpf_testmod needs to use the bpf_tail_call helper in a later selftest patch. This patch is to EXPORT_GPL_SYMBOL the bpf_base_func_proto.
--- kernel/bpf/helpers.c | 1 + 1 file changed, 1 insertion(+)
kernel/bpf/helpers.c +1 -0
@@ -2034,6 +2034,7 @@ bpf_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)return NULL ; } } +EXPORT_SYMBOL_GPL (bpf_base_func_proto);void bpf_list_head_free (const struct btf_field *field,void *list_head,struct bpf_spin_lock *spin_lock)
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 5/9 selftests/bpf: attach struct_ops maps before test prog runs
In reply to Martin KaFai LauFrom: Eduard Zingerman <[email protected]>
In test_loader based tests to bpf_map__attach_struct_ops() before call to bpf_prog_test_run_opts() in order to trigger bpf_struct_ops->reg() callbacks on kernel side. This allows to use __retval macro for struct_ops tests.
--- tools/testing/selftests/bpf/test_loader.c | 27 +++++++++++++++++++++++ 1 file changed, 27 insertions(+)
tools/testing/selftests/bpf/test_loader.c +27 -0
@@ -890,11 +890,13 @@ void run_subtest(struct test_loader *tester, {struct test_subspec *subspec = unpriv ? &spec->unpriv : &spec->priv;struct bpf_program *tprog =NULL , *tprog_iter; +struct bpf_link *link, *links[32 ] = {};struct test_spec *spec_iter;struct cap_state caps = {};struct bpf_object *tobj;struct bpf_map *map;int retval, err, i; +int links_cnt =0 ;bool should_load;if (!test__start_subtest (subspec->name))
@@ -999,6 +1001,26 @@ void run_subtest(struct test_loader *tester,if (restore_capabilities (&caps)) goto tobj_cleanup; +/* Do bpf_map__attach_struct_ops() for each struct_ops map. +* This should trigger bpf_struct_ops->reg callback on kernel side. +*/ +bpf_object__for_each_map (map, tobj) { +if (!bpf_map__autocreate (map) || +bpf_map__type (map) !=BPF_MAP_TYPE_STRUCT_OPS ) +continue ; +if (links_cnt >=ARRAY_SIZE (links)) { +PRINT_FAIL ("too many struct_ops maps" ); + goto tobj_cleanup; + } + link =bpf_map__attach_struct_ops (map); +if (!link) { +PRINT_FAIL ("bpf_map__attach_struct_ops failed for map %s: err=%d\n" , +bpf_map__name (map), err); + goto tobj_cleanup; + } + links[links_cnt++] = link; + } +if (tester->pre_execution_cb) { err = tester->pre_execution_cb (tobj);if (err) {
@@ -1013,9 +1035,14 @@ void run_subtest(struct test_loader *tester,PRINT_FAIL ("Unexpected retval: %d != %d\n" , retval, subspec->retval); goto tobj_cleanup; } +/* redo bpf_map__attach_struct_ops for each test */ +while (links_cnt >0 ) +bpf_link__destroy (links[--links_cnt]); } tobj_cleanup: +while (links_cnt >0 ) +bpf_link__destroy (links[--links_cnt]);bpf_object__close (tobj); subtest_cleanup:test__end_subtest ();
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 6/9 selftests/bpf: Test gen_prologue and gen_epilogue
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
This test adds a new struct_ops "bpf_testmod_st_ops" in bpf_testmod. The ops of the bpf_testmod_st_ops is triggered by new kfunc calls "bpf_kfunc_st_ops_test_*logue". These new kfunc calls are primarily used by the SEC("syscall") program. The test triggering sequence is like:
SEC("syscall")
syscall_prologue(struct st_ops_args *args)
bpf_kfunc_st_op_test_prologue(args)
st_ops->test_prologue(args).gen_prologue adds 1000 to args->a .gen_epilogue adds 10000 to args->a .gen_epilogue will also set the r0 to 2 * args->a.
The .gen_prologue and .gen_epilogue of the bpf_testmod_st_ops will test the prog->aux->attach_func_name to decide if it needs to generate codes.
The main programs of the pro_epilogue.c will call a new kfunc bpf_kfunc_st_ops_inc10 which does "args->a += 10". It will also call a subprog() which does "args->a += 1".
This patch uses the test_loader infra to check the __xlated instructions patched after gen_prologue and/or gen_epilogue. The __xlated check is based on Eduard's example (Thanks!) in v1.
args->a is returned by the struct_ops prog (either the main prog or the epilogue). Thus, the __retval of the SEC("syscall") prog is checked. For example, when triggering the ops in the 'SEC("struct_ops/test_epilogue") int test_epilogue' The expected args->a is +1 (subprog call) + 10 (kfunc call)
+ 10000 (.gen_epilogue) = 10011.
The expected return value is 2 * 10011 (.gen_epilogue).
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 190 ++++++++++++++++++ .../selftests/bpf/bpf_testmod/bpf_testmod.h | 11 + .../bpf/bpf_testmod/bpf_testmod_kfunc.h | 6 + .../selftests/bpf/prog_tests/pro_epilogue.c | 10 + .../selftests/bpf/progs/pro_epilogue.c | 154 ++++++++++++++ 5 files changed, 371 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/pro_epilogue.c create mode 100644 tools/testing/selftests/bpf/progs/pro_epilogue.c
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +190 -0
@@ -17,6 +17,7 @@#include <linux/in.h> #include <linux/in6.h> #include <linux/un.h> +#include <linux/filter.h> #include <net/sock.h> #include <linux/namei.h> #include "bpf_testmod.h"
@@ -945,6 +946,51 @@ __bpf_kfunc int bpf_kfunc_call_kernel_getpeername(struct addr_args *args)return err; } +static DEFINE_MUTEX (st_ops_mutex); +static struct bpf_testmod_st_ops *st_ops; + +__bpf_kfunc int bpf_kfunc_st_ops_test_prologue(struct st_ops_args *args) +{ +int ret =-1 ; + +mutex_lock (&st_ops_mutex); +if (st_ops && st_ops->test_prologue) + ret = st_ops->test_prologue (args); +mutex_unlock (&st_ops_mutex); + +return ret; +} + +__bpf_kfunc int bpf_kfunc_st_ops_test_epilogue(struct st_ops_args *args) +{ +int ret =-1 ; + +mutex_lock (&st_ops_mutex); +if (st_ops && st_ops->test_epilogue) + ret = st_ops->test_epilogue (args); +mutex_unlock (&st_ops_mutex); + +return ret; +} + +__bpf_kfunc int bpf_kfunc_st_ops_test_pro_epilogue(struct st_ops_args *args) +{ +int ret =-1 ; + +mutex_lock (&st_ops_mutex); +if (st_ops && st_ops->test_pro_epilogue) + ret = st_ops->test_pro_epilogue (args); +mutex_unlock (&st_ops_mutex); + +return ret; +} + +__bpf_kfunc int bpf_kfunc_st_ops_inc10(struct st_ops_args *args) +{ + args->a +=10 ; +return args->a; +} + BTF_KFUNCS_START(bpf_testmod_check_kfunc_ids) BTF_ID_FLAGS(func, bpf_testmod_test_mod_kfunc) BTF_ID_FLAGS(func, bpf_kfunc_call_test1)
@@ -981,6 +1027,10 @@ BTF_ID_FLAGS(func, bpf_kfunc_call_kernel_sendmsg, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_kfunc_call_sock_sendmsg, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_kfunc_call_kernel_getsockname, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_kfunc_call_kernel_getpeername, KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_kfunc_st_ops_test_prologue, KF_TRUSTED_ARGS | KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_kfunc_st_ops_test_epilogue, KF_TRUSTED_ARGS | KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_kfunc_st_ops_test_pro_epilogue, KF_TRUSTED_ARGS | KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_kfunc_st_ops_inc10, KF_TRUSTED_ARGS)BTF_KFUNCS_END (bpf_testmod_check_kfunc_ids) static int bpf_testmod_ops_init(struct btf *btf)
@@ -1100,6 +1150,144 @@ struct bpf_struct_ops bpf_testmod_ops2 = { .owner = THIS_MODULE, }; +static int bpf_test_mod_st_ops__test_prologue (struct st_ops_args *args) +{ +return 0 ; +} + +static int bpf_test_mod_st_ops__test_epilogue (struct st_ops_args *args) +{ +return 0 ; +} + +static int bpf_test_mod_st_ops__test_pro_epilogue (struct st_ops_args *args) +{ +return 0 ; +} + +static int st_ops_gen_prologue (struct bpf_insn *insn_buf,bool direct_write, +const struct bpf_prog *prog) +{ +struct bpf_insn *insn = insn_buf; + +if (strcmp (prog->aux->attach_func_name,"test_prologue" ) && +strcmp (prog->aux->attach_func_name,"test_pro_epilogue" )) +return 0 ; + +/* r6 = r1[0]; // r6 will be "struct st_ops *args". r1 is "u64 *ctx". +* r7 = r6->a; +* r7 += 1000; +* r6->a = r7; +*/ + *insn++ =BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,0 ); + *insn++ =BPF_LDX_MEM (BPF_DW ,BPF_REG_7 ,BPF_REG_6 , offsetof(struct st_ops_args , a)); + *insn++ =BPF_ALU64_IMM (BPF_ADD ,BPF_REG_7 ,1000 ); + *insn++ =BPF_STX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_7 , offsetof(struct st_ops_args , a)); + *insn++ = prog->insnsi[0 ]; + +return insn - insn_buf; +} + +static int st_ops_gen_epilogue (struct bpf_insn *insn_buf,const struct bpf_prog *prog, +s16 ctx_stack_off) +{ +struct bpf_insn *insn = insn_buf; + +if (strcmp (prog->aux->attach_func_name,"test_epilogue" ) && +strcmp (prog->aux->attach_func_name,"test_pro_epilogue" )) +return 0 ; + +/* r1 = stack[ctx_stack_off]; // r1 will be "u64 *ctx" +* r1 = r1[0]; // r1 will be "struct st_ops *args" +* r6 = r1->a; +* r6 += 10000; +* r1->a = r6; +* r0 = r6; +* r0 *= 2; +* BPF_EXIT; +*/ + *insn++ =BPF_LDX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_FP , ctx_stack_off); + *insn++ =BPF_LDX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_1 ,0 ); + *insn++ =BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 , offsetof(struct st_ops_args , a)); + *insn++ =BPF_ALU64_IMM (BPF_ADD ,BPF_REG_6 ,10000 ); + *insn++ =BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_6 , offsetof(struct st_ops_args , a)); + *insn++ =BPF_MOV64_REG (BPF_REG_0 ,BPF_REG_6 ); + *insn++ =BPF_ALU64_IMM (BPF_MUL ,BPF_REG_0 ,2 ); + *insn++ =BPF_EXIT_INSN (); + +return insn - insn_buf; +} + +static int st_ops_btf_struct_access (struct bpf_verifier_log *log, +const struct bpf_reg_state *reg, +int off,int size) +{ +if (off <0 || off + size >sizeof (struct st_ops_args )) +return -EACCES ; +return 0 ; +} + +static const struct bpf_verifier_ops st_ops_verifier_ops = { + .is_valid_access = bpf_testmod_ops_is_valid_access, + .btf_struct_access = st_ops_btf_struct_access, + .gen_prologue = st_ops_gen_prologue, + .gen_epilogue = st_ops_gen_epilogue, + .get_func_proto = bpf_base_func_proto, +}; + +static struct bpf_testmod_st_ops st_ops_cfi_stubs = { + .test_prologue = bpf_test_mod_st_ops__test_prologue, + .test_epilogue = bpf_test_mod_st_ops__test_epilogue, + .test_pro_epilogue = bpf_test_mod_st_ops__test_pro_epilogue, +}; + +static int st_ops_reg (void *kdata,struct bpf_link *link) +{ +int err =0 ; + +mutex_lock (&st_ops_mutex); +if (st_ops) { +pr_err ("st_ops has already been registered\n" ); + err = -EEXIST ; + goto unlock; + } + st_ops = kdata; + +unlock: +mutex_unlock (&st_ops_mutex); +return err; +} + +static void st_ops_unreg (void *kdata,struct bpf_link *link) +{ +mutex_lock (&st_ops_mutex); + st_ops =NULL ; +mutex_unlock (&st_ops_mutex); +} + +static int st_ops_init (struct btf *btf) +{ +return 0 ; +} + +static int st_ops_init_member (const struct btf_type *t, +const struct btf_member *member, +void *kdata,const void *udata) +{ +return 0 ; +} + +static struct bpf_struct_ops testmod_st_ops = { + .verifier_ops = &st_ops_verifier_ops, + .init = st_ops_init, + .init_member = st_ops_init_member, + .reg = st_ops_reg, + .unreg = st_ops_unreg, + .cfi_stubs = &st_ops_cfi_stubs, + .name ="bpf_testmod_st_ops" , + .owner =THIS_MODULE , +}; +extern int bpf_fentry_test1 (int a);static int bpf_testmod_init (void )
@@ -1117,8 +1305,10 @@ static int bpf_testmod_init(void) ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SCHED_CLS , &bpf_testmod_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &bpf_testmod_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SYSCALL , &bpf_testmod_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &bpf_testmod_kfunc_set); ret = ret ?:register_bpf_struct_ops (&bpf_bpf_testmod_ops, bpf_testmod_ops); ret = ret ?:register_bpf_struct_ops (&bpf_testmod_ops2, bpf_testmod_ops2); + ret = ret ?:register_bpf_struct_ops (&testmod_st_ops, bpf_testmod_st_ops); ret = ret ?:register_btf_id_dtor_kfuncs (bpf_testmod_dtors,ARRAY_SIZE (bpf_testmod_dtors),THIS_MODULE );
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.h +11 -0
@@ -94,4 +94,15 @@ struct bpf_testmod_ops2 { int (*test_1)(void); }; +struct st_ops_args { +u64 a; +}; + +struct bpf_testmod_st_ops { +int (*test_prologue)(struct st_ops_args *args); +int (*test_epilogue)(struct st_ops_args *args); +int (*test_pro_epilogue)(struct st_ops_args *args); +struct module *owner; +}; +#endif /* _BPF_TESTMOD_H */
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod_kfunc.h +6 -0
@@ -148,4 +148,10 @@ struct sk_buff *bpf_kfunc_nested_acquire_nonzero_offset_test(struct sk_buff_headstruct sk_buff *bpf_kfunc_nested_acquire_zero_offset_test (struct sock_common *ptr) __ksym; void bpf_kfunc_nested_release_test(struct sk_buff *ptr) __ksym; +struct st_ops_args ; +int bpf_kfunc_st_ops_test_prologue(struct st_ops_args *args) __ksym; +int bpf_kfunc_st_ops_test_epilogue(struct st_ops_args *args) __ksym; +int bpf_kfunc_st_ops_test_pro_epilogue(struct st_ops_args *args) __ksym; +int bpf_kfunc_st_ops_inc10(struct st_ops_args *args) __ksym; +#endif /* _BPF_TESTMOD_KFUNC_H */
tools/testing/selftests/bpf/prog_tests/pro_epilogue.c new file +10 -0
@@ -0,0 +1,10 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */ + +#include <test_progs.h> +#include "pro_epilogue.skel.h" + +void test_pro_epilogue (void ) +{ +RUN_TESTS (pro_epilogue); +}
tools/testing/selftests/bpf/progs/pro_epilogue.c new file +154 -0
154 lines not on this page · raw message
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 7/9 selftests/bpf: Add tailcall epilogue test
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
This patch adds a gen_epilogue test to test a main prog using a bpf_tail_call.
A non test_loader test is used. The tailcall target program, "test_epilogue_subprog", needs to be used in a struct_ops map before it can be loaded. Another struct_ops map is also needed to host the actual "test_epilogue_tailcall" struct_ops program that does the bpf_tail_call. The earlier test_loader patch will attach all struct_ops maps but the bpf_testmod.c does not support >1 attached struct_ops.
The earlier patch used the test_loader which has already covered checking for the patched pro/epilogue instructions. This is done by the __xlated tag.
This patch goes for the regular skel load and syscall test to do the tailcall test that can also allow to directly pass the the "struct st_ops_args *args" as ctx_in to the SEC("syscall") program.
--- .../selftests/bpf/prog_tests/pro_epilogue.c | 46 +++++++++++++++ .../selftests/bpf/progs/epilogue_tailcall.c | 58 +++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/epilogue_tailcall.c
tools/testing/selftests/bpf/prog_tests/pro_epilogue.c +46 -0
@@ -3,8 +3,54 @@#include <test_progs.h> #include "pro_epilogue.skel.h" +#include "epilogue_tailcall.skel.h" + +struct st_ops_args { +__u64 a; +}; + +static void test_tailcall (void ) +{ +LIBBPF_OPTS (bpf_test_run_opts, topts); +struct epilogue_tailcall *skel; +struct st_ops_args args; +int err, prog_fd; + + skel =epilogue_tailcall__open_and_load (); +if (!ASSERT_OK_PTR (skel,"epilogue_tailcall__open_and_load" )) +return ; + + topts.ctx_in = &args; + topts.ctx_size_in =sizeof (args); + + skel->links.epilogue_tailcall = +bpf_map__attach_struct_ops (skel->maps.epilogue_tailcall); +if (!ASSERT_OK_PTR (skel->links.epilogue_tailcall,"attach_struct_ops" )) + goto done; + +/* Both test_epilogue_tailcall and test_epilogue_subprog are +* patched with epilogue. When syscall_epilogue_tailcall() +* is run, test_epilogue_tailcall() is triggered. +* It executes a tail call and control is transferred to +* test_epilogue_subprog(). Only test_epilogue_subprog() +* does args->a += 1, thus final args.a value of 10001 +* guarantees that only the epilogue of the +* test_epilogue_subprog is executed. +*/ +memset (&args,0 ,sizeof (args)); + prog_fd =bpf_program__fd (skel->progs.syscall_epilogue_tailcall); + err =bpf_prog_test_run_opts (prog_fd, &topts); +ASSERT_OK (err,"bpf_prog_test_run_opts" ); +ASSERT_EQ (args.a,10001 ,"args.a" ); +ASSERT_EQ (topts.retval,10001 *2 ,"topts.retval" ); + +done: +epilogue_tailcall__destroy (skel); +}void test_pro_epilogue (void ) {RUN_TESTS (pro_epilogue); +if (test__start_subtest ("tailcall" )) +test_tailcall (); }
tools/testing/selftests/bpf/progs/epilogue_tailcall.c new file +58 -0
58 lines not on this page · raw message
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 8/9 selftests/bpf: A pro/epilogue test when the main prog jumps back to the 1st insn
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
This patch adds a pro/epilogue test when the main prog has a goto insn that goes back to the very first instruction of the prog. It is to test the correctness of the adjust_jmp_off(prog, 0, delta) after the verifier has applied the prologue and/or epilogue patch.
--- .../selftests/bpf/prog_tests/pro_epilogue.c | 2 + .../bpf/progs/pro_epilogue_goto_start.c | 149 ++++++++++++++++++ 2 files changed, 151 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/pro_epilogue_goto_start.c
tools/testing/selftests/bpf/prog_tests/pro_epilogue.c +2 -0
@@ -4,6 +4,7 @@#include <test_progs.h> #include "pro_epilogue.skel.h" #include "epilogue_tailcall.skel.h" +#include "pro_epilogue_goto_start.skel.h" struct st_ops_args {__u64 a;
@@ -51,6 +52,7 @@ static void test_tailcall(void)void test_pro_epilogue (void ) {RUN_TESTS (pro_epilogue); +RUN_TESTS (pro_epilogue_goto_start);if (test__start_subtest ("tailcall" ))test_tailcall (); }
tools/testing/selftests/bpf/progs/pro_epilogue_goto_start.c new file +149 -0
149 lines not on this page · raw message
Signature · 1 line
2.43.5
Martin KaFai Lau
reviewerPATCH v5 9/9 selftests/bpf: Test epilogue patching when the main prog has multiple BPF_EXIT
In reply to Martin KaFai LauFrom: Martin KaFai Lau <[email protected]>
This patch tests the epilogue patching when the main prog has multiple BPF_EXIT. The verifier should have patched the 2nd (and later) BPF_EXIT with a BPF_JA that goes back to the earlier patched epilogue instructions.
--- .../selftests/bpf/prog_tests/pro_epilogue.c | 2 + .../selftests/bpf/progs/epilogue_exit.c | 82 +++++++++++++++++++ 2 files changed, 84 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/epilogue_exit.c
tools/testing/selftests/bpf/prog_tests/pro_epilogue.c +2 -0
@@ -5,6 +5,7 @@#include "pro_epilogue.skel.h" #include "epilogue_tailcall.skel.h" #include "pro_epilogue_goto_start.skel.h" +#include "epilogue_exit.skel.h" struct st_ops_args {__u64 a;
@@ -53,6 +54,7 @@ void test_pro_epilogue(void) {RUN_TESTS (pro_epilogue);RUN_TESTS (pro_epilogue_goto_start); +RUN_TESTS (epilogue_exit);if (test__start_subtest ("tailcall" ))test_tailcall (); }
tools/testing/selftests/bpf/progs/epilogue_exit.c new file +82 -0
82 lines not on this page · raw message
Signature · 1 line
2.43.5
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 11 lines · On Thu, 29 Aug 2024 14:08:22 -0700 you wrote:
From: Martin KaFai Lau <[email protected]>
This set allows the subsystem to patch codes before
BPF_EXIT. The verifier ops, .gen_epilogue, is added for this purpose. One of the use case will be in the bpf qdisc, the bpf qdisc subsystem can ensure theskb->devis in the correct value. The bpf qdisc subsystem can either inline fixing it in the epilogue or call another kernel function to handle it (e.g. drop) in the epilogue. Another use case could be inbpf_tcp_ca.cto enforcesnd_cwndhas valid value (e.g. positive value).
Quoted 1 line
[...]
Here is the summary with links:
- [v5,bpf-next,1/9] bpf: Move insn_buf[16] to bpf_verifier_env
https://git.kernel.org/bpf/bpf-next/c/6f606ffd6dd7 - [v5,bpf-next,2/9] bpf: Adjust BPF_JMP that jumps to the 1st insn of the prologue https://git.kernel.org/bpf/bpf-next/c/d5c47719f244 - [v5,bpf-next,3/9] bpf: Add gen_epilogue to bpf_verifier_ops https://git.kernel.org/bpf/bpf-next/c/169c31761c8d - [v5,bpf-next,4/9] bpf: Export bpf_base_func_proto https://git.kernel.org/bpf/bpf-next/c/866d571e6201 - [v5,bpf-next,5/9] selftests/bpf: attach struct_ops maps before test prog runs https://git.kernel.org/bpf/bpf-next/c/a0dbf6d0b21e - [v5,bpf-next,6/9] selftests/bpf: Test gen_prologue and gen_epilogue https://git.kernel.org/bpf/bpf-next/c/47e69431b57a - [v5,bpf-next,7/9] selftests/bpf: Add tailcall epilogue test https://git.kernel.org/bpf/bpf-next/c/b191b0fd7400 - [v5,bpf-next,8/9] selftests/bpf: A pro/epilogue test when the main prog jumps back to the 1st insn https://git.kernel.org/bpf/bpf-next/c/42fdbbde6cf4 - [v5,bpf-next,9/9] selftests/bpf: Test epilogue patching when the main prog has multiple BPF_EXIT https://git.kernel.org/bpf/bpf-next/c/cada0bdcc471
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html