bpf: omit default off=0 and imm=0 in register state log

Simplify BPF verifier log further by omitting default (and frequently
irrelevant) off=0 and imm=0 parts for non-SCALAR_VALUE registers. As can
be seen from fixed tests, this is often a visual noise for PTR_TO_CTX
register and even for PTR_TO_PACKET registers.

Omitting default values follows the rest of register state logic: we
omit default values to keep verifier log succinct and to highlight
interesting state that deviates from default one. E.g., we do the same
for var_off, when it's unknown, which gives no additional information.

Acked-by: Eduard Zingerman <eddyz87@gmail.com>
Acked-by: Stanislav Fomichev <sdf@google.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/r/20231118034623.3320920-7-andrii@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/log.c b/kernel/bpf/log.c
index c209ab1ec2b56d9696375e7d48e6e9a98ece6679..20b4f81087daf319c7efd8c138f2d60b0c75a041 100644 (file)
--- a/kernel/bpf/log.c
+++ b/kernel/bpf/log.c
@@ -602,16 +602,14 @@ static void print_reg_state(struct bpf_verifier_env *env, const struct bpf_reg_s
                          reg->map_ptr->key_size,
                          reg->map_ptr->value_size);
        }
-       if (t != SCALAR_VALUE)
+       if (t != SCALAR_VALUE && reg->off)
                verbose_a("off=%d", reg->off);
        if (type_is_pkt_pointer(t))
                verbose_a("r=%d", reg->range);
        if (tnum_is_const(reg->var_off)) {
-               /* Typically an immediate SCALAR_VALUE, but
-                * could be a pointer whose offset is too big
-                * for reg->off
-                */
-               verbose_a("imm=%llx", reg->var_off.value);
+               /* a pointer register with fixed offset */
+               if (reg->var_off.value)
+                       verbose_a("imm=%llx", reg->var_off.value);
        } else {
                print_scalar_ranges(env, reg, &sep);
                if (!tnum_is_unknown(reg->var_off)) {

diff --git a/tools/testing/selftests/bpf/prog_tests/align.c b/tools/testing/selftests/bpf/prog_tests/align.c
index 465c1c3a3d3c2653d0c3d542101f5e3639186914..4ebd0da898f5ca6a40f775e6b48d611777a45ca8 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/align.c
+++ b/tools/testing/selftests/bpf/prog_tests/align.c
@@ -40,7 +40,7 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {0, "R1", "ctx(off=0,imm=0)"},
+                       {0, "R1", "ctx()"},
                        {0, "R10", "fp0"},
                        {0, "R3_w", "2"},
                        {1, "R3_w", "4"},
@@ -68,7 +68,7 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {0, "R1", "ctx(off=0,imm=0)"},
+                       {0, "R1", "ctx()"},
                        {0, "R10", "fp0"},
                        {0, "R3_w", "1"},
                        {1, "R3_w", "2"},
@@ -97,7 +97,7 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {0, "R1", "ctx(off=0,imm=0)"},
+                       {0, "R1", "ctx()"},
                        {0, "R10", "fp0"},
                        {0, "R3_w", "4"},
                        {1, "R3_w", "8"},
@@ -119,7 +119,7 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {0, "R1", "ctx(off=0,imm=0)"},
+                       {0, "R1", "ctx()"},
                        {0, "R10", "fp0"},
                        {0, "R3_w", "7"},
                        {1, "R3_w", "7"},
@@ -162,13 +162,13 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {6, "R0_w", "pkt(off=8,r=8,imm=0)"},
+                       {6, "R0_w", "pkt(off=8,r=8)"},
                        {6, "R3_w", "var_off=(0x0; 0xff)"},
                        {7, "R3_w", "var_off=(0x0; 0x1fe)"},
                        {8, "R3_w", "var_off=(0x0; 0x3fc)"},
                        {9, "R3_w", "var_off=(0x0; 0x7f8)"},
                        {10, "R3_w", "var_off=(0x0; 0xff0)"},
-                       {12, "R3_w", "pkt_end(off=0,imm=0)"},
+                       {12, "R3_w", "pkt_end()"},
                        {17, "R4_w", "var_off=(0x0; 0xff)"},
                        {18, "R4_w", "var_off=(0x0; 0x1fe0)"},
                        {19, "R4_w", "var_off=(0x0; 0xff0)"},
@@ -235,11 +235,11 @@ static struct bpf_align_test tests[] = {
                },
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
-                       {2, "R5_w", "pkt(off=0,r=0,imm=0)"},
-                       {4, "R5_w", "pkt(off=14,r=0,imm=0)"},
-                       {5, "R4_w", "pkt(off=14,r=0,imm=0)"},
-                       {9, "R2", "pkt(off=0,r=18,imm=0)"},
-                       {10, "R5", "pkt(off=14,r=18,imm=0)"},
+                       {2, "R5_w", "pkt(r=0)"},
+                       {4, "R5_w", "pkt(off=14,r=0)"},
+                       {5, "R4_w", "pkt(off=14,r=0)"},
+                       {9, "R2", "pkt(r=18)"},
+                       {10, "R5", "pkt(off=14,r=18)"},
                        {10, "R4_w", "var_off=(0x0; 0xff)"},
                        {13, "R4_w", "var_off=(0x0; 0xffff)"},
                        {14, "R4_w", "var_off=(0x0; 0xffff)"},
@@ -299,7 +299,7 @@ static struct bpf_align_test tests[] = {
                        /* Calculated offset in R6 has unknown value, but known
                         * alignment of 4.
                         */
-                       {6, "R2_w", "pkt(off=0,r=8,imm=0)"},
+                       {6, "R2_w", "pkt(r=8)"},
                        {7, "R6_w", "var_off=(0x0; 0x3fc)"},
                        /* Offset is added to packet pointer R5, resulting in
                         * known fixed offset, and variable offset from R6.
@@ -337,7 +337,7 @@ static struct bpf_align_test tests[] = {
                        /* Constant offset is added to R5 packet pointer,
                         * resulting in reg->off value of 14.
                         */
-                       {26, "R5_w", "pkt(off=14,r=8,"},
+                       {26, "R5_w", "pkt(off=14,r=8)"},
                        /* Variable offset is added to R5, resulting in a
                         * variable offset of (4n). See comment for insn #18
                         * for R4 = R5 trick.
@@ -397,7 +397,7 @@ static struct bpf_align_test tests[] = {
                        /* Calculated offset in R6 has unknown value, but known
                         * alignment of 4.
                         */
-                       {6, "R2_w", "pkt(off=0,r=8,imm=0)"},
+                       {6, "R2_w", "pkt(r=8)"},
                        {7, "R6_w", "var_off=(0x0; 0x3fc)"},
                        /* Adding 14 makes R6 be (4n+2) */
                        {8, "R6_w", "var_off=(0x2; 0x7fc)"},
@@ -459,7 +459,7 @@ static struct bpf_align_test tests[] = {
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .result = REJECT,
                .matches = {
-                       {3, "R5_w", "pkt_end(off=0,imm=0)"},
+                       {3, "R5_w", "pkt_end()"},
                        /* (ptr - ptr) << 2 == unknown, (4n) */
                        {5, "R5_w", "var_off=(0x0; 0xfffffffffffffffc)"},
                        /* (4n) + 14 == (4n+2).  We blow our bounds, because
@@ -513,7 +513,7 @@ static struct bpf_align_test tests[] = {
                        /* Calculated offset in R6 has unknown value, but known
                         * alignment of 4.
                         */
-                       {6, "R2_w", "pkt(off=0,r=8,imm=0)"},
+                       {6, "R2_w", "pkt(r=8)"},
                        {8, "R6_w", "var_off=(0x0; 0x3fc)"},
                        /* Adding 14 makes R6 be (4n+2) */
                        {9, "R6_w", "var_off=(0x2; 0x7fc)"},
@@ -566,7 +566,7 @@ static struct bpf_align_test tests[] = {
                        /* Calculated offset in R6 has unknown value, but known
                         * alignment of 4.
                         */
-                       {6, "R2_w", "pkt(off=0,r=8,imm=0)"},
+                       {6, "R2_w", "pkt(r=8)"},
                        {9, "R6_w", "var_off=(0x0; 0x3c)"},
                        /* Adding 14 makes R6 be (4n+2) */
                        {10, "R6_w", "var_off=(0x2; 0x7c)"},
@@ -659,14 +659,14 @@ static int do_test_single(struct bpf_align_test *test)
                        /* Check the next line as well in case the previous line
                         * did not have a corresponding bpf insn. Example:
                         * func#0 @0
-                        * 0: R1=ctx(off=0,imm=0) R10=fp0
+                        * 0: R1=ctx() R10=fp0
                         * 0: (b7) r3 = 2                 ; R3_w=2
                         *
                         * Sometimes it's actually two lines below, e.g. when
                         * searching for "6: R3_w=scalar(umax=255,var_off=(0x0; 0xff))":
-                        *   from 4 to 6: R0_w=pkt(off=8,r=8,imm=0) R1=ctx(off=0,imm=0) R2_w=pkt(off=0,r=8,imm=0) R3_w=pkt_end(off=0,imm=0) R10=fp0
-                        *   6: R0_w=pkt(off=8,r=8,imm=0) R1=ctx(off=0,imm=0) R2_w=pkt(off=0,r=8,imm=0) R3_w=pkt_end(off=0,imm=0) R10=fp0
-                        *   6: (71) r3 = *(u8 *)(r2 +0)           ; R2_w=pkt(off=0,r=8,imm=0) R3_w=scalar(umax=255,var_off=(0x0; 0xff))
+                        *   from 4 to 6: R0_w=pkt(off=8,r=8) R1=ctx() R2_w=pkt(r=8) R3_w=pkt_end() R10=fp0
+                        *   6: R0_w=pkt(off=8,r=8) R1=ctx() R2_w=pkt(r=8) R3_w=pkt_end() R10=fp0
+                        *   6: (71) r3 = *(u8 *)(r2 +0)           ; R2_w=pkt(r=8) R3_w=scalar(umax=255,var_off=(0x0; 0xff))
                         */
                        while (!(p = strstr(line_ptr, m.reg)) || !strstr(p, m.match)) {
                                cur_line = -1;

diff --git a/tools/testing/selftests/bpf/prog_tests/log_buf.c b/tools/testing/selftests/bpf/prog_tests/log_buf.c
index fe9a23e65ef41e6553f4f24122c8e9f77ebfd8f2..0f7ea4d7d9f6e26fd26e49a7149412b0fe90c110 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/log_buf.c
+++ b/tools/testing/selftests/bpf/prog_tests/log_buf.c
@@ -78,7 +78,7 @@ static void obj_load_log_buf(void)
        ASSERT_OK_PTR(strstr(libbpf_log_buf, "prog 'bad_prog': BPF program load failed"),
                      "libbpf_log_not_empty");
        ASSERT_OK_PTR(strstr(obj_log_buf, "DATASEC license"), "obj_log_not_empty");
-       ASSERT_OK_PTR(strstr(good_log_buf, "0: R1=ctx(off=0,imm=0) R10=fp0"),
+       ASSERT_OK_PTR(strstr(good_log_buf, "0: R1=ctx() R10=fp0"),
                      "good_log_verbose");
        ASSERT_OK_PTR(strstr(bad_log_buf, "invalid access to map value, value_size=16 off=16000 size=4"),
                      "bad_log_not_empty");
@@ -175,7 +175,7 @@ static void bpf_prog_load_log_buf(void)
        opts.log_level = 2;
        fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, "good_prog", "GPL",
                           good_prog_insns, good_prog_insn_cnt, &opts);
-       ASSERT_OK_PTR(strstr(log_buf, "0: R1=ctx(off=0,imm=0) R10=fp0"), "good_log_2");
+       ASSERT_OK_PTR(strstr(log_buf, "0: R1=ctx() R10=fp0"), "good_log_2");
        ASSERT_GE(fd, 0, "good_fd2");
        if (fd >= 0)
                close(fd);

diff --git a/tools/testing/selftests/bpf/prog_tests/spin_lock.c b/tools/testing/selftests/bpf/prog_tests/spin_lock.c
index ace65224286f0b7fe2c546dc5bba687cb1652a36..18d451be57c87d8cae940fffd20877b48b2254c4 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/spin_lock.c
+++ b/tools/testing/selftests/bpf/prog_tests/spin_lock.c
@@ -13,22 +13,22 @@ static struct {
        const char *err_msg;
 } spin_lock_fail_tests[] = {
        { "lock_id_kptr_preserve",
-         "5: (bf) r1 = r0                       ; R0_w=ptr_foo(id=2,ref_obj_id=2,off=0,imm=0) "
-         "R1_w=ptr_foo(id=2,ref_obj_id=2,off=0,imm=0) refs=2\n6: (85) call bpf_this_cpu_ptr#154\n"
+         "5: (bf) r1 = r0                       ; R0_w=ptr_foo(id=2,ref_obj_id=2) "
+         "R1_w=ptr_foo(id=2,ref_obj_id=2) refs=2\n6: (85) call bpf_this_cpu_ptr#154\n"
          "R1 type=ptr_ expected=percpu_ptr_" },
        { "lock_id_global_zero",
-         "; R1_w=map_value(map=.data.A,ks=4,vs=4,off=0,imm=0)\n2: (85) call bpf_this_cpu_ptr#154\n"
+         "; R1_w=map_value(map=.data.A,ks=4,vs=4)\n2: (85) call bpf_this_cpu_ptr#154\n"
          "R1 type=map_value expected=percpu_ptr_" },
        { "lock_id_mapval_preserve",
          "[0-9]\\+: (bf) r1 = r0                       ;"
-         " R0_w=map_value(id=1,map=array_map,ks=4,vs=8,off=0,imm=0)"
-         " R1_w=map_value(id=1,map=array_map,ks=4,vs=8,off=0,imm=0)\n"
+         " R0_w=map_value(id=1,map=array_map,ks=4,vs=8)"
+         " R1_w=map_value(id=1,map=array_map,ks=4,vs=8)\n"
          "[0-9]\\+: (85) call bpf_this_cpu_ptr#154\n"
          "R1 type=map_value expected=percpu_ptr_" },
        { "lock_id_innermapval_preserve",
          "[0-9]\\+: (bf) r1 = r0                      ;"
-         " R0=map_value(id=2,ks=4,vs=8,off=0,imm=0)"
-         " R1_w=map_value(id=2,ks=4,vs=8,off=0,imm=0)\n"
+         " R0=map_value(id=2,ks=4,vs=8)"
+         " R1_w=map_value(id=2,ks=4,vs=8)\n"
          "[0-9]\\+: (85) call bpf_this_cpu_ptr#154\n"
          "R1 type=map_value expected=percpu_ptr_" },
        { "lock_id_mismatch_kptr_kptr", "bpf_spin_unlock of different lock" },

diff --git a/tools/testing/selftests/bpf/progs/exceptions_assert.c b/tools/testing/selftests/bpf/progs/exceptions_assert.c
index e1e5c54a6a11838b02786cf84f1a74a50681363f..26f7d67432ccfe574cef52704a590b43434f693a 100644 (file)
--- a/tools/testing/selftests/bpf/progs/exceptions_assert.c
+++ b/tools/testing/selftests/bpf/progs/exceptions_assert.c
@@ -59,7 +59,7 @@ check_assert(s64, ge, neg, INT_MIN);
 
 SEC("?tc")
 __log_level(2) __failure
-__msg(": R0=0 R1=ctx(off=0,imm=0) R2=scalar(smin=smin32=-2147483646,smax=smax32=2147483645) R10=fp0")
+__msg(": R0=0 R1=ctx() R2=scalar(smin=smin32=-2147483646,smax=smax32=2147483645) R10=fp0")
 int check_assert_range_s64(struct __sk_buff *ctx)
 {
        struct bpf_sock *sk = ctx->sk;
@@ -75,7 +75,7 @@ int check_assert_range_s64(struct __sk_buff *ctx)
 
 SEC("?tc")
 __log_level(2) __failure
-__msg(": R1=ctx(off=0,imm=0) R2=scalar(smin=umin=smin32=umin32=4096,smax=umax=smax32=umax32=8192,var_off=(0x0; 0x3fff))")
+__msg(": R1=ctx() R2=scalar(smin=umin=smin32=umin32=4096,smax=umax=smax32=umax32=8192,var_off=(0x0; 0x3fff))")
 int check_assert_range_u64(struct __sk_buff *ctx)
 {
        u64 num = ctx->len;
@@ -86,7 +86,7 @@ int check_assert_range_u64(struct __sk_buff *ctx)
 
 SEC("?tc")
 __log_level(2) __failure
-__msg(": R0=0 R1=ctx(off=0,imm=0) R2=4096 R10=fp0")
+__msg(": R0=0 R1=ctx() R2=4096 R10=fp0")
 int check_assert_single_range_s64(struct __sk_buff *ctx)
 {
        struct bpf_sock *sk = ctx->sk;
@@ -103,7 +103,7 @@ int check_assert_single_range_s64(struct __sk_buff *ctx)
 
 SEC("?tc")
 __log_level(2) __failure
-__msg(": R1=ctx(off=0,imm=0) R2=4096 R10=fp0")
+__msg(": R1=ctx() R2=4096 R10=fp0")
 int check_assert_single_range_u64(struct __sk_buff *ctx)
 {
        u64 num = ctx->len;
@@ -114,7 +114,7 @@ int check_assert_single_range_u64(struct __sk_buff *ctx)
 
 SEC("?tc")
 __log_level(2) __failure
-__msg(": R1=pkt(off=64,r=64,imm=0) R2=pkt_end(off=0,imm=0) R6=pkt(off=0,r=64,imm=0) R10=fp0")
+__msg(": R1=pkt(off=64,r=64) R2=pkt_end() R6=pkt(r=64) R10=fp0")
 int check_assert_generic(struct __sk_buff *ctx)
 {
        u8 *data_end = (void *)(long)ctx->data_end;