bpf: simple DFA-based live registers analysis
Subsystems (4)
Eduard Zingerman
maintainerv3 cover bpf: simple DFA-based live registers analysis
This patch-set introduces a simple live registers DFA analysis. Analysis is done as a separate step before main verification pass. Results are stored in the env->insn_aux_data for each instruction.
The change helps with iterator/callback based loops handling, as regular register liveness marks are not finalized while loops are processed. See veristat results in patch #2.
Note: for regular subprogram calls analysis conservatively assumes that r1-r5 are used, and r0 is used at each 'exit' instruction. Experiments show that adding logic handling these cases precisely has no impact on verification performance.
The patch set was tested by disabling the current register parentage chain liveness computation, using DFA-based liveness for registers while assuming all stack slots as live. See discussion in [1].
Changes v2 -> v3:
- added support for BPF_LOAD_ACQ, BPF_STORE_REL atomics (Alexei);
- correct use marks for r0 for BPF_CMPXCHG.
Changes v1 -> v2:
- added a refactoring commit extracting utility functions:
jmp_offset(), verbose_insn() (Alexei);
- added a refactoring commit extracting utility function get_call_summary() in order to share helper/kfunc related code with mark_fastcall_pattern_for_call() (Alexei);
- comment in the compute_insn_live_regs() extended (Alexei).
Changes RFC -> v1:
- parameter count for helpers and kfuncs is taken into account;
- copy_verifier_state() bugfix had been merged as a separate patch-set and is no longer a part of this patch set.
RFC: https://lore.kernel.org/bpf/[email protected]/ v1: https://lore.kernel.org/bpf/[email protected]/ v2: https://lore.kernel.org/bpf/[email protected]/
[1] https://lore.kernel.org/bpf/[email protected]/
Eduard Zingerman (5):
bpf: jmp_offset() and verbose_insn() utility functions
bpf: get_call_summary() utility function
bpf: simple DFA-based live registers analysis
bpf: use register liveness information for func_states_equal selftests/bpf: test cases for compute_live_registers()
include/linux/bpf_verifier.h | 6 + kernel/bpf/verifier.c | 495 ++++++++++++++---- .../testing/selftests/bpf/prog_tests/align.c | 11 +- .../bpf/prog_tests/compute_live_registers.c | 9 + tools/testing/selftests/bpf/progs/bpf_misc.h | 17 + .../bpf/progs/compute_live_registers.c | 424 +++++++++++++++ .../selftests/bpf/progs/verifier_gotol.c | 6 +- .../bpf/progs/verifier_iterating_callbacks.c | 6 +- .../bpf/progs/verifier_load_acquire.c | 7 +- 9 files changed, 875 insertions(+), 106 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/compute_live_registers.c create mode 100644 tools/testing/selftests/bpf/progs/compute_live_registers.c
Signature · 1 line
2.48.1
Eduard Zingerman
maintainerPATCH v3 1/5 bpf: jmp_offset() and verbose_insn() utility functions
Extract two utility functions:
- One BPF jump instruction uses .imm field to encode jump offset, while the rest use .off. Encapsulate this detail as jmp_offset() function.
- Avoid duplicating instruction printing callback definitions by defining a verbose_insn() function, which disassembles an instruction into the verifier log while hiding this detail.
These functions will be used in the next patch.
--- kernel/bpf/verifier.c | 40 +++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-)
kernel/bpf/verifier.c +23 -17
@@ -3360,6 +3360,15 @@ static int add_subprog_and_kfunc(struct bpf_verifier_env *env)return 0 ; } +static int jmp_offset (struct bpf_insn *insn) +{ +u8 code = insn->code; + +if (code == (BPF_JMP32 |BPF_JA )) +return insn->imm; +return insn->off; +} +static int check_subprogs (struct bpf_verifier_env *env) {int i, subprog_start, subprog_end, off, cur_subprog =0 ;
@@ -3386,10 +3395,7 @@ static int check_subprogs(struct bpf_verifier_env *env) goto next;if (BPF_OP (code) ==BPF_EXIT ||BPF_OP (code) ==BPF_CALL ) goto next; -if (code == (BPF_JMP32 |BPF_JA )) - off = i + insn[i].imm +1 ; -else - off = i + insn[i].off +1 ; + off = i +jmp_offset (&insn[i]) +1 ;if (off < subprog_start || off >= subprog_end) {verbose (env,"jump out of range from insn %d to %d\n" , i, off);return -EINVAL ;
@@ -3919,6 +3925,17 @@ static const char *disasm_kfunc_name(void *data, const struct bpf_insn *insn)return btf_name_by_offset (desc_btf, func->name_off); } +static void verbose_insn (struct bpf_verifier_env *env,struct bpf_insn *insn) +{ +const struct bpf_insn_cbs cbs = { + .cb_call = disasm_kfunc_name, + .cb_print = verbose, + .private_data = env, + }; + +print_bpf_insn (&cbs, insn, env->allow_ptr_leaks); +} +static inline void bt_init (struct backtrack_state *bt,u32 frame) { bt->frame = frame;
@@ -4119,11 +4136,6 @@ static bool calls_callback(struct bpf_verifier_env *env, int insn_idx);static int backtrack_insn (struct bpf_verifier_env *env,int idx,int subseq_idx,struct bpf_insn_hist_entry *hist,struct backtrack_state *bt) { -const struct bpf_insn_cbs cbs = { - .cb_call = disasm_kfunc_name, - .cb_print = verbose, - .private_data = env, - };struct bpf_insn *insn = env->prog->insnsi + idx;u8 class =BPF_CLASS (insn->code);u8 opcode =BPF_OP (insn->code);
@@ -4141,7 +4153,7 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx, int subseq_idx,fmt_stack_mask (env->tmp_str_buf,TMP_STR_BUF_LEN ,bt_stack_mask (bt));verbose (env,"stack=%s before " , env->tmp_str_buf);verbose (env,"%d: " , idx); -print_bpf_insn (&cbs, insn, env->allow_ptr_leaks); +verbose_insn (env, insn); }/* If there is a history record that some registers gained range at this insn,
@@ -19273,19 +19285,13 @@ static int do_check(struct bpf_verifier_env *env) }if (env->log.level &BPF_LOG_LEVEL ) { -const struct bpf_insn_cbs cbs = { - .cb_call = disasm_kfunc_name, - .cb_print = verbose, - .private_data = env, - }; -if (verifier_state_scratched (env))print_insn_state (env, state, state->curframe);verbose_linfo (env, env->insn_idx,"; " ); env->prev_log_pos = env->log.end_pos;verbose (env,"%d: " , env->insn_idx); -print_bpf_insn (&cbs, insn, env->allow_ptr_leaks); +verbose_insn (env, insn); env->prev_insn_print_pos = env->log.end_pos - env->prev_log_pos; env->prev_log_pos = env->log.end_pos; }
Signature · 1 line
2.48.1
Eduard Zingerman
maintainerPATCH v3 2/5 bpf: get_call_summary() utility function
In reply to Eduard ZingermanRefactor mark_fastcall_pattern_for_call() to extract a utility function get_call_summary(). For a helper or kfunc call this function fills the following information: {num_params, is_void, fastcall}.
This function would be used in the next patch in order to get number of parameters of a helper or kfunc call.
--- kernel/bpf/verifier.c | 121 ++++++++++++++++++++---------------------- 1 file changed, 57 insertions(+), 64 deletions(-)
kernel/bpf/verifier.c +57 -64
@@ -17019,27 +17019,6 @@ static int visit_func_call_insn(int t, struct bpf_insn *insns,/* Bitmask with 1s for all caller saved registers */ #define ALL_CALLER_SAVED_REGS ((1u << CALLER_SAVED_REGS) - 1) -/* Return a bitmask specifying which caller saved registers are -* clobbered by a call to a helper *as if* this helper follows -* bpf_fastcall contract: -* - includes R0 if function is non-void; -* - includes R1-R5 if corresponding parameter has is described -* in the function prototype. -*/ -static u32 helper_fastcall_clobber_mask (const struct bpf_func_proto *fn) -{ -u32 mask; -int i; - - mask =0 ; -if (fn->ret_type !=RET_VOID ) - mask |=BIT (BPF_REG_0 ); -for (i =0 ; i <ARRAY_SIZE (fn->arg_type); ++i) -if (fn->arg_type[i] !=ARG_DONTCARE ) - mask |=BIT (BPF_REG_1 + i); -return mask; -} -/* True if do_misc_fixups() replaces calls to helper number 'imm', * replacement patch is presumed to follow bpf_fastcall contract * (see mark_fastcall_pattern_for_call() below).
@@ -17056,24 +17035,54 @@ static bool verifier_inlines_helper_call(struct bpf_verifier_env *env, s32 imm) } } -/* Same as helper_fastcall_clobber_mask() but for kfuncs, see comment above */ -static u32 kfunc_fastcall_clobber_mask (struct bpf_kfunc_call_arg_meta *meta) +struct call_summary { +u8 num_params; +bool is_void; +bool fastcall; +}; + +/* If @call is a kfunc or helper call, fills @cs and returns true, +* otherwise returns false. +*/ +static bool get_call_summary (struct bpf_verifier_env *env,struct bpf_insn *call, +struct call_summary *cs) { -u32 vlen, i, mask; +struct bpf_kfunc_call_arg_meta meta; +const struct bpf_func_proto *fn; +int i; - vlen =btf_type_vlen (meta->func_proto); - mask =0 ; -if (!btf_type_is_void (btf_type_by_id (meta->btf, meta->func_proto->type))) - mask |=BIT (BPF_REG_0 ); -for (i =0 ; i < vlen; ++i) - mask |=BIT (BPF_REG_1 + i); -return mask; -} +if (bpf_helper_call (call)) { -/* Same as verifier_inlines_helper_call() but for kfuncs, see comment above */ -static bool is_fastcall_kfunc_call (struct bpf_kfunc_call_arg_meta *meta) -{ -return meta->kfunc_flags &KF_FASTCALL ; +if (get_helper_proto (env, call->imm, &fn) <0 ) +/* error would be reported later */ +return false; + cs->fastcall = fn->allow_fastcall && + (verifier_inlines_helper_call (env, call->imm) || +bpf_jit_inlines_helper_call (call->imm)); + cs->is_void = fn->ret_type ==RET_VOID ; + cs->num_params =0 ; +for (i =0 ; i <ARRAY_SIZE (fn->arg_type); ++i) { +if (fn->arg_type[i] ==ARG_DONTCARE ) +break ; + cs->num_params++; + } +return true; + } + +if (bpf_pseudo_kfunc_call (call)) { +int err; + + err =fetch_kfunc_meta (env, call, &meta,NULL ); +if (err <0 ) +/* error would be reported later */ +return false; + cs->num_params =btf_type_vlen (meta.func_proto); + cs->fastcall = meta.kfunc_flags &KF_FASTCALL ; + cs->is_void =btf_type_is_void (btf_type_by_id (meta.btf, meta.func_proto->type)); +return true; + } + +return false; }/* LLVM define a bpf_fastcall function attribute.
@@ -17156,39 +17165,23 @@ static void mark_fastcall_pattern_for_call(struct bpf_verifier_env *env, {struct bpf_insn *insns = env->prog->insnsi, *stx, *ldx;struct bpf_insn *call = &env->prog->insnsi[insn_idx]; -const struct bpf_func_proto *fn; -u32 clobbered_regs_mask =ALL_CALLER_SAVED_REGS ; +u32 clobbered_regs_mask; +struct call_summary cs;u32 expected_regs_mask; -bool can_be_inlined = false;s16 off;int i; -if (bpf_helper_call (call)) { -if (get_helper_proto (env, call->imm, &fn) <0 ) -/* error would be reported later */ -return ; - clobbered_regs_mask =helper_fastcall_clobber_mask (fn); - can_be_inlined = fn->allow_fastcall && - (verifier_inlines_helper_call (env, call->imm) || -bpf_jit_inlines_helper_call (call->imm)); - } - -if (bpf_pseudo_kfunc_call (call)) { -struct bpf_kfunc_call_arg_meta meta; -int err; - - err =fetch_kfunc_meta (env, call, &meta,NULL ); -if (err <0 ) -/* error would be reported later */ -return ; - - clobbered_regs_mask =kfunc_fastcall_clobber_mask (&meta); - can_be_inlined =is_fastcall_kfunc_call (&meta); - } - -if (clobbered_regs_mask ==ALL_CALLER_SAVED_REGS ) +if (!get_call_summary (env, call, &cs))return ; +/* A bitmask specifying which caller saved registers are clobbered +* by a call to a helper/kfunc *as if* this helper/kfunc follows +* bpf_fastcall contract: +* - includes R0 if function is non-void; +* - includes R1-R5 if corresponding parameter has is described +* in the function prototype. +*/ + clobbered_regs_mask =GENMASK (cs.num_params, cs.is_void ?1 :0 );/* e.g. if helper call clobbers r{0,1}, expect r{2,3,4,5} in the pattern */ expected_regs_mask = ~clobbered_regs_mask &ALL_CALLER_SAVED_REGS ;
@@ -17246,7 +17239,7 @@ static void mark_fastcall_pattern_for_call(struct bpf_verifier_env *env,* don't set 'fastcall_spills_num' for call B so that remove_fastcall_spills_fills() * does not remove spill/fill pair {4,6}. */ -if (can_be_inlined) +if (cs.fastcall) env->insn_aux_data[insn_idx].fastcall_spills_num = i -1 ;else subprog->keep_fastcall_stack =1 ;
Signature · 1 line
2.48.1
Eduard Zingerman
maintainerPATCH v3 3/5 bpf: simple DFA-based live registers analysis
In reply to Eduard ZingermanCompute may-live registers before each instruction in the program. The register is live before the instruction I if it is read by I or some instruction S following I during program execution and is not overwritten between I and S.
This information would be used in the next patch as a hint in func_states_equal().
Use a simple algorithm described in [1] to compute this information:
- define the following:
- I.use : a set of all registers read by instruction I;
- I.def : a set of all registers written by instruction I;
- I.in : a set of all registers that may be alive before I execution;
- I.out : a set of all registers that may be alive after I execution;
- I.successors : a set of instructions S that might immediately
follow I for some program execution;
- associate separate empty sets 'I.in' and 'I.out' with each instruction;
- visit each instruction in a postorder and update corresponding 'I.in' and 'I.out' sets as follows:
I.out = U [S.in for S in I.successors]
I.in = (I.out / I.def) U I.use
(where U stands for set union, / stands for set difference)
- repeat the computation while I.{in,out} changes for any instruction.
On implementation side keep things as simple, as possible:
- check_cfg() already marks instructions EXPLORED in post-order, modify it to save the index of each EXPLORED instruction in a vector;
- represent I.{in,out,use,def} as bitmasks;
- don't split the program into basic blocks and don't maintain the work queue, instead:
- do fixed-point computation by visiting each instruction;
- maintain a simple 'changed' flag if I.{in,out} for any instruction
change;
Measurements show that even such simplistic implementation does not add measurable verification time overhead (for selftests, at-least).
Note on check_cfg() ex_insn_beg/ex_done change:
To avoid out of bounds access to env->cfg.insn_postorder array, it should be guaranteed that instruction transitions to EXPLORED state only once. Previously this was not the fact for incorrect programs with direct calls to exception callbacks.
The 'align' selftest needs adjustment to skip computed insn/live registers printout. Otherwise it matches lines from the live registers printout.
[1] https://en.wikipedia.org/wiki/Live-variable_analysis
--- include/linux/bpf_verifier.h | 6 + kernel/bpf/verifier.c | 320 +++++++++++++++++- .../testing/selftests/bpf/prog_tests/align.c | 11 +- 3 files changed, 330 insertions(+), 7 deletions(-)
include/linux/bpf_verifier.h +6 -0
@@ -591,6 +591,8 @@ struct bpf_insn_aux_data {* accepts callback function as a parameter. */ bool calls_callback; +/* registers alive before this instruction. */ +u16 live_regs_before; };#define MAX_USED_MAPS 64/* max number of maps accessed by one eBPF program */
@@ -748,7 +750,11 @@ struct bpf_verifier_env {struct {int *insn_state;int *insn_stack; +/* vector of instruction indexes sorted in post-order */ +int *insn_postorder;int cur_stack; +/* current position in the insn_postorder vector */ +int cur_postorder; } cfg;struct backtrack_state bt;struct bpf_insn_hist_entry *insn_hist;
kernel/bpf/verifier.c +314 -6
366 lines not on this page · raw message
tools/testing/selftests/bpf/prog_tests/align.c +10 -1
@@ -610,9 +610,11 @@ static int do_test_single(struct bpf_align_test *test) .log_size = sizeof(bpf_vlog), .log_level = 2, ); +const char *main_pass_start ="0: R1=ctx() R10=fp0" ;const char *line_ptr;int cur_line =-1 ;int prog_len, i; +char *start;int fd_prog;int ret;
@@ -632,7 +634,13 @@ static int do_test_single(struct bpf_align_test *test) ret =0 ;/* We make a local copy so that we can strtok() it */ strncpy (bpf_vlog_copy, bpf_vlog,sizeof (bpf_vlog_copy)); - line_ptr =strtok (bpf_vlog_copy,"\n" ); + start =strstr (bpf_vlog_copy, main_pass_start); +if (!start) { + ret =1 ; +printf ("Can't find initial line '%s'\n" , main_pass_start); + goto out; + } + line_ptr =strtok (start,"\n" );for (i =0 ; i <MAX_MATCHES ; i++) {struct bpf_reg_match m = test->matches[i];const char *p;
@@ -682,6 +690,7 @@ static int do_test_single(struct bpf_align_test *test)break ; } } +out:if (fd_prog >=0 )close (fd_prog); }
Signature · 1 line
2.48.1
Eduard Zingerman
maintainerPATCH v3 4/5 bpf: use register liveness information for func_states_equal
In reply to Eduard ZingermanLiveness analysis DFA computes a set of registers live before each instruction. Leverage this information to skip comparison of dead registers in func_states_equal(). This helps with convergance of iterator processing loops, as bpf_reg_state->live marks can't be used when loops are processed.
This has certain performance impact for selftests, here is a veristat listing using -f "insns_pct>5" -f "!insns<200"
selftests:
File Program States (A) States (B) States (DIFF) -------------------- ----------------------------- ---------- ---------- -------------- arena_htab.bpf.o arena_htab_llvm 37 35 -2 (-5.41%) arena_htab_asm.bpf.o arena_htab_asm 37 33 -4 (-10.81%) arena_list.bpf.o arena_list_add 37 22 -15 (-40.54%) dynptr_success.bpf.o test_dynptr_copy 22 16 -6 (-27.27%) dynptr_success.bpf.o test_dynptr_copy_xdp 68 58 -10 (-14.71%) iters.bpf.o checkpoint_states_deletion 918 40 -878 (-95.64%) iters.bpf.o clean_live_states 136 66 -70 (-51.47%) iters.bpf.o iter_nested_deeply_iters 43 37 -6 (-13.95%) iters.bpf.o iter_nested_iters 72 62 -10 (-13.89%) iters.bpf.o iter_pass_iter_ptr_to_subprog 30 26 -4 (-13.33%) iters.bpf.o iter_subprog_iters 68 59 -9 (-13.24%) iters.bpf.o loop_state_deps2 35 32 -3 (-8.57%) iters_css.bpf.o iter_css_for_each 32 29 -3 (-9.38%) pyperf600_iter.bpf.o on_event 286 192 -94 (-32.87%)
Total progs: 3578 Old success: 2061 New success: 2061 States diff min: -95.64% States diff max: 0.00% -100 .. -90 %: 1 -55 .. -45 %: 3 -45 .. -35 %: 2 -35 .. -25 %: 5 -20 .. -10 %: 12 -10 .. 0 %: 6
sched_ext:
File Program States (A) States (B) States (DIFF) ----------------- ---------------------- ---------- ---------- --------------- bpf.bpf.o lavd_dispatch 8950 7065 -1885 (-21.06%) bpf.bpf.o lavd_init 516 480 -36 (-6.98%) bpf.bpf.o layered_dispatch 662 501 -161 (-24.32%) bpf.bpf.o layered_dump 298 237 -61 (-20.47%) bpf.bpf.o layered_init 523 423 -100 (-19.12%) bpf.bpf.o layered_init_task 24 22 -2 (-8.33%) bpf.bpf.o layered_runnable 151 125 -26 (-17.22%) bpf.bpf.o p2dq_dispatch 66 53 -13 (-19.70%) bpf.bpf.o p2dq_init 170 142 -28 (-16.47%) bpf.bpf.o refresh_layer_cpumasks 120 78 -42 (-35.00%) bpf.bpf.o rustland_init 37 34 -3 (-8.11%) bpf.bpf.o rustland_init 37 34 -3 (-8.11%) bpf.bpf.o rusty_select_cpu 125 108 -17 (-13.60%) scx_central.bpf.o central_dispatch 59 43 -16 (-27.12%) scx_central.bpf.o central_init 39 28 -11 (-28.21%) scx_nest.bpf.o nest_init 58 51 -7 (-12.07%) scx_pair.bpf.o pair_dispatch 142 111 -31 (-21.83%) scx_qmap.bpf.o qmap_dispatch 174 141 -33 (-18.97%) scx_qmap.bpf.o qmap_init 768 654 -114 (-14.84%)
Total progs: 216 Old success: 186 New success: 186 States diff min: -35.00% States diff max: 0.00% -35 .. -25 %: 3 -25 .. -20 %: 6 -20 .. -15 %: 6 -15 .. -5 %: 7 -5 .. 0 %: 6
--- kernel/bpf/verifier.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)
kernel/bpf/verifier.c +10 -4
@@ -18500,15 +18500,17 @@ static bool refsafe(struct bpf_verifier_state *old, struct bpf_verifier_state *c* the current state will reach 'bpf_exit' instruction safely */ static bool func_states_equal (struct bpf_verifier_env *env,struct bpf_func_state *old, -struct bpf_func_state *cur,enum exact_level exact) +struct bpf_func_state *cur,u32 insn_idx,enum exact_level exact) { -int i; +u16 live_regs = env->insn_aux_data[insn_idx].live_regs_before; +u16 i;if (old->callback_depth > cur->callback_depth)return false;for (i =0 ; i <MAX_BPF_REG ; i++) -if (!regsafe (env, &old->regs[i], &cur->regs[i], +if (((1 << i) & live_regs) && + !regsafe (env, &old->regs[i], &cur->regs[i], &env->idmap_scratch, exact))return false;
@@ -18529,6 +18531,7 @@ static bool states_equal(struct bpf_verifier_env *env,struct bpf_verifier_state *cur, enum exact_level exact) { + u32 insn_idx;int i;if (old->curframe != cur->curframe)
@@ -18552,9 +18555,12 @@ static bool states_equal(struct bpf_verifier_env *env,* and all frame states need to be equivalent */ for (i =0 ; i <= old->curframe; i++) { + insn_idx = i == old->curframe + ? env->insn_idx + : old->frame[i +1 ]->callsite;if (old->frame[i]->callsite != cur->frame[i]->callsite)return false; -if (!func_states_equal (env, old->frame[i], cur->frame[i], exact)) +if (!func_states_equal (env, old->frame[i], cur->frame[i], insn_idx, exact))return false; }return true;
Signature · 1 line
2.48.1
Eduard Zingerman
maintainerPATCH v3 5/5 selftests/bpf: test cases for compute_live_registers()
In reply to Eduard ZingermanCover instructions from each kind:
- assignment
- arithmetic
- store/load
- endian conversion
- atomics
- branches, conditional branches, may_goto, calls
- LD_ABS/LD_IND
- address_space_cast
--- .../bpf/prog_tests/compute_live_registers.c | 9 + tools/testing/selftests/bpf/progs/bpf_misc.h | 17 + .../bpf/progs/compute_live_registers.c | 424 ++++++++++++++++++ .../selftests/bpf/progs/verifier_gotol.c | 6 +- .../bpf/progs/verifier_iterating_callbacks.c | 6 +- .../bpf/progs/verifier_load_acquire.c | 7 +- 6 files changed, 455 insertions(+), 14 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/compute_live_registers.c create mode 100644 tools/testing/selftests/bpf/progs/compute_live_registers.c
tools/testing/selftests/bpf/prog_tests/compute_live_registers.c new file +9 -0
@@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "compute_live_registers.skel.h" +#include "test_progs.h" + +void test_compute_live_registers (void ) +{ +RUN_TESTS (compute_live_registers); +}
tools/testing/selftests/bpf/progs/bpf_misc.h +17 -0
@@ -213,4 +213,21 @@#define ARRAY_SIZE (x) (sizeof(x) / sizeof((x)[0]))#endif +#if (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86) || \ + (defined(__TARGET_ARCH_riscv) && __riscv_xlen ==64 ) || \ + defined(__TARGET_ARCH_arm) || defined(__TARGET_ARCH_s390) || \ + defined(__TARGET_ARCH_loongarch)) && \ + __clang_major__ >=18 +#define CAN_USE_GOTOL +#endif + +#if _clang_major__ >=18 +#define CAN_USE_BPF_ST +#endif + +#if __clang_major__ >=18 && defined(ENABLE_ATOMICS_TESTS ) && \ + (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86)) +#define CAN_USE_LOAD_ACQ_STORE_REL +#endif +#endif
tools/testing/selftests/bpf/progs/compute_live_registers.c new file +424 -0
424 lines not on this page · raw message
tools/testing/selftests/bpf/progs/verifier_gotol.c +1 -5
@@ -4,11 +4,7 @@#include <bpf/bpf_helpers.h> #include "bpf_misc.h" -#if (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86) || \ - (defined(__TARGET_ARCH_riscv) && __riscv_xlen ==64 ) || \ - defined(__TARGET_ARCH_arm) || defined(__TARGET_ARCH_s390) || \ - defined(__TARGET_ARCH_loongarch)) && \ - __clang_major__ >=18 +#ifdef CAN_USE_GOTOL SEC("socket")__description ("gotol, small_imm" )
tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c +1 -5
@@ -407,11 +407,7 @@ l0_%=: call %[bpf_jiffies64]; \ : __clobber_all); } -#if (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86) || \ - (defined(__TARGET_ARCH_riscv) && __riscv_xlen ==64 ) || \ - defined(__TARGET_ARCH_arm) || defined(__TARGET_ARCH_s390) || \ - defined(__TARGET_ARCH_loongarch)) && \ - __clang_major__ >=18 +#ifdef CAN_USE_GOTOL SEC("socket") __success __retval(0)__naked void gotol_and_may_goto (void )
tools/testing/selftests/bpf/progs/verifier_load_acquire.c +3 -4
@@ -6,8 +6,7 @@#include "../../../include/linux/filter.h" #include "bpf_misc.h" -#if __clang_major__ >=18 && defined(ENABLE_ATOMICS_TESTS ) && \ - (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86)) +#ifdef CAN_USE_LOAD_ACQ_STORE_REL SEC("socket")__description ("load-acquire, 8-bit" )
@@ -182,7 +181,7 @@ __naked void load_acquire_from_sock_pointer(void) : __clobber_all); } -#else +#else /* CAN_USE_LOAD_ACQ_STORE_REL */ SEC("socket")__description ("Clang version < 18, ENABLE_ATOMICS_TESTS not defined, and/or JIT doesn't support load-acquire, use a dummy test" )
@@ -192,6 +191,6 @@ int dummy_test(void)return 0 ; } -#endif +#endif /* CAN_USE_LOAD_ACQ_STORE_REL */ char _license[] SEC("license") = "GPL";
Signature · 1 line
2.48.1
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 9 lines · On Tue, 4 Mar 2025 11:50:19 -0800 you wrote:
This patch-set introduces a simple live registers DFA analysis. Analysis is done as a separate step before main verification pass. Results are stored in the
env->insn_aux_datafor each instruction.The change helps with iterator/callback based loops handling, as regular register liveness marks are not finalized while loops are processed. See veristat results in patch #2.
[...]
Here is the summary with links:
- [bpf-next,v3,1/5] bpf: jmp_offset() and verbose_insn() utility functions
https://git.kernel.org/bpf/bpf-next/c/1c152572be59 - [bpf-next,v3,2/5] bpf: get_call_summary() utility function https://git.kernel.org/bpf/bpf-next/c/0ae958eca164 - [bpf-next,v3,3/5] bpf: simple DFA-based live registers analysis https://git.kernel.org/bpf/bpf-next/c/7dad03653567 - [bpf-next,v3,4/5] bpf: use register liveness information for func_states_equal https://git.kernel.org/bpf/bpf-next/c/994a876a076a - [bpf-next,v3,5/5] selftests/bpf: test cases for compute_live_registers() https://git.kernel.org/bpf/bpf-next/c/8a3fc22ddec7
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html