Commit 75748837 authored by Alexei Starovoitov's avatar Alexei Starovoitov Committed by Daniel Borkmann
Browse files

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: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Acked-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Acked-by: default avatarJohn Fastabend <john.fastabend@gmail.com>
Link: https://lore.kernel.org/bpf/20201009011240.48506-2-alexei.starovoitov@gmail.com
parent eca43ee6

kernel/bpf/verifier.c

+50 −0
Original line number Diff line number Diff line
@@ -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.

tools/testing/selftests/bpf/prog_tests/align.c

+8 −8
Original line number Diff line number Diff line
@@ -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)"},

		},

	},

};

tools/testing/selftests/bpf/verifier/direct_packet_access.c

+1 −1
Original line number Diff line number Diff line
@@ -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,

},

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE