bpf: Propagate scalar ranges through register assignments.

The llvm register allocator may use two different registers representing the
same virtual register. In such case the following pattern can be observed:
1047: (bf) r9 = r6
1048: (a5) if r6 < 0x1000 goto pc+1
1050: ...
1051: (a5) if r9 < 0x2 goto pc+66
1052: ...
1053: (bf) r2 = r9 /* r2 needs to have upper and lower bounds */

This is normal behavior of greedy register allocator.
The slides 137+ explain why regalloc introduces such register copy:
http://llvm.org/devmtg/2018-04/slides/Yatsina-LLVM%20Greedy%20Register%20Allocator.pdf
There is no way to tell llvm 'not to do this'.
Hence the verifier has to recognize such patterns.

In order to track this information without backtracking allocate ID
for scalars in a similar way as it's done for find_good_pkt_pointers().

When the verifier encounters r9 = r6 assignment it will assign the same ID
to both registers. Later if either register range is narrowed via conditional
jump propagate the register state into the other register.

Clear register ID in adjust_reg_min_max_vals() for any alu instruction. The
register ID is ignored for scalars in regsafe() and doesn't affect state
pruning. mark_reg_unknown() clears the ID. It's used to process call, endian
and other instructions. Hence ID is explicitly cleared only in
adjust_reg_min_max_vals() and in 32-bit mov.

Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: John Fastabend <john.fastabend@gmail.com>
Link: https://lore.kernel.org/bpf/20201009011240.48506-2-alexei.starovoitov@gmail.com

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 62b804651a4801dfde95f703eb67886dcfab3847..ba96f7e9bbc0d4fea3818450a28ee5dd3fee8003 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -6436,6 +6436,11 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env,
        src_reg = NULL;
        if (dst_reg->type != SCALAR_VALUE)
                ptr_reg = dst_reg;
+       else
+               /* Make sure ID is cleared otherwise dst_reg min/max could be
+                * incorrectly propagated into other registers by find_equal_scalars()
+                */
+               dst_reg->id = 0;
        if (BPF_SRC(insn->code) == BPF_X) {
                src_reg = &regs[insn->src_reg];
                if (src_reg->type != SCALAR_VALUE) {
@@ -6569,6 +6574,12 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
                                /* case: R1 = R2
                                 * copy register state to dest reg
                                 */
+                               if (src_reg->type == SCALAR_VALUE && !src_reg->id)
+                                       /* Assign src and dst registers the same ID
+                                        * that will be used by find_equal_scalars()
+                                        * to propagate min/max range.
+                                        */
+                                       src_reg->id = ++env->id_gen;
                                *dst_reg = *src_reg;
                                dst_reg->live |= REG_LIVE_WRITTEN;
                                dst_reg->subreg_def = DEF_NOT_SUBREG;
@@ -6581,6 +6592,11 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
                                        return -EACCES;
                                } else if (src_reg->type == SCALAR_VALUE) {
                                        *dst_reg = *src_reg;
+                                       /* Make sure ID is cleared otherwise
+                                        * dst_reg min/max could be incorrectly
+                                        * propagated into src_reg by find_equal_scalars()
+                                        */
+                                       dst_reg->id = 0;
                                        dst_reg->live |= REG_LIVE_WRITTEN;
                                        dst_reg->subreg_def = env->insn_idx + 1;
                                } else {
@@ -7369,6 +7385,30 @@ static bool try_match_pkt_pointers(const struct bpf_insn *insn,
        return true;
 }
 
+static void find_equal_scalars(struct bpf_verifier_state *vstate,
+                              struct bpf_reg_state *known_reg)
+{
+       struct bpf_func_state *state;
+       struct bpf_reg_state *reg;
+       int i, j;
+
+       for (i = 0; i <= vstate->curframe; i++) {
+               state = vstate->frame[i];
+               for (j = 0; j < MAX_BPF_REG; j++) {
+                       reg = &state->regs[j];
+                       if (reg->type == SCALAR_VALUE && reg->id == known_reg->id)
+                               *reg = *known_reg;
+               }
+
+               bpf_for_each_spilled_reg(j, state, reg) {
+                       if (!reg)
+                               continue;
+                       if (reg->type == SCALAR_VALUE && reg->id == known_reg->id)
+                               *reg = *known_reg;
+               }
+       }
+}
+
 static int check_cond_jmp_op(struct bpf_verifier_env *env,
                             struct bpf_insn *insn, int *insn_idx)
 {
@@ -7497,6 +7537,11 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env,
                                reg_combine_min_max(&other_branch_regs[insn->src_reg],
                                                    &other_branch_regs[insn->dst_reg],
                                                    src_reg, dst_reg, opcode);
+                       if (src_reg->id) {
+                               find_equal_scalars(this_branch, src_reg);
+                               find_equal_scalars(other_branch, &other_branch_regs[insn->src_reg]);
+                       }
+
                }
        } else if (dst_reg->type == SCALAR_VALUE) {
                reg_set_min_max(&other_branch_regs[insn->dst_reg],
@@ -7504,6 +7549,11 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env,
                                        opcode, is_jmp32);
        }
 
+       if (dst_reg->type == SCALAR_VALUE && dst_reg->id) {
+               find_equal_scalars(this_branch, dst_reg);
+               find_equal_scalars(other_branch, &other_branch_regs[insn->dst_reg]);
+       }
+
        /* detect if R == 0 where R is returned from bpf_map_lookup_elem().
         * NOTE: these optimizations below are related with pointer comparison
         *       which will never be JMP32.

diff --git a/tools/testing/selftests/bpf/prog_tests/align.c b/tools/testing/selftests/bpf/prog_tests/align.c
index c548aded658599e52bb755d50f1ae8755197657a..52414058a6272d95714d0fb414eac28fa64ed82e 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/align.c
+++ b/tools/testing/selftests/bpf/prog_tests/align.c
@@ -195,13 +195,13 @@ static struct bpf_align_test tests[] = {
                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
                .matches = {
                        {7, "R3_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-                       {8, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+                       {8, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
                        {9, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-                       {10, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+                       {10, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
                        {11, "R4_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
-                       {12, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+                       {12, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
                        {13, "R4_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
-                       {14, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+                       {14, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
                        {15, "R4_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
                        {16, "R4_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
                },
@@ -518,7 +518,7 @@ static struct bpf_align_test tests[] = {
                         * the total offset is 4-byte aligned and meets the
                         * load's requirements.
                         */
-                       {20, "R5=pkt(id=1,off=0,r=4,umin_value=2,umax_value=1034,var_off=(0x2; 0x7fc)"},
+                       {20, "R5=pkt(id=2,off=0,r=4,umin_value=2,umax_value=1034,var_off=(0x2; 0x7fc)"},
 
                },
        },
@@ -561,18 +561,18 @@ static struct bpf_align_test tests[] = {
                        /* Adding 14 makes R6 be (4n+2) */
                        {11, "R6_w=inv(id=0,umin_value=14,umax_value=74,var_off=(0x2; 0x7c))"},
                        /* Subtracting from packet pointer overflows ubounds */
-                       {13, "R5_w=pkt(id=1,off=0,r=8,umin_value=18446744073709551542,umax_value=18446744073709551602,var_off=(0xffffffffffffff82; 0x7c)"},
+                       {13, "R5_w=pkt(id=2,off=0,r=8,umin_value=18446744073709551542,umax_value=18446744073709551602,var_off=(0xffffffffffffff82; 0x7c)"},
                        /* New unknown value in R7 is (4n), >= 76 */
                        {15, "R7_w=inv(id=0,umin_value=76,umax_value=1096,var_off=(0x0; 0x7fc))"},
                        /* Adding it to packet pointer gives nice bounds again */
-                       {16, "R5_w=pkt(id=2,off=0,r=0,umin_value=2,umax_value=1082,var_off=(0x2; 0xfffffffc)"},
+                       {16, "R5_w=pkt(id=3,off=0,r=0,umin_value=2,umax_value=1082,var_off=(0x2; 0xfffffffc)"},
                        /* At the time the word size load is performed from R5,
                         * its total fixed offset is NET_IP_ALIGN + reg->off (0)
                         * which is 2.  Then the variable offset is (4n+2), so
                         * the total offset is 4-byte aligned and meets the
                         * load's requirements.
                         */
-                       {20, "R5=pkt(id=2,off=0,r=4,umin_value=2,umax_value=1082,var_off=(0x2; 0xfffffffc)"},
+                       {20, "R5=pkt(id=3,off=0,r=4,umin_value=2,umax_value=1082,var_off=(0x2; 0xfffffffc)"},
                },
        },
 };

diff --git a/tools/testing/selftests/bpf/verifier/direct_packet_access.c b/tools/testing/selftests/bpf/verifier/direct_packet_access.c
index 2c5fbe7bcd2730274b800544e91e05caaa16416f..ae72536603fe2bdf39f15725672e296b7a48547c 100644 (file)
--- a/tools/testing/selftests/bpf/verifier/direct_packet_access.c
+++ b/tools/testing/selftests/bpf/verifier/direct_packet_access.c
@@ -529,7 +529,7 @@
        },
        .prog_type = BPF_PROG_TYPE_SCHED_CLS,
        .result = REJECT,
-       .errstr = "invalid access to packet, off=0 size=8, R5(id=1,off=0,r=0)",
+       .errstr = "invalid access to packet, off=0 size=8, R5(id=2,off=0,r=0)",
        .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 },
 {