bpf: verifier: Improve state pruning for scalar registers
Subsystems (4)
v2 cover bpf: verifier: Improve state pruning for scalar registers
V1: https://lore.kernel.org/all/[email protected]/
Changes in V2:
- Collected acked by Eduard
- Removed some unnecessary comments
- Added a selftest for id=0 equivalence in Patch 5
This series improves BPF verifier state pruning by relaxing scalar ID equivalence requirements. Scalar register IDs are used to track relationships between registers for bounds propagation. However, once an ID becomes "singular" (only one register/stack slot carries it), it can no longer participate in bounds propagation and becomes stale. These stale IDs can prevent pruning of otherwise equivalent states.
The series addresses this in four patches:
Patch 1: Assign IDs on stack fills to ensure stack slots have IDs before being read into registers, preparing for the singular ID clearing in patch 2.
Patch 2: Clear IDs that appear only once before caching, as they cannot contribute to bounds propagation.
Patch 3: Relax maybe_widen_reg() to only compare value-tracking fields (bounds, tnum, var_off) rather than also requiring ID matches. Two scalars with identical value constraints but different IDs represent the same abstract value and don't need widening.
Patch 4: Relax scalar ID equivalence in state comparison by treating rold->id == 0 as "independent". If the old state didn't rely on ID relationships for a register, any linking in the current state only adds constraints and is safe to accept for pruning.
Patch 5: Add a selftest to show the exact case being handled by Patch 4
I ran veristat on BPF programs from sched_ext, meta's internal programs, and on selftest programs, showing programs with insn diff > 5%:
Scx Progs
File Program States (A) States (B) States (DIFF) Insns (A) Insns (B) Insns (DIFF) ------------------ ------------------- ---------- ---------- ------------- --------- --------- --------------- scx_rusty.bpf.o rusty_set_cpumask 320 230 -90 (-28.12%) 4478 3259 -1219 (-27.22%) scx_bpfland.bpf.o bpfland_select_cpu 55 49 -6 (-10.91%) 691 618 -73 (-10.56%) scx_beerland.bpf.o beerland_select_cpu 27 25 -2 (-7.41%) 320 295 -25 (-7.81%) scx_p2dq.bpf.o p2dq_init 265 250 -15 (-5.66%) 3423 3233 -190 (-5.55%) scx_layered.bpf.o layered_enqueue 1461 1386 -75 (-5.13%) 14541 13792 -749 (-5.15%)
FB Progs
File Program States (A) States (B) States (DIFF) Insns (A) Insns (B) Insns (DIFF) ------------ ------------------- ---------- ---------- -------------- --------- --------- --------------- bpf007.bpf.o bpfj_free 1726 1342 -384 (-22.25%) 25671 19096 -6575 (-25.61%) bpf041.bpf.o armr_net_block_init 22373 20411 -1962 (-8.77%) 651697 602873 -48824 (-7.49%) bpf227.bpf.o layered_quiescent 28 26 -2 (-7.14%) 365 340 -25 (-6.85%) bpf248.bpf.o p2dq_init 263 248 -15 (-5.70%) 3370 3159 -211 (-6.26%) bpf254.bpf.o p2dq_init 263 248 -15 (-5.70%) 3388 3177 -211 (-6.23%) bpf241.bpf.o p2dq_init 264 249 -15 (-5.68%) 3428 3240 -188 (-5.48%) bpf230.bpf.o p2dq_init 287 271 -16 (-5.57%) 3666 3431 -235 (-6.41%) bpf251.bpf.o lavd_cpu_offline 321 316 -5 (-1.56%) 6221 5891 -330 (-5.30%) bpf251.bpf.o lavd_cpu_online 321 316 -5 (-1.56%) 6219 5889 -330 (-5.31%)
Selftest Progs
File Program States (A) States (B) States (DIFF) Insns (A) Insns (B) Insns (DIFF) ---------------------------------- ----------------- ---------- ---------- ------------- --------- --------- --------------- verifier_iterating_callbacks.bpf.o test2 4 2 -2 (-50.00%) 29 18 -11 (-37.93%) verifier_iterating_callbacks.bpf.o test3 4 2 -2 (-50.00%) 31 19 -12 (-38.71%) strobemeta_bpf_loop.bpf.o on_event 318 221 -97 (-30.50%) 3938 2755 -1183 (-30.04%) bpf_qdisc_fq.bpf.o bpf_fq_dequeue 133 105 -28 (-21.05%) 1686 1385 -301 (-17.85%) iters.bpf.o delayed_read_mark 6 5 -1 (-16.67%) 60 46 -14 (-23.33%) arena_strsearch.bpf.o arena_strsearch 107 106 -1 (-0.93%) 1394 1258 -136 (-9.76%)
Puranjay Mohan (5):
bpf: verifier: Assign ids on stack fills
bpf: verifier: Clear singular ids for scalars
bpf: verifier: relax maybe_widen_reg() constraints
bpf: verifier: Relax scalar id equivalence for state pruning
selftests: bpf: Add a test for ids=0
include/linux/bpf_verifier.h | 7 +- kernel/bpf/verifier.c | 162 ++++++++++++++++-- .../selftests/bpf/progs/verifier_scalar_ids.c | 53 +++++- 3 files changed, 198 insertions(+), 24 deletions(-)
base-commit: 6b95cc562de2889a9333843dda073ba875f9e808
Signature · 1 line
2.47.3
PATCH v2 1/5 bpf: verifier: Assign ids on stack fills
The next commit will allow clearing of scalar ids if no other register/stack slot has that id. This is because if only one register has a unique id, it can't participate in bounds propagation and is equivalent to having no id.
But if the id of a stack slot is cleared by clear_singular_ids() in the next commit, reading that stack slot into a register will not establish a link because the stack slot's id is cleared.
This can happen in a situation where a register is spilled and later loses its id due to a multiply operation (for example) and then the stack slot's id becomes singular and can be cleared.
Make sure that scalar stack slots have an id before we read them into a register.
--- kernel/bpf/verifier.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/bpf/verifier.c +11 -0
@@ -5518,6 +5518,12 @@ static int check_stack_read_fixed_off(struct bpf_verifier_env *env,*/ s32 subreg_def = state->regs[dst_regno].subreg_def; +if (env->bpf_capable && size ==4 && spill_size ==4 && +get_reg_width (reg) <=32 ) +/* Ensure stack slot has an ID to build a relation +* with the destination register on fill. +*/ +assign_scalar_id_before_mov (env, reg);copy_register_state (&state->regs[dst_regno], reg); state->regs[dst_regno].subreg_def = subreg_def;
@@ -5563,6 +5569,11 @@ static int check_stack_read_fixed_off(struct bpf_verifier_env *env, } }else if (dst_regno >=0 ) {/* restore register state from stack */ +if (env->bpf_capable) +/* Ensure stack slot has an ID to build a relation +* with the destination register on fill. +*/ +assign_scalar_id_before_mov (env, reg);copy_register_state (&state->regs[dst_regno], reg);/* mark reg as written since spilled pointer state likely * has its liveness marks cleared by is_state_visited()
Signature · 1 line
2.47.3
PATCH v2 2/5 bpf: verifier: Clear singular ids for scalars
In reply to Puranjay MohanVerifier assigns ids to scalar registers/stack slots when they are linked through a mov or stack spill/fill instruction. These ids are later used to progagate newly found bounds to from one register to all registers that share the same id. The verifier also compares the ids of these registers in current state and cached state when making pruning decisions.
When an ID becomes singular (i.e., only a single register or stack slot has that ID), it can no longer participate in bounds propagation. During comparisons between current and cached states for pruning decisions, however, such stale IDs can prevent pruning of otherwise equivalent states.
Find and clear all singular ids before caching a state in is_state_visited(). struct bpf_idset which is currently unused has been repurposed for this use case.
--- include/linux/bpf_verifier.h | 7 ++-- kernel/bpf/verifier.c | 68 ++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+), 2 deletions(-)
include/linux/bpf_verifier.h +5 -2
@@ -697,8 +697,11 @@ struct bpf_idmap { };struct bpf_idset { -u32 count; -u32 ids[BPF_ID_MAP_SIZE ]; +u32 num_ids; +struct { +u32 id; +u32 cnt; + } entries[BPF_ID_MAP_SIZE ]; };/* see verifier.c:compute_scc_callchain() */
kernel/bpf/verifier.c +68 -0
80 lines not on this page · raw message
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH bpf-next v2 2/5] bpf: verifier: Clear singular ids for scalars
commit ca2bffc24660b903cc21dad2f51a3a89f918b2eb Author: Puranjay Mohan <[email protected]>
commit ca2bffc24660b903cc21dad2f51a3a89f918b2eb
Author: Puranjay Mohan <[email protected]>
bpf: verifier: Clear singular ids for scalars
This commit finds and clears singular (unique) scalar register IDs before caching verifier states. When only one register has a given ID, the ID can no longer participate in bounds propagation, so clearing it to zero enables better state pruning by treating such registers as independent.
Quoted 3 lines
Verifier assigns ids to scalar registers/stack slots when they are linked through a mov or stack spill/fill instruction. These ids are later used to progagate newly found bounds to from one register to all
^^^^^^^^^ ^^^^^^^
This isn't a bug, but the commit message has "progagate" which should be "propagate", and "to from one register" appears to have an extra word.
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21614542865
AI-authorship-score: low
AI-authorship-explanation: The code follows kernel conventions consistently; commit message typos and natural technical phrasing suggest human authorship.
issues-found: 1
issue-severity-score: low
issue-severity-explanation: Minor commit message typos that do not affect code correctness or system stability.
PATCH v2 3/5 bpf: verifier: relax maybe_widen_reg() constraints
In reply to Puranjay MohanThe maybe_widen_reg() function widens imprecise scalar registers to unknown when their values differ between the cached and current states. Previously, it used regs_exact() which also compared register IDs via check_ids(), requiring registers to have matching IDs (or mapped IDs) to be considered exact.
For scalar widening purposes, what matters is whether the value tracking (bounds, tnum, var_off) is the same, not whether the IDs match. Two scalars with identical value constraints but different IDs represent the same abstract value and don't need to be widened.
Introduce scalars_exact_for_widen() that only compares the value-tracking portion of bpf_reg_state (fields before 'id'). This allows the verifier to preserve more scalar value information during state merging when IDs differ but actual tracked values are identical, reducing unnecessary widening and potentially improving verification precision.
--- kernel/bpf/verifier.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-)
kernel/bpf/verifier.c +13 -7
@@ -8995,15 +8995,23 @@ static bool regs_exact(const struct bpf_reg_state *rold,const struct bpf_reg_state *rcur, struct bpf_idmap *idmap); +/* Check if scalar registers are exact for the purpose of not widening. +* More lenient than regs_exact() +*/ +static bool scalars_exact_for_widen (const struct bpf_reg_state *rold, +const struct bpf_reg_state *rcur) +{ +return !memcmp (rold, rcur, offsetof(struct bpf_reg_state , id)); +} +static void maybe_widen_reg (struct bpf_verifier_env *env, -struct bpf_reg_state *rold,struct bpf_reg_state *rcur, -struct bpf_idmap *idmap) +struct bpf_reg_state *rold,struct bpf_reg_state *rcur) {if (rold->type !=SCALAR_VALUE )return ;if (rold->type != rcur->type)return ; -if (rold->precise || rcur->precise ||regs_exact (rold, rcur, idmap)) +if (rold->precise || rcur->precise ||scalars_exact_for_widen (rold, rcur))return ;__mark_reg_unknown (env, rcur); }
@@ -9023,8 +9031,7 @@ static int widen_imprecise_scalars(struct bpf_verifier_env *env,for (i =0 ; i <MAX_BPF_REG ; i++)maybe_widen_reg (env, &fold->regs[i], - &fcur->regs[i], - &env->idmap_scratch); + &fcur->regs[i]); num_slots =min (fold->allocated_stack /BPF_REG_SIZE , fcur->allocated_stack /BPF_REG_SIZE );
@@ -9035,8 +9042,7 @@ static int widen_imprecise_scalars(struct bpf_verifier_env *env,maybe_widen_reg (env, &fold->stack[i].spilled_ptr, - &fcur->stack[i].spilled_ptr, - &env->idmap_scratch); + &fcur->stack[i].spilled_ptr); } }return 0 ;
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH bpf-next v2 3/5] bpf: verifier: relax maybe_widen_reg() constraints
The change removes the idmap_scratch argument from maybe_widen_reg() calls, but widen_imprecise_scalars() still calls reset_idmap_scratch(env) at the start of the function. After this commit, the…
Quoted 4 lines
kernel/bpf/verifier.c +0
-0
[ ... ]
kernel/bpf/verifier.c static int widen_imprecise_scalars(struct bpf_verifier_env *env, · line 9034
Quoted 7 lines
kernel/bpf/verifier.c +1
-2@@ -9023,8 +9031,7 @@ static int widen_imprecise_scalars(struct bpf_verifier_env *env,for (i =0 ; i <MAX_BPF_REG ; i++)maybe_widen_reg (env, &fold->regs[i], - &fcur->regs[i], - &env->idmap_scratch); + &fcur->regs[i]);
The change removes the idmap_scratch argument from maybe_widen_reg() calls, but widen_imprecise_scalars() still calls reset_idmap_scratch(env) at the start of the function. After this commit, the function looks like:
static int widen_imprecise_scalars(...)
{
...
reset_idmap_scratch(env); <-- this is now dead code
for (fr = old->curframe; fr >= 0; fr--) {
...
maybe_widen_reg(env, ..., ...); <-- no longer uses idmap
...
}
return 0;
}Should reset_idmap_scratch(env) be removed since it no longer serves any purpose in this function?
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21614542865
AI-authorship-score: low
AI-authorship-explanation: The commit demonstrates deep familiarity with BPF verifier internals and uses precise domain-specific terminology naturally; the focused scope and minimal code changes are consistent with experienced kernel developer patterns.
issues-found: 1
issue-severity-score: low
issue-severity-explanation: Minor dead code issue where reset_idmap_scratch() is called but the idmap is no longer used after this change; no functional impact.
PATCH v2 4/5 bpf: verifier: Relax scalar id equivalence for state pruning
In reply to Puranjay MohanScalar register IDs are used by the verifier to track relationships between registers and enable bounds propagation across those relationships. Once an ID becomes singular (i.e. only a single register/stack slot carries it), it can no longer contribute to bounds propagation and effectively becomes stale. The previous commit makes the verifier clear such ids before caching the state.
When comparing the current and cached states for pruning, these stale IDs can cause technically equivalent states to be considered different and thus prevent pruning.
For example in the selftest added in the next commit, two registers - r6 and r7 are not linked to any other registers and get cached with id=0, in the current state, they are both linked to each other with id=A. Before this commit, check_scalar_ids, would give temperory ids to r6 and r6 (say tid1 and tid2) and then check_ids() would map tid1->A, and when it would see tid2->A, it would not consider these state equivalent.
Relax scalar ID equivalence by treating rold->id == 0 as "independent":
if the old state did not rely on any ID relationships for a register, then any ID/linking present in the current state only adds constraints and is always safe to accept for pruning. Implement this by returning true immediately in check_scalar_ids() when old_id == 0.
Maintain correctness for the opposite direction (old_id != 0 && cur_id == 0) by still allocating a temporary ID for cur_id == 0. This avoids incorrectly allowing multiple independent current registers (id==0) to satisfy a single linked old ID during mapping.
--- kernel/bpf/verifier.c | 63 +++++++++++++++---- .../selftests/bpf/progs/verifier_scalar_ids.c | 8 ++- 2 files changed, 56 insertions(+), 15 deletions(-)
kernel/bpf/verifier.c +51 -12
@@ -19387,13 +19387,29 @@ static bool check_ids(u32 old_id, u32 cur_id, struct bpf_idmap *idmap)return false; } -/* Similar to check_ids(), but allocate a unique temporary ID -* for 'old_id' or 'cur_id' of zero. -* This makes pairs like '0 vs unique ID', 'unique ID vs 0' valid. +/* +* Compare scalar register IDs for state equivalence. +* +* When old_id == 0, the old register is independent - not linked to any +* other register. Any linking in the current state only adds constraints, +* making it more restrictive. Since the old state didn't rely on any ID +* relationships for this register, it's always safe to accept cur regardless +* of its ID. Hence, return true immediately. +* +* When old_id != 0 but cur_id == 0, we need to ensure that different +* independent registers in cur don't incorrectly satisfy the ID matching +* requirements of linked registers in old. +* +* Example: if old has r6.id=X and r7.id=X (linked), but cur has r6.id=0 +* and r7.id=0 (both independent), without temp IDs both would map old_id=X +* to cur_id=0 and pass. With temp IDs: r6 maps X->temp1, r7 tries to map +* X->temp2, but X is already mapped to temp1, so the check fails correctly. */ static bool check_scalar_ids (u32 old_id,u32 cur_id,struct bpf_idmap *idmap) { - old_id = old_id ? old_id : ++idmap->tmp_id_gen; +if (!old_id) +return true; + cur_id = cur_id ? cur_id : ++idmap->tmp_id_gen;return check_ids (old_id, cur_id, idmap);
@@ -19618,11 +19634,21 @@ static bool regsafe(struct bpf_verifier_env *env, struct bpf_reg_state *rold, }if (!rold->precise && exact ==NOT_EXACT )return true; -if ((rold->id &BPF_ADD_CONST ) != (rcur->id &BPF_ADD_CONST )) -return false; -if ((rold->id &BPF_ADD_CONST ) && (rold->off != rcur->off)) -return false; -/* Why check_ids() for scalar registers? +/* +* Linked register tracking uses rold->id to detect relationships. +* When rold->id == 0, the register is independent and any linking +* in rcur only adds constraints. When rold->id != 0, we must verify +* id mapping and (for BPF_ADD_CONST) offset consistency. +* +* +------------------+-----------+------------------+---------------+ +* | | rold->id | rold + ADD_CONST | rold->id == 0 | +* |------------------+-----------+------------------+---------------| +* | rcur->id | range,ids | false | range | +* | rcur + ADD_CONST | false | range,ids,off | range | +* | rcur->id == 0 | range,ids | false | range | +* +------------------+-----------+------------------+---------------+ +* +* Why check_ids() for scalar registers? * * Consider the following BPF code: * 1: r6 = ... unbound scalar, ID=a ...
@@ -19646,9 +19672,22 @@ static bool regsafe(struct bpf_verifier_env *env, struct bpf_reg_state *rold,* --- * Also verify that new value satisfies old value range knowledge. */ -return range_within (rold, rcur) && -tnum_in (rold->var_off, rcur->var_off) && -check_scalar_ids (rold->id, rcur->id, idmap); + +/* ADD_CONST mismatch: different linking semantics */ +if ((rold->id &BPF_ADD_CONST ) && !(rcur->id &BPF_ADD_CONST )) +return false; + +if (rold->id && !(rold->id &BPF_ADD_CONST ) && (rcur->id &BPF_ADD_CONST )) +return false; + +/* Both have offset linkage: offsets must match */ +if ((rold->id &BPF_ADD_CONST ) && rold->off != rcur->off) +return false; + +if (!check_scalar_ids (rold->id, rcur->id, idmap)) +return false; + +return range_within (rold, rcur) &&tnum_in (rold->var_off, rcur->var_off);case PTR_TO_MAP_KEY :case PTR_TO_MAP_VALUE :case PTR_TO_MEM :
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c +5 -3
@@ -723,9 +723,9 @@ __success __log_level(2)/* The exit instruction should be reachable from two states, * use two matches and "processed .. insns" to ensure this. */ -__msg("13: (95) exit") -__msg("13: (95) exit") -__msg("processed 18 insns") +__msg("15: (95) exit") +__msg("15: (95) exit") +__msg("processed 20 insns")__flag (BPF_F_TEST_STATE_FREQ) __naked void two_old_ids_one_cur_id(void) {
@@ -734,9 +734,11 @@ __naked void two_old_ids_one_cur_id(void)"call %[bpf_ktime_get_ns];" "r0 &= 0xff;" "r6 = r0;" +"r8 = r0;" "call %[bpf_ktime_get_ns];" "r0 &= 0xff;" "r7 = r0;" +"r9 = r0;" "r0 = 0;" /* Maybe make r{6,7} IDs identical */ "if r6 > r7 goto l0_%=;"
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH bpf-next v2 4/5] bpf: verifier: Relax scalar id equivalence for state pruning
commit caefa48534e902ffcecf6479615965779dd6ec93 Author: Puranjay Mohan <[email protected]>
commit caefa48534e902ffcecf6479615965779dd6ec93
Author: Puranjay Mohan <[email protected]>
bpf: verifier: Relax scalar id equivalence for state pruning
This commit relaxes scalar ID equivalence checking for state pruning in the BPF verifier. When the old state has id=0 (independent register), any ID in the current state is now accepted since it only adds constraints.
Quoted 5 lines
For example in the selftest added in the next commit, two registers - r6 and r7 are not linked to any other registers and get cached with id=0, in the current state, they are both linked to each other with id=A. Before this commit,
check_scalar_ids, would give temperory ids to r6 and r6 (say tid1 and tid2) and thencheck_ids()would maptid1->A, and when
This isn't a bug, but there are two typos in this paragraph: "temperory" should be "temporary", and "r6 and r6" should be "r6 and r7".
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21614542865
AI-authorship-score: low
AI-authorship-explanation: The commit contains minor typos and shows domain expertise typical of human kernel developers rather than AI-generated content.
issues-found: 1
issue-severity-score: low
issue-severity-explanation: Minor typos in commit message do not affect code functionality or system behavior.
PATCH v2 5/5 selftests: bpf: Add a test for ids=0
In reply to Puranjay MohanTest that two registers with their id=0 (unlinked) in the cached state can be mapped to a single id in the current state.
--- .../selftests/bpf/progs/verifier_scalar_ids.c | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+)
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c +45 -0
@@ -715,6 +715,51 @@ __naked void ignore_unique_scalar_ids_old(void) : __clobber_all); } +/* Check that two registers with 0 scalar IDs in a verified state can be mapped +* to the same scalar ID in current state. +*/ +SEC("socket") +__success __log_level(2) +/* The states should be equivalent on reaching insn 12. + */ +__msg("12: safe") +__msg("processed 17 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void two_nil_old_ids_one_cur_id(void) +{ + asmvolatile ( +/* Give unique scalar IDs to r{6,7} */ +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +"r6 = r0;" +"r6 *= 1;" +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +"r7 = r0;" +"r7 *= 1;" +"r0 = 0;" +/* Maybe make r{6,7} IDs identical */ +"if r6 > r7 goto l0_%=;" +"goto l1_%=;" +"l0_%=:" +"r6 = r7;" +"l1_%=:" +/* Mark r{6,7} precise. +* Get here in two states: +* - first: r6{.id=0}, r7{.id=0} (cached state) +* - second: r6{.id=A}, r7{.id=A} +* Currently we don't want to consider such states equivalent. +* Thus "exit;" would be verified only once. +*/ +"r2 = r10;" +"r2 += r6;" +"r2 += r7;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} +/* Check that two different scalar IDs in a verified state can't be * mapped to the same scalar ID in current state. */
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [PATCH bpf-next v2 5/5] selftests: bpf: Add a test for ids=0
The comment says "we don't want to consider such states equivalent" but the test expects __msg("12: safe") which indicates the states ARE considered equivalent (pruning happens).
Quoted 16 lines
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c +8
-0@@ -715,6 +715,51 @@ __naked void ignore_unique_scalar_ids_old(void) : __clobber_all); } +/* Check that two registers with 0 scalar IDs in a verified state can be mapped +* to the same scalar ID in current state. +*/ +SEC("socket") +__success __log_level(2) +/* The states should be equivalent on reaching insn 12. + */ +__msg ("12: safe" )
[ ... ]
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c __naked void ignore_unique_scalar_ids_old(void) · line 753
Quoted 8 lines
+"l1_%=:"
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c +7
-0+/* Mark r{6,7} precise. +* Get here in two states: +* - first: r6{.id=0}, r7{.id=0} (cached state) +* - second: r6{.id=A}, r7{.id=A} +* Currently we don't want to consider such states equivalent. +* Thus "exit;" would be verified only once. +*/
The comment says "we don't want to consider such states equivalent" but the test expects __msg("12: safe") which indicates the states ARE considered equivalent (pruning happens).
This appears to be copy-pasted from the adjacent two_old_ids_one_cur_id() test which has the opposite expectation. The top-level comment, the annotation comment ("states should be equivalent"), and the "exit would be verified only once" all indicate equivalence, but this line contradicts them.
Should this say "we DO want to consider such states equivalent" instead?
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/21614542865
AI-authorship-score: low
AI-authorship-explanation: The code follows established patterns with a typical copy-paste error in comments, which is characteristic of human development rather than AI generation.
issues-found: 1
issue-severity-score: low
issue-severity-explanation: Comment in test code contradicts test expectations, causing confusion but no functional impact.