bpf: fix precision tracking of stack slots
Subsystems (4)
Alexei Starovoitov
maintainerPATCH 1/1 bpf: fix precision tracking of stack slots
The problem can be seen in the following two tests:
0: (bf) r3 = r10
1: (55) if r3 != 0x7b goto pc+0
2: (7a) *(u64 *)(r3 -8) = 0
3: (79) r4 = *(u64 *)(r10 -8)
..
0: (85) call bpf_get_prandom_u32#7
1: (bf) r3 = r10
2: (55) if r3 != 0x7b goto pc+0
3: (7b) *(u64 *)(r3 -8) = r0
4: (79) r4 = *(u64 *)(r10 -8)
When backtracking need to mark R4 it will mark slot fp-8. But ST or STX into fp-8 could belong to the same block of instructions. When backtracing is done the parent state may have fp-8 slot as "unallocated stack". Which will cause verifier to warn and incorrectly reject such programs.
Writes into stack via non-R10 register are rare. llvm always generates canonical stack spill/fill.
For such pathological case fall back to conservative precision tracking instead of rejecting.
---
tests will be submitted to bpf-next.
kernel/bpf/verifier.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
kernel/bpf/verifier.c +14 -9
@@ -1772,16 +1772,21 @@ static int __mark_chain_precision(struct bpf_verifier_env *env, int regno,bitmap_from_u64 (mask, stack_mask);for_each_set_bit (i, mask,64 ) {if (i >= func->allocated_stack /BPF_REG_SIZE ) { -/* This can happen if backtracking -* is propagating stack precision where -* caller has larger stack frame -* than callee, but backtrack_insn() should -* have returned -ENOTSUPP. +/* the sequence of instructions: +* 2: (bf) r3 = r10 +* 3: (7b) *(u64 *)(r3 -8) = r0 +* 4: (79) r4 = *(u64 *)(r10 -8) +* doesn't contain jmps. It's backtracked +* as a single block. +* During backtracking insn 3 is not recognized as +* stack access, so at the end of backtracking +* stack slot fp-8 is still marked in stack_mask. +* However the parent state may not have accessed +* fp-8 and it's "unallocated" stack space. +* In such case fallback to conservative. */ -verbose (env,"BUG spi %d stack_size %d\n" , - i, func->allocated_stack); -WARN_ONCE (1 ,"verifier backtracking bug" ); -return -EFAULT ; +mark_all_scalars_precise (env, st); +return 0 ; }if (func->stack[i].slot_type[0 ] !=STACK_SPILL ) {
Signature · 1 line
2.20.0
Quoted 18 lines · Alexei Starovoitov
The problem can be seen in the following two tests:
0: (bf) r3 = r10
1: (55) if r3 !=0x7bgoto pc+0
2: (7a) *(u64 *)(r3 -8) = 0
3: (79) r4 = *(u64 *)(r10 -8)
..
0: (85) call bpf_get_prandom_u32#7
1: (bf) r3 = r10
2: (55) if r3 !=0x7bgoto pc+0
3: (7b) *(u64 *)(r3 -8) = r0
4: (79) r4 = *(u64 *)(r10 -8)When backtracking need to mark R4 it will mark slot fp-8. But ST or STX into fp-8 could belong to the same block of instructions. When backtracing is done the parent state may have fp-8 slot as "unallocated stack". Which will cause verifier to warn and incorrectly reject such programs.
Quoted 8 lines
Writes into stack via non-R10 register are rare. llvm always generates canonical stack spill/fill.
For such pathological case fall back to conservative precision tracking instead of rejecting.Reported-by [email protected]Fixes b5dc0163d8fd ("bpf: precise scalar_value tracking")Signed-off-by Alexei Starovoitov <[email protected]>
Applied, thanks!