bpf: rename bpf_reg_state->off to bpf_reg_state->delta

This field is now used only for linked scalar registers tracking.
Rename it to 'delta' to better describe it's purpose:
constant delta between "linked" scalars with the same ID.

Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/r/20260212-ptrs-off-migration-v2-4-00820e4d3438@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index a97bdbf3a07b63246ebf2021816e81c147989381..c1e30096ea7bfc90b4eb79ab40f4fbd25b69188a 100644 (file)
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -40,7 +40,7 @@ struct bpf_reg_state {
        /*
         * Constant delta between "linked" scalars with the same ID.
         */
-       s32 off;
+       s32 delta;
        union {
                /* valid when type == PTR_TO_PACKET */
                int range;
@@ -145,9 +145,9 @@ struct bpf_reg_state {
         * Upper bit of ID is used to remember relationship between "linked"
         * registers. Example:
         * r1 = r2;    both will have r1->id == r2->id == N
-        * r1 += 10;   r1->id == N | BPF_ADD_CONST and r1->off == 10
+        * r1 += 10;   r1->id == N | BPF_ADD_CONST and r1->delta == 10
         * r3 = r2;    both will have r3->id == r2->id == N
-        * w3 += 10;   r3->id == N | BPF_ADD_CONST32 and r3->off == 10
+        * w3 += 10;   r3->id == N | BPF_ADD_CONST32 and r3->delta == 10
         */
 #define BPF_ADD_CONST64 (1U << 31)
 #define BPF_ADD_CONST32 (1U << 30)

diff --git a/kernel/bpf/log.c b/kernel/bpf/log.c
index 39a731392d6520a1345fc3d79e86fc43f63e426a..37d72b0521920daf6f3274ad77d055c8b3aafa1b 100644 (file)
--- a/kernel/bpf/log.c
+++ b/kernel/bpf/log.c
@@ -694,7 +694,7 @@ static void print_reg_state(struct bpf_verifier_env *env,
                if (state->frameno != reg->frameno)
                        verbose(env, "[%d]", reg->frameno);
                if (tnum_is_const(reg->var_off)) {
-                       verbose_snum(env, reg->var_off.value + reg->off);
+                       verbose_snum(env, reg->var_off.value + reg->delta);
                        return;
                }
        }
@@ -704,7 +704,7 @@ static void print_reg_state(struct bpf_verifier_env *env,
        if (reg->id)
                verbose_a("id=%d", reg->id & ~BPF_ADD_CONST);
        if (reg->id & BPF_ADD_CONST)
-               verbose(env, "%+d", reg->off);
+               verbose(env, "%+d", reg->delta);
        if (reg->ref_obj_id)
                verbose_a("ref_obj_id=%d", reg->ref_obj_id);
        if (type_is_non_owning_ref(reg->type))
@@ -716,9 +716,9 @@ static void print_reg_state(struct bpf_verifier_env *env,
                          reg->map_ptr->key_size,
                          reg->map_ptr->value_size);
        }
-       if (t != SCALAR_VALUE && reg->off) {
+       if (t != SCALAR_VALUE && reg->delta) {
                verbose_a("off=");
-               verbose_snum(env, reg->off);
+               verbose_snum(env, reg->delta);
        }
        if (type_is_pkt_pointer(t)) {
                verbose_a("r=");

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 2c5794dad66889b7f872aa9882652efae877ac1a..0162f946032fe317ce1e5cf4a82e86a9357eca2b 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -5095,7 +5095,7 @@ static void assign_scalar_id_before_mov(struct bpf_verifier_env *env,
                 * Cleared it, since multiple rX += const are not supported.
                 */
                src_reg->id = 0;
-               src_reg->off = 0;
+               src_reg->delta = 0;
        }
 
        if (!src_reg->id && !tnum_is_const(src_reg->var_off))
@@ -16219,14 +16219,14 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env,
                         * we cannot accumulate another val into rx->off.
                         */
 clear_id:
-                       dst_reg->off = 0;
+                       dst_reg->delta = 0;
                        dst_reg->id = 0;
                } else {
                        if (alu32)
                                dst_reg->id |= BPF_ADD_CONST32;
                        else
                                dst_reg->id |= BPF_ADD_CONST64;
-                       dst_reg->off = off;
+                       dst_reg->delta = off;
                }
        } else {
                /*
@@ -17305,18 +17305,18 @@ static void sync_linked_regs(struct bpf_verifier_env *env, struct bpf_verifier_s
                if ((reg->id & ~BPF_ADD_CONST) != (known_reg->id & ~BPF_ADD_CONST))
                        continue;
                if ((!(reg->id & BPF_ADD_CONST) && !(known_reg->id & BPF_ADD_CONST)) ||
-                   reg->off == known_reg->off) {
+                   reg->delta == known_reg->delta) {
                        s32 saved_subreg_def = reg->subreg_def;
 
                        copy_register_state(reg, known_reg);
                        reg->subreg_def = saved_subreg_def;
                } else {
                        s32 saved_subreg_def = reg->subreg_def;
-                       s32 saved_off = reg->off;
+                       s32 saved_off = reg->delta;
                        u32 saved_id = reg->id;
 
                        fake_reg.type = SCALAR_VALUE;
-                       __mark_reg_known(&fake_reg, (s64)reg->off - (s64)known_reg->off);
+                       __mark_reg_known(&fake_reg, (s64)reg->delta - (s64)known_reg->delta);
 
                        /* reg = known_reg; reg += delta */
                        copy_register_state(reg, known_reg);
@@ -17324,7 +17324,7 @@ static void sync_linked_regs(struct bpf_verifier_env *env, struct bpf_verifier_s
                         * Must preserve off, id and subreg_def flag,
                         * otherwise another sync_linked_regs() will be incorrect.
                         */
-                       reg->off = saved_off;
+                       reg->delta = saved_off;
                        reg->id = saved_id;
                        reg->subreg_def = saved_subreg_def;
 
@@ -19629,7 +19629,7 @@ static void clear_singular_ids(struct bpf_verifier_env *env,
                        continue;
                if (idset_cnt_get(idset, reg->id & ~BPF_ADD_CONST) == 1) {
                        reg->id = 0;
-                       reg->off = 0;
+                       reg->delta = 0;
                }
        }));
 }
@@ -19766,7 +19766,7 @@ static bool regsafe(struct bpf_verifier_env *env, struct bpf_reg_state *rold,
                        return false;
 
                /* Both have offset linkage: offsets must match */
-               if ((rold->id & BPF_ADD_CONST) && rold->off != rcur->off)
+               if ((rold->id & BPF_ADD_CONST) && rold->delta != rcur->delta)
                        return false;
 
                if (!check_scalar_ids(rold->id, rcur->id, idmap))