bpf: propagate precision across all frames, not just the last one

When equivalent completed state is found and it has additional precision
restrictions, BPF verifier propagates precision to
currently-being-verified state chain (i.e., including parent states) so
that if some of the states in the chain are not yet completed, necessary
precision restrictions are enforced.

Unfortunately, right now this happens only for the last frame (deepest
active subprogram's frame), not all the frames. This can lead to
incorrect matching of states due to missing precision marker. Currently
this doesn't seem possible as BPF verifier forces everything to precise
when validated BPF program has any subprograms. But with the next patch
lifting this restriction, this becomes problematic.

In fact, without this fix, we'll start getting failure in one of the
existing test_verifier test cases:

  #906/p precise: cross frame pruning FAIL
  Unexpected success to load!
  verification time 48 usec
  stack depth 0+0
  processed 26 insns (limit 1000000) max_states_per_insn 3 total_states 17 peak_states 17 mark_read 8

This patch adds precision propagation across all frames.

Fixes: a3ce685dd01a ("bpf: fix precision tracking")
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/r/20221104163649.121784-3-andrii@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index ddfb4b0ab35f56925baa5db730105868a9f2a8f4..5c708eb306643f09b31de98fa8db576d09b60a23 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -2756,7 +2756,7 @@ static void mark_all_scalars_precise(struct bpf_verifier_env *env,
                }
 }
 
-static int __mark_chain_precision(struct bpf_verifier_env *env, int regno,
+static int __mark_chain_precision(struct bpf_verifier_env *env, int frame, int regno,
                                  int spi)
 {
        struct bpf_verifier_state *st = env->cur_state;
@@ -2773,7 +2773,7 @@ static int __mark_chain_precision(struct bpf_verifier_env *env, int regno,
        if (!env->bpf_capable)
                return 0;
 
-       func = st->frame[st->curframe];
+       func = st->frame[frame];
        if (regno >= 0) {
                reg = &func->regs[regno];
                if (reg->type != SCALAR_VALUE) {
@@ -2854,7 +2854,7 @@ static int __mark_chain_precision(struct bpf_verifier_env *env, int regno,
                        break;
 
                new_marks = false;
-               func = st->frame[st->curframe];
+               func = st->frame[frame];
                bitmap_from_u64(mask, reg_mask);
                for_each_set_bit(i, mask, 32) {
                        reg = &func->regs[i];
@@ -2920,12 +2920,17 @@ static int __mark_chain_precision(struct bpf_verifier_env *env, int regno,
 
 int mark_chain_precision(struct bpf_verifier_env *env, int regno)
 {
-       return __mark_chain_precision(env, regno, -1);
+       return __mark_chain_precision(env, env->cur_state->curframe, regno, -1);
 }
 
-static int mark_chain_precision_stack(struct bpf_verifier_env *env, int spi)
+static int mark_chain_precision_frame(struct bpf_verifier_env *env, int frame, int regno)
 {
-       return __mark_chain_precision(env, -1, spi);
+       return __mark_chain_precision(env, frame, regno, -1);
+}
+
+static int mark_chain_precision_stack_frame(struct bpf_verifier_env *env, int frame, int spi)
+{
+       return __mark_chain_precision(env, frame, -1, spi);
 }
 
 static bool is_spillable_regtype(enum bpf_reg_type type)
@@ -11794,34 +11799,36 @@ static int propagate_precision(struct bpf_verifier_env *env,
 {
        struct bpf_reg_state *state_reg;
        struct bpf_func_state *state;
-       int i, err = 0;
+       int i, err = 0, fr;
 
-       state = old->frame[old->curframe];
-       state_reg = state->regs;
-       for (i = 0; i < BPF_REG_FP; i++, state_reg++) {
-               if (state_reg->type != SCALAR_VALUE ||
-                   !state_reg->precise)
-                       continue;
-               if (env->log.level & BPF_LOG_LEVEL2)
-                       verbose(env, "propagating r%d\n", i);
-               err = mark_chain_precision(env, i);
-               if (err < 0)
-                       return err;
-       }
+       for (fr = old->curframe; fr >= 0; fr--) {
+               state = old->frame[fr];
+               state_reg = state->regs;
+               for (i = 0; i < BPF_REG_FP; i++, state_reg++) {
+                       if (state_reg->type != SCALAR_VALUE ||
+                           !state_reg->precise)
+                               continue;
+                       if (env->log.level & BPF_LOG_LEVEL2)
+                               verbose(env, "frame %d: propagating r%d\n", i, fr);
+                       err = mark_chain_precision_frame(env, fr, i);
+                       if (err < 0)
+                               return err;
+               }
 
-       for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {
-               if (!is_spilled_reg(&state->stack[i]))
-                       continue;
-               state_reg = &state->stack[i].spilled_ptr;
-               if (state_reg->type != SCALAR_VALUE ||
-                   !state_reg->precise)
-                       continue;
-               if (env->log.level & BPF_LOG_LEVEL2)
-                       verbose(env, "propagating fp%d\n",
-                               (-i - 1) * BPF_REG_SIZE);
-               err = mark_chain_precision_stack(env, i);
-               if (err < 0)
-                       return err;
+               for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {
+                       if (!is_spilled_reg(&state->stack[i]))
+                               continue;
+                       state_reg = &state->stack[i].spilled_ptr;
+                       if (state_reg->type != SCALAR_VALUE ||
+                           !state_reg->precise)
+                               continue;
+                       if (env->log.level & BPF_LOG_LEVEL2)
+                               verbose(env, "frame %d: propagating fp%d\n",
+                                       (-i - 1) * BPF_REG_SIZE, fr);
+                       err = mark_chain_precision_stack_frame(env, fr, i);
+                       if (err < 0)
+                               return err;
+               }
        }
        return 0;
 }