bpf: bounded loops and other features
Subsystems (7)
Alexei Starovoitov
maintainerPATCH 8/9 selftests/bpf: add realistic loop tests
In reply to Alexei StarovoitovAdd a bunch of loop tests. Most of them are created by replacing '#pragma unroll' with '#pragma clang loop unroll(disable)'
Several tests are artificially large:
/* partial unroll. llvm will unroll loop ~150 times.
* C loop count -> 600.
* Asm loop count -> 4.
* 16k insns in loop body.
* Total of 5 such loops. Total program size ~82k insns. */
"./pyperf600.o",
/* no unroll at all.
* C loop count -> 600.
* ASM loop count -> 600.
* ~110 insns in loop body.
* Total of 5 such loops. Total program size ~1500 insns. */
"./pyperf600_nounroll.o",
/* partial unroll. 19k insn in a loop.
* Total program size 20.8k insn.
* ~350k processed_insns
*/
"./strobemeta.o",
--- .../bpf/prog_tests/bpf_verif_scale.c | 67 ++- tools/testing/selftests/bpf/progs/loop1.c | 28 + tools/testing/selftests/bpf/progs/loop2.c | 28 + tools/testing/selftests/bpf/progs/loop3.c | 22 + tools/testing/selftests/bpf/progs/pyperf.h | 6 +- tools/testing/selftests/bpf/progs/pyperf600.c | 9 + .../selftests/bpf/progs/pyperf600_nounroll.c | 8 + .../testing/selftests/bpf/progs/strobemeta.c | 10 + .../testing/selftests/bpf/progs/strobemeta.h | 528 ++++++++++++++++++ .../bpf/progs/strobemeta_nounroll1.c | 9 + .../bpf/progs/strobemeta_nounroll2.c | 9 + .../selftests/bpf/progs/test_seg6_loop.c | 261 +++++++++ .../selftests/bpf/progs/test_sysctl_loop1.c | 68 +++ .../selftests/bpf/progs/test_sysctl_loop2.c | 69 +++ .../selftests/bpf/progs/test_xdp_loop.c | 231 ++++++++ 15 files changed, 1341 insertions(+), 12 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/loop1.c create mode 100644 tools/testing/selftests/bpf/progs/loop2.c create mode 100644 tools/testing/selftests/bpf/progs/loop3.c create mode 100644 tools/testing/selftests/bpf/progs/pyperf600.c create mode 100644 tools/testing/selftests/bpf/progs/pyperf600_nounroll.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta.h create mode 100644 tools/testing/selftests/bpf/progs/strobemeta_nounroll1.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta_nounroll2.c create mode 100644 tools/testing/selftests/bpf/progs/test_seg6_loop.c create mode 100644 tools/testing/selftests/bpf/progs/test_sysctl_loop1.c create mode 100644 tools/testing/selftests/bpf/progs/test_sysctl_loop2.c create mode 100644 tools/testing/selftests/bpf/progs/test_xdp_loop.c
tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c +56 -11
@@ -5,7 +5,7 @@ static int libbpf_debug_print(enum libbpf_print_level level, const char *format, va_list args) { if (level != LIBBPF_DEBUG) - return 0; + return vfprintf(stderr, format, args);if (!strstr (format,"verifier log" ))return 0 ;
@@ -32,24 +32,69 @@ static int check_load(const char *file, enum bpf_prog_type type)void test_bpf_verif_scale (void ) { -const char *scale[] = { -"./test_verif_scale1.o" ,"./test_verif_scale2.o" ,"./test_verif_scale3.o" +const char *sched_cls[] = { +"./test_verif_scale1.o" ,"./test_verif_scale2.o" ,"./test_verif_scale3.o" , }; -const char *pyperf[] = { -"./pyperf50.o" ,"./pyperf100.o" ,"./pyperf180.o" +const char *raw_tp[] = { +/* full unroll by llvm */ +"./pyperf50.o" ,"./pyperf100.o" ,"./pyperf180.o" , + +/* partial unroll. llvm will unroll loop ~150 times. +* C loop count -> 600. +* Asm loop count -> 4. +* 16k insns in loop body. +* Total of 5 such loops. Total program size ~82k insns. +*/ +"./pyperf600.o" , + +/* no unroll at all. +* C loop count -> 600. +* ASM loop count -> 600. +* ~110 insns in loop body. +* Total of 5 such loops. Total program size ~1500 insns. +*/ +"./pyperf600_nounroll.o" , + +"./loop1.o" ,"./loop2.o" , + +/* partial unroll. 19k insn in a loop. +* Total program size 20.8k insn. +* ~350k processed_insns +*/ +"./strobemeta.o" , + +/* no unroll, tiny loops */ +"./strobemeta_nounroll1.o" , +"./strobemeta_nounroll2.o" , + }; +const char *cg_sysctl[] = { +"./test_sysctl_loop1.o" ,"./test_sysctl_loop2.o" , };int err, i;if (verifier_stats)libbpf_set_print (libbpf_debug_print); -for (i =0 ; i <ARRAY_SIZE (scale); i++) { - err =check_load (scale[i],BPF_PROG_TYPE_SCHED_CLS ); -printf ("test_scale:%s:%s\n" , scale[i], err ?"FAIL" :"OK" ); + err =check_load ("./loop3.o" ,BPF_PROG_TYPE_RAW_TRACEPOINT ); +printf ("test_scale:loop3:%s\n" , err ? (error_cnt--,"OK" ) :"FAIL" ); + +for (i =0 ; i <ARRAY_SIZE (sched_cls); i++) { + err =check_load (sched_cls[i],BPF_PROG_TYPE_SCHED_CLS ); +printf ("test_scale:%s:%s\n" , sched_cls[i], err ?"FAIL" :"OK" ); } -for (i =0 ; i <ARRAY_SIZE (pyperf); i++) { - err =check_load (pyperf[i],BPF_PROG_TYPE_RAW_TRACEPOINT ); -printf ("test_scale:%s:%s\n" , pyperf[i], err ?"FAIL" :"OK" ); +for (i =0 ; i <ARRAY_SIZE (raw_tp); i++) { + err =check_load (raw_tp[i],BPF_PROG_TYPE_RAW_TRACEPOINT ); +printf ("test_scale:%s:%s\n" , raw_tp[i], err ?"FAIL" :"OK" ); } + +for (i =0 ; i <ARRAY_SIZE (cg_sysctl); i++) { + err =check_load (cg_sysctl[i],BPF_PROG_TYPE_CGROUP_SYSCTL ); +printf ("test_scale:%s:%s\n" , cg_sysctl[i], err ?"FAIL" :"OK" ); + } + err =check_load ("./test_xdp_loop.o" ,BPF_PROG_TYPE_XDP ); +printf ("test_scale:test_xdp_loop:%s\n" , err ?"FAIL" :"OK" ); + + err =check_load ("./test_seg6_loop.o" ,BPF_PROG_TYPE_LWT_SEG6LOCAL ); +printf ("test_scale:test_seg6_loop:%s\n" , err ?"FAIL" :"OK" ); }
tools/testing/selftests/bpf/progs/loop1.c new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +#include <linux/sched.h> +#include <linux/ptrace.h> +#include <stdint.h> +#include <stddef.h> +#include <stdbool.h> +#include <linux/bpf.h> +#include "bpf_helpers.h" + +char _license[] SEC("license") = "GPL"; + +SEC("raw_tracepoint/kfree_skb") +int nested_loops (volatile struct pt_regs * ctx) +{ +int i, j, sum =0 , m; + +for (j =0 ; j <300 ; j++) +for (i =0 ; i < j; i++) { +if (j &1 ) + m = ctx->rax; +else + m = j; + sum += i * m; + } + +return sum; +}
tools/testing/selftests/bpf/progs/loop2.c new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +#include <linux/sched.h> +#include <linux/ptrace.h> +#include <stdint.h> +#include <stddef.h> +#include <stdbool.h> +#include <linux/bpf.h> +#include "bpf_helpers.h" + +char _license[] SEC("license") = "GPL"; + +SEC("raw_tracepoint/consume_skb") +int while_true (volatile struct pt_regs * ctx) +{ +int i =0 ; + +while (true) { +if (ctx->rax &1 ) + i +=3 ; +else + i +=7 ; +if (i >40 ) +break ; + } + +return i; +}
tools/testing/selftests/bpf/progs/loop3.c new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +#include <linux/sched.h> +#include <linux/ptrace.h> +#include <stdint.h> +#include <stddef.h> +#include <stdbool.h> +#include <linux/bpf.h> +#include "bpf_helpers.h" + +char _license[] SEC("license") = "GPL"; + +SEC("raw_tracepoint/consume_skb") +int while_true (volatile struct pt_regs * ctx) +{ +__u64 i =0 , sum =0 ; +do { + i++; + sum += ctx->rax; + }while (i <0x100000000ULL ); +return sum; +}
tools/testing/selftests/bpf/progs/pyperf.h +5 -1
@@ -220,7 +220,11 @@ static inline __attribute__((__always_inline__)) int __on_event(struct pt_regs *int32_t * symbol_counter =bpf_map_lookup_elem (&symbolmap, &sym);if (symbol_counter ==NULL )return 0 ; -#pragma unroll +#ifdef NO_UNROLL +#pragma clang loop unroll(disable) +#else +#pragma clang loop unroll(full) +#endif /* Unwind python stack */ for (int i =0 ; i <STACK_MAX_LEN ; ++i) {if (frame_ptr &&get_frame_data (frame_ptr, pidData, &frame, &sym)) {
tools/testing/selftests/bpf/progs/pyperf600.c new file +9 -0
@@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +#define STACK_MAX_LEN 600 +/* clang will not unroll the loop 600 times. +* Instead it will unroll it to the amount it deemed +* appropriate, but the loop will still execute 600 times. +* Total program size is around 90k insns +*/ +#include "pyperf.h"
tools/testing/selftests/bpf/progs/pyperf600_nounroll.c new file +8 -0
@@ -0,0 +1,8 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +#define STACK_MAX_LEN 600 +#define NO_UNROLL +/* clang will not unroll at all. +* Total program size is around 2k insns +*/ +#include "pyperf.h"
tools/testing/selftests/bpf/progs/strobemeta.c new file +10 -0
@@ -0,0 +1,10 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2019 Facebook + +#define STROBE_MAX_INTS 2 +#define STROBE_MAX_STRS 25 +#define STROBE_MAX_MAPS 100 +#define STROBE_MAX_MAP_ENTRIES 20 +/* full unroll by llvm #undef NO_UNROLL */ +#include "strobemeta.h" +
tools/testing/selftests/bpf/progs/strobemeta.h new file +528 -0
528 lines not on this page · raw message
tools/testing/selftests/bpf/progs/strobemeta_nounroll1.c new file +9 -0
@@ -0,0 +1,9 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2019 Facebook + +#define STROBE_MAX_INTS 2 +#define STROBE_MAX_STRS 25 +#define STROBE_MAX_MAPS 13 +#define STROBE_MAX_MAP_ENTRIES 20 +#define NO_UNROLL +#include "strobemeta.h"
tools/testing/selftests/bpf/progs/strobemeta_nounroll2.c new file +9 -0
@@ -0,0 +1,9 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2019 Facebook + +#define STROBE_MAX_INTS 2 +#define STROBE_MAX_STRS 25 +#define STROBE_MAX_MAPS 30 +#define STROBE_MAX_MAP_ENTRIES 20 +#define NO_UNROLL +#include "strobemeta.h"
tools/testing/selftests/bpf/progs/test_seg6_loop.c new file +261 -0
261 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_sysctl_loop1.c new file +68 -0
68 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_sysctl_loop2.c new file +69 -0
69 lines not on this page · raw message
tools/testing/selftests/bpf/progs/test_xdp_loop.c new file +231 -0
231 lines not on this page · raw message
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 9/9 bpf: precise scalar_value tracking
In reply to Alexei StarovoitovIntroduce precision tracking logic that
helps cilium programs the most:
old clang old clang new clang new clang
with all patches with all patches
bpf_lb-DLB_L3.o 1838 2728 1923 2216 bpf_lb-DLB_L4.o 3218 3562 3077 3390 bpf_lb-DUNKNOWN.o 1064 544 1062 543 bpf_lxc-DDROP_ALL.o 26935 15989 166729 15372 bpf_lxc-DUNKNOWN.o 34439 26043 174607 22156 bpf_netdev.o 9721 8062 8407 7312 bpf_overlay.o 6184 6138 5420 5555 bpf_lxc_jit.o 39389 39452 39389 39452
Consider code:
654: (85) call bpf_get_hash_recalc#34
655: (bf) r7 = r0
656: (15) if r8 == 0x0 goto pc+29
657: (bf) r2 = r10
658: (07) r2 += -48
659: (18) r1 = 0xffff8881e41e1b00
661: (85) call bpf_map_lookup_elem#1
662: (15) if r0 == 0x0 goto pc+23
663: (69) r1 = *(u16 *)(r0 +0)
664: (15) if r1 == 0x0 goto pc+21
665: (bf) r8 = r7
666: (57) r8 &= 65535
667: (bf) r2 = r8
668: (3f) r2 /= r1
669: (2f) r2 *= r1
670: (bf) r1 = r8
671: (1f) r1 -= r2
672: (57) r1 &= 255
673: (25) if r1 > 0x1e goto pc+12
R0=map_value(id=0,off=0,ks=20,vs=64,imm=0) R1_w=inv(id=0,umax_value=30,var_off=(0x0; 0x1f))
674: (67) r1 <<= 1
675: (0f) r0 += r1
At this point the verifier will notice that scalar R1 is used in map pointer adjustment. R1 has to be precise for later operations on R0 to be validated properly.
The verifier will backtrack the above code in the following way:last_idx 675 first_idx 664
regs=2 stack=0 before 675: (0f) r0 += r1 // started backtracking R1 regs=2 is a bitmask
regs=2 stack=0 before 674: (67) r1 <<= 1
regs=2 stack=0 before 673: (25) if r1 > 0x1e goto pc+12
regs=2 stack=0 before 672: (57) r1 &= 255
regs=2 stack=0 before 671: (1f) r1 -= r2 // now both R1 and R2 has to be precise -> regs=6 mask
regs=6 stack=0 before 670: (bf) r1 = r8 // after this insn R8 and R2 has to be precise
regs=104 stack=0 before 669: (2f) r2 *= r1 // after this one R8, R2, and R1
regs=106 stack=0 before 668: (3f) r2 /= r1
regs=106 stack=0 before 667: (bf) r2 = r8
regs=102 stack=0 before 666: (57) r8 &= 65535
regs=102 stack=0 before 665: (bf) r8 = r7
regs=82 stack=0 before 664: (15) if r1 == 0x0 goto pc+21
// this is the end of verifier state. The following regs will be marked precised:
R1_rw=invP(id=0,umax_value=65535,var_off=(0x0; 0xffff)) R7_rw=invP(id=0)
parent didn't have regs=82 stack=0 marks // so backtracking continues into parent statelast_idx 663 first_idx 655
regs=82 stack=0 before 663: (69) r1 = *(u16 *)(r0 +0) // R1 was assigned no need to track it further
regs=80 stack=0 before 662: (15) if r0 == 0x0 goto pc+23 // keep tracking R7
regs=80 stack=0 before 661: (85) call bpf_map_lookup_elem#1 // keep tracking R7
regs=80 stack=0 before 659: (18) r1 = 0xffff8881e41e1b00
regs=80 stack=0 before 658: (07) r2 += -48
regs=80 stack=0 before 657: (bf) r2 = r10
regs=80 stack=0 before 656: (15) if r8 == 0x0 goto pc+29
regs=80 stack=0 before 655: (bf) r7 = r0 // here the assignment into R7
// mark R0 to be precise:
R0_rw=invP(id=0)
parent didn't have regs=1 stack=0 marks // regs=1 -> tracking R0last_idx 654 first_idx 644
regs=1 stack=0 before 654: (85) call bpf_get_hash_recalc#34 // and in the parent frame it was a return value
// nothing further to backtrack
Two scalar registers not marked precise are equivalent from state pruning point of view. More details in the patch comments.
It doesn't support bpf2bpf calls yet and enabled for root only.
--- include/linux/bpf_verifier.h | 18 ++ kernel/bpf/verifier.c | 461 ++++++++++++++++++++++++++++++++++- 2 files changed, 469 insertions(+), 10 deletions(-)
include/linux/bpf_verifier.h +18 -0
@@ -139,6 +139,8 @@ struct bpf_reg_state {*/ s32 subreg_def;enum bpf_reg_liveness live; +/* if (!precise && SCALAR_VALUE) min/max/tnum don't affect safety */ +bool precise; };enum bpf_stack_slot_type {
@@ -190,6 +192,11 @@ struct bpf_func_state {struct bpf_stack_state *stack; }; +struct bpf_idx_pair { +u32 prev_idx; +u32 idx; +}; +#define MAX_CALL_FRAMES 8struct bpf_verifier_state {/* call stack tracking */
@@ -245,6 +252,17 @@ struct bpf_verifier_state {u32 curframe;u32 active_spin_lock;bool speculative; + +/* first and last insn idx of this verifier state */ +u32 first_insn_idx; +u32 last_insn_idx; +/* jmp history recorded from first to last. +* backtracking is using it to go from last to first. +* For most states jmp_history_cnt is [0-3]. +* For loops can go up to ~40. +*/ +struct bpf_idx_pair *jmp_history; +u32 jmp_history_cnt; };#define bpf_get_spilled_reg (slot, frame) \
kernel/bpf/verifier.c +451 -10
632 lines not on this page · raw message
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 5/9 bpf: fix callees pruning callers
In reply to Alexei StarovoitovThe commit 7640ead93924 partially resolved the issue of callees incorrectly pruning the callers.
With introduction of bounded loops and jmps_processed heuristic single verifier state may contain multiple branches and calls.
It's possible that new verifier state (for future pruning) will be allocated inside callee. Then callee will exit (still within the same verifier state). It will go back to the caller and there R6-R9 registers will be read and will trigger mark_reg_read. But the reg->live for all frames but the top frame is not set to LIVE_NONE. Hence mark_reg_read will fail to propagate liveness into parent and future walking will incorrectly conclude that the states are equivalent because LIVE_READ is not set. In other words the rule for parent/live should be:
whenever register parentage chain is set the reg->live should be set to LIVE_NONE. is_state_visited logic already follows this rule for spilled registers.
--- kernel/bpf/verifier.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
kernel/bpf/verifier.c +6 -5
@@ -6835,17 +6835,18 @@ static int is_state_visited(struct bpf_verifier_env *env, int insn_idx)* the state of the call instruction (with WRITTEN set), and r0 comes * from callee with its full parentage chain, anyway. */ -for (j =0 ; j <= cur->curframe; j++) -for (i = j < cur->curframe ?BPF_REG_6 :0 ; i <BPF_REG_FP ; i++) - cur->frame[j]->regs[i].parent = &new->frame[j]->regs[i];/* clear write marks in current state: the writes we did are not writes * our child did, so they don't screen off its reads from us. * (There are no read marks in current state, because reads always mark * their parent and current state never has children yet. Only * explored_states can get read marks.) */ -for (i =0 ; i <BPF_REG_FP ; i++) - cur->frame[cur->curframe]->regs[i].live =REG_LIVE_NONE ; +for (j =0 ; j <= cur->curframe; j++) { +for (i = j < cur->curframe ?BPF_REG_6 :0 ; i <BPF_REG_FP ; i++) + cur->frame[j]->regs[i].parent = &new->frame[j]->regs[i]; +for (i =0 ; i <BPF_REG_FP ; i++) + cur->frame[j]->regs[i].live =REG_LIVE_NONE ; + }/* all stack frames are accessible from callee, clear them all */ for (j =0 ; j <= cur->curframe; j++) {
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 6/9 selftests/bpf: fix tests
In reply to Alexei StarovoitovFix tests that assumed no loops.
--- tools/testing/selftests/bpf/test_verifier.c | 11 ++++------ tools/testing/selftests/bpf/verifier/calls.c | 22 ++++++++++++-------- tools/testing/selftests/bpf/verifier/cfg.c | 11 ++++++---- 3 files changed, 24 insertions(+), 20 deletions(-)
tools/testing/selftests/bpf/test_verifier.c +4 -7
@@ -237,10 +237,10 @@ static void bpf_fill_scale1(struct bpf_test *self) insn[i++] =BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_6 ,-8 * (k %64 +1 )); } -/* every jump adds 1 step to insn_processed, so to stay exactly -* within 1m limit add MAX_TEST_INSNS - MAX_JMP_SEQ - 1 MOVs and 1 EXIT +/* is_state_visited() doesn't allocate state for pruning for every jump. +* Hence multiply jmps by 4 to accommodate that heuristic */ -while (i <MAX_TEST_INSNS -MAX_JMP_SEQ -1 ) +while (i <MAX_TEST_INSNS -MAX_JMP_SEQ *4 ) insn[i++] =BPF_ALU64_IMM (BPF_MOV ,BPF_REG_0 ,42 ); insn[i] =BPF_EXIT_INSN (); self->prog_len = i +1 ;
@@ -269,10 +269,7 @@ static void bpf_fill_scale2(struct bpf_test *self) insn[i++] =BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_6 ,-8 * (k % (64 -4 *FUNC_NEST ) +1 )); } -/* every jump adds 1 step to insn_processed, so to stay exactly -* within 1m limit add MAX_TEST_INSNS - MAX_JMP_SEQ - 1 MOVs and 1 EXIT -*/ -while (i <MAX_TEST_INSNS -MAX_JMP_SEQ -1 ) +while (i <MAX_TEST_INSNS -MAX_JMP_SEQ *4 ) insn[i++] =BPF_ALU64_IMM (BPF_MOV ,BPF_REG_0 ,42 ); insn[i] =BPF_EXIT_INSN (); self->prog_len = i +1 ;
tools/testing/selftests/bpf/verifier/calls.c +13 -9
@@ -215,9 +215,11 @@BPF_MOV64_IMM (BPF_REG_0 ,3 ), BPF_JMP_IMM(BPF_JA, 0, 0, -6), }, - .prog_type =BPF_PROG_TYPE_TRACEPOINT , - .errstr = "back-edge from insn", - .result = REJECT, + .prog_type =BPF_PROG_TYPE_SOCKET_FILTER , + .errstr_unpriv = "back-edge from insn", + .result_unpriv = REJECT, + .result = ACCEPT, + .retval = 1, }, { "calls: conditional call 4",
@@ -250,22 +252,24 @@BPF_MOV64_IMM (BPF_REG_0 ,3 ), BPF_EXIT_INSN(), }, - .prog_type =BPF_PROG_TYPE_TRACEPOINT , - .errstr = "back-edge from insn", - .result = REJECT, + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .result = ACCEPT, + .retval = 1, }, {"calls: conditional call 6" , .insns = { +BPF_MOV64_REG (BPF_REG_6 ,BPF_REG_1 ), +BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_6 ),BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,1 ,0 ,2 ), -BPF_JMP_IMM (BPF_JEQ ,BPF_REG_0 ,0 ,-2 ), +BPF_JMP_IMM (BPF_JEQ ,BPF_REG_0 ,0 ,-3 ),BPF_EXIT_INSN (),BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_1 , offsetof(struct __sk_buff , mark)), BPF_EXIT_INSN(), }, - .prog_type =BPF_PROG_TYPE_TRACEPOINT , - .errstr = "back-edge from insn", + .prog_type =BPF_PROG_TYPE_SCHED_CLS , + .errstr = "infinite loop detected", .result = REJECT, }, {
tools/testing/selftests/bpf/verifier/cfg.c +7 -4
@@ -41,7 +41,8 @@BPF_JMP_IMM (BPF_JA ,0 ,0 ,-1 ), BPF_EXIT_INSN(), }, - .errstr ="back-edge" , + .errstr ="unreachable insn 1" , + .errstr_unpriv = "back-edge", .result = REJECT, }, {
@@ -53,18 +54,20 @@ BPF_JMP_IMM(BPF_JA, 0, 0, -4), BPF_EXIT_INSN(), }, - .errstr = "back-edge", + .errstr = "unreachable insn 4", + .errstr_unpriv = "back-edge", .result = REJECT, }, { "conditional loop", .insns = { -BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), +BPF_MOV64_REG (BPF_REG_0 ,BPF_REG_1 ),BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_0 ),BPF_MOV64_REG (BPF_REG_3 ,BPF_REG_0 ),BPF_JMP_IMM (BPF_JEQ ,BPF_REG_1 ,0 ,-3 ), BPF_EXIT_INSN(), }, - .errstr ="back-edge" , + .errstr ="infinite loop detected" , + .errstr_unpriv = "back-edge", .result = REJECT, },
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 7/9 selftests/bpf: add basic verifier tests for loops
In reply to Alexei StarovoitovThis set of tests is a rewrite of Edward's earlier tests:
https://patchwork.ozlabs.org/patch/877221/
--- tools/testing/selftests/bpf/verifier/loops1.c | 161 ++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 tools/testing/selftests/bpf/verifier/loops1.c
tools/testing/selftests/bpf/verifier/loops1.c new file +161 -0
@@ -0,0 +1,161 @@ +{ + "bounded loop, count to 4", + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, + .retval = 4, +}, +{ +"bounded loop, count to 20" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,3 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,20 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"bounded loop, count from positive unknown to 4" , + .insns = { +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , BPF_FUNC_get_prandom_u32), +BPF_JMP_IMM (BPF_JSLT ,BPF_REG_0 ,0 ,2 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, + .retval = 4, +}, +{ +"bounded loop, count from totally unknown to 4" , + .insns = { +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , BPF_FUNC_get_prandom_u32), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"bounded loop, count to 4 with equality" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JNE ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"bounded loop, start in the middle" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_JMP_A (1 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =REJECT , + .errstr = "back-edge", + .prog_type = BPF_PROG_TYPE_TRACEPOINT, + .retval = 4, +}, +{ +"bounded loop containing a forward jump" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_REG (BPF_JEQ ,BPF_REG_0 ,BPF_REG_0 ,0 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-3 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, + .retval = 4, +}, +{ +"bounded loop that jumps out rather than in" , + .insns = { +BPF_MOV64_IMM (BPF_REG_6 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_6 ,1 ), +BPF_JMP_IMM (BPF_JGT ,BPF_REG_6 ,10000 ,2 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,0 ,0 , BPF_FUNC_get_prandom_u32), +BPF_JMP_A (-4 ), + BPF_EXIT_INSN(), + }, + .result =ACCEPT , + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"infinite loop after a conditional jump" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,5 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,2 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_JMP_A (-2 ), + BPF_EXIT_INSN(), + }, + .result =REJECT , + .errstr = "program is too large", + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"bounded recursion" , + .insns = { +BPF_MOV64_IMM (BPF_REG_1 ,0 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,1 ,0 ,1 ), +BPF_EXIT_INSN (), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,1 ), +BPF_MOV64_REG (BPF_REG_0 ,BPF_REG_1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_1 ,4 ,1 ), +BPF_EXIT_INSN (), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,1 ,0 ,-5 ), + BPF_EXIT_INSN(), + }, + .result =REJECT , + .errstr = "back-edge", + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"infinite loop in two jumps" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_JMP_A (0 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,4 ,-2 ), + BPF_EXIT_INSN(), + }, + .result =REJECT , + .errstr = "loop detected", + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +}, +{ +"infinite loop: three-jump trick" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,0 ), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_ALU64_IMM (BPF_AND ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,2 ,1 ), +BPF_EXIT_INSN (), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_ALU64_IMM (BPF_AND ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,2 ,1 ), +BPF_EXIT_INSN (), +BPF_ALU64_IMM (BPF_ADD ,BPF_REG_0 ,1 ), +BPF_ALU64_IMM (BPF_AND ,BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JLT ,BPF_REG_0 ,2 ,-11 ), + BPF_EXIT_INSN(), + }, + .result =REJECT , + .errstr = "loop detected", + .prog_type = BPF_PROG_TYPE_TRACEPOINT, +},
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 3/9 bpf: extend is_branch_taken to registers
In reply to Alexei StarovoitovThis patch extends is_branch_taken() logic from JMP+K instructions to JMP+X instructions.
Conditional branches are often done when src and dst registers contain known scalars. In such case the verifier can follow the branch that is going to be taken when program executes on CPU. That speeds up the verification and essential feature to support bounded loops.
--- kernel/bpf/verifier.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
kernel/bpf/verifier.c +13 -3
@@ -5263,10 +5263,11 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env,struct bpf_verifier_state *this_branch = env->cur_state;struct bpf_verifier_state *other_branch;struct bpf_reg_state *regs = this_branch->frame[this_branch->curframe]->regs; -struct bpf_reg_state *dst_reg, *other_branch_regs; +struct bpf_reg_state *dst_reg, *other_branch_regs, *src_reg =NULL ;u8 opcode =BPF_OP (insn->code);bool is_jmp32;int err; +u64 cond_val;/* Only conditional jumps are expected to reach here. */ if (opcode ==BPF_JA || opcode >BPF_JSLE ) {
@@ -5290,6 +5291,7 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env, insn->src_reg);return -EACCES ; } + src_reg = ®s[insn->src_reg]; }else {if (insn->src_reg !=BPF_REG_0 ) {verbose (env,"BPF_JMP/JMP32 uses reserved fields\n" );
@@ -5306,8 +5308,11 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env, is_jmp32 =BPF_CLASS (insn->code) ==BPF_JMP32 ;if (BPF_SRC (insn->code) ==BPF_K ) { -int pred =is_branch_taken (dst_reg, insn->imm, opcode, - is_jmp32); +int pred; + + cond_val = insn->imm; +check_taken: + pred =is_branch_taken (dst_reg, cond_val, opcode, is_jmp32);if (pred ==1 ) {/* only follow the goto, ignore fall-through */
@@ -5319,6 +5324,11 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env,*/ return 0 ; } + }else if (BPF_SRC (insn->code) ==BPF_X && + src_reg->type ==SCALAR_VALUE && +tnum_is_const (src_reg->var_off)) { + cond_val = src_reg->var_off.value; + goto check_taken; } other_branch = push_stack(env, *insn_idx + insn->off + 1, *insn_idx,
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 4/9 bpf: introduce bounded loops
In reply to Alexei StarovoitovAllow the verifier to validate the loops by simulating their execution. Exisiting programs have used '#pragma unroll' to unroll the loops by the compiler. Instead let the verifier simulate all iterations of the loop.
In order to do that introduce parentage chain of bpf_verifier_state and 'branches' counter for the number of branches left to explore. See more detailed algorithm description in bpf_verifier.h
This algorithm borrows the key idea from Edward Cree approach:
https://patchwork.ozlabs.org/patch/877222/
Additional state pruning heuristics make such brute force loop walk practical even for large loops.
--- include/linux/bpf_verifier.h | 51 +++++++++++++- kernel/bpf/verifier.c | 133 ++++++++++++++++++++++++++++++++--- 2 files changed, 175 insertions(+), 9 deletions(-)
include/linux/bpf_verifier.h +50 -1
@@ -194,6 +194,53 @@ struct bpf_func_state {struct bpf_verifier_state {/* call stack tracking */ struct bpf_func_state *frame[MAX_CALL_FRAMES ]; +struct bpf_verifier_state *parent; +/* +* 'branches' field is the number of branches left to explore: +* 0 - all possible paths from this state reached bpf_exit or +* were safely pruned +* 1 - at least one path is being explored. +* This state hasn't reached bpf_exit +* 2 - at least two paths are being explored. +* This state is an immediate parent of two children. +* One is fallthrough branch with branches==1 and another +* state is pushed into stack (to be explored later) also with +* branches==1. The parent of this state has branches==1. +* The verifier state tree connected via 'parent' pointer looks like: +* 1 +* 1 +* 2 -> 1 (first 'if' pushed into stack) +* 1 +* 2 -> 1 (second 'if' pushed into stack) +* 1 +* 1 +* 1 bpf_exit. +* +* Once do_check() reaches bpf_exit, it calls update_branch_counts() +* and the verifier state tree will look: +* 1 +* 1 +* 2 -> 1 (first 'if' pushed into stack) +* 1 +* 1 -> 1 (second 'if' pushed into stack) +* 0 +* 0 +* 0 bpf_exit. +* After pop_stack() the do_check() will resume at second 'if'. +* +* If is_state_visited() sees a state with branches > 0 it means +* there is a loop. If such state is exactly equal to the current state +* it's an infinite loop. Note states_equal() checks for states +* equvalency, so two states being 'states_equal' does not mean +* infinite loop. The exact comparison is provided by +* states_maybe_looping() function. It's a stronger pre-check and +* much faster than states_equal(). +* +* This algorithm may not find all possible infinite loops or +* loop iteration count may be too high. +* In such cases BPF_COMPLEXITY_LIMIT_INSNS limit kicks in. +*/ +u32 branches;u32 insn_idx;u32 curframe;u32 active_spin_lock;
@@ -312,7 +359,9 @@ struct bpf_verifier_env { } cfg;u32 subprog_cnt;/* number of instructions analyzed by the verifier */ -u32 insn_processed; +u32 prev_insn_processed, insn_processed; +/* number of jmps, calls, exits analyzed so far */ +u32 prev_jmps_processed, jmps_processed;/* total verification time */ u64 verification_time;/* maximum number of verifier states kept in 'branching' instructions */
kernel/bpf/verifier.c +125 -8
276 lines not on this page · raw message
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 2/9 selftests/bpf: fix tests due to const spill/fill
In reply to Alexei Starovoitovfix tests that incorrectly assumed that the verifier cannot track constants through stack.
--- .../bpf/verifier/direct_packet_access.c | 3 +- .../bpf/verifier/helper_access_var_len.c | 28 ++++++++++--------- 2 files changed, 17 insertions(+), 14 deletions(-)
tools/testing/selftests/bpf/verifier/direct_packet_access.c +2 -1
@@ -511,7 +511,8 @@ offsetof(struct __sk_buff, data)),BPF_LDX_MEM (BPF_W ,BPF_REG_3 ,BPF_REG_1 , offsetof(struct __sk_buff , data_end)), -BPF_MOV64_IMM (BPF_REG_0 ,0xffffffff ), +BPF_LDX_MEM (BPF_W ,BPF_REG_0 ,BPF_REG_1 , + offsetof(struct __sk_buff , mark)),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_0 ,-8 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_0 ,BPF_REG_10 ,-8 ), BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 0xffff),
tools/testing/selftests/bpf/verifier/helper_access_var_len.c +15 -13
@@ -29,9 +29,9 @@ { "helper access to variable memory: stack, bitwise AND, zero included", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 64),
@@ -46,9 +46,9 @@ { "helper access to variable memory: stack, bitwise AND + JMP, wrong max", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 65),
@@ -122,9 +122,9 @@ { "helper access to variable memory: stack, JMP, bounds + offset", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_JMP_IMM(BPF_JGT, BPF_REG_2, 64, 5),
@@ -143,9 +143,9 @@ { "helper access to variable memory: stack, JMP, wrong max", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_JMP_IMM(BPF_JGT, BPF_REG_2, 65, 4),
@@ -163,9 +163,9 @@ { "helper access to variable memory: stack, JMP, no max check", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_MOV64_IMM(BPF_REG_4, 0),
@@ -183,9 +183,9 @@ { "helper access to variable memory: stack, JMP, no min check", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_JMP_IMM(BPF_JGT, BPF_REG_2, 64, 3),
@@ -201,9 +201,9 @@ { "helper access to variable memory: stack, JMP (signed), no min check", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), -BPF_MOV64_IMM (BPF_REG_2 ,16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_1 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,-128 ), BPF_JMP_IMM(BPF_JSGT, BPF_REG_2, 64, 3),
@@ -244,6 +244,7 @@ { "helper access to variable memory: map, JMP, wrong max", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
@@ -251,7 +252,7 @@BPF_EMIT_CALL (BPF_FUNC_map_lookup_elem),BPF_JMP_IMM (BPF_JEQ ,BPF_REG_0 ,0 ,10 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ), -BPF_MOV64_IMM (BPF_REG_2 ,sizeof (struct test_val )), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_6 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_10 ,-128 ), BPF_JMP_IMM(BPF_JSGT, BPF_REG_2, sizeof(struct test_val) + 1, 4),
@@ -262,7 +263,7 @@BPF_MOV64_IMM (BPF_REG_0 ,0 ), BPF_EXIT_INSN(), }, - .fixup_map_hash_48b = { 3 }, + .fixup_map_hash_48b = { 4 }, .errstr = "invalid access to map value, value_size=48 off=0 size=49", .result = REJECT, .prog_type = BPF_PROG_TYPE_TRACEPOINT,
@@ -296,6 +297,7 @@ { "helper access to variable memory: map adjusted, JMP, wrong max", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_6 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_2 ,-8 ), BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
@@ -304,7 +306,7 @@BPF_JMP_IMM (BPF_JEQ ,BPF_REG_0 ,0 ,11 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_0 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,20 ), -BPF_MOV64_IMM (BPF_REG_2 ,sizeof (struct test_val )), +BPF_MOV64_REG (BPF_REG_2 ,BPF_REG_6 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_10 ,-128 ), BPF_JMP_IMM(BPF_JSGT, BPF_REG_2, sizeof(struct test_val) - 19, 4),
@@ -315,7 +317,7 @@BPF_MOV64_IMM (BPF_REG_0 ,0 ), BPF_EXIT_INSN(), }, - .fixup_map_hash_48b = { 3 }, + .fixup_map_hash_48b = { 4 }, .errstr = "R1 min value is outside of the array range", .result = REJECT, .prog_type = BPF_PROG_TYPE_TRACEPOINT,
@@ -337,8 +339,8 @@ { "helper access to variable memory: size > 0 not allowed on NULL (ARG_PTR_TO_MEM_OR_NULL)", .insns = { +BPF_LDX_MEM (BPF_W ,BPF_REG_2 ,BPF_REG_1 ,0 ),BPF_MOV64_IMM (BPF_REG_1 ,0 ), -BPF_MOV64_IMM (BPF_REG_2 ,1 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_10 ,-128 ), BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 64),
@@ -562,6 +564,7 @@ { "helper access to variable memory: 8 bytes leak", .insns = { +BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_1 ,8 ),BPF_MOV64_REG (BPF_REG_1 ,BPF_REG_10 ),BPF_ALU64_IMM (BPF_ADD ,BPF_REG_1 ,-64 ), BPF_MOV64_IMM(BPF_REG_0, 0),
@@ -572,7 +575,6 @@BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_0 ,-24 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_0 ,-16 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_0 ,-8 ), -BPF_MOV64_IMM (BPF_REG_2 ,1 ),BPF_STX_MEM (BPF_DW ,BPF_REG_10 ,BPF_REG_2 ,-128 ),BPF_LDX_MEM (BPF_DW ,BPF_REG_2 ,BPF_REG_10 ,-128 ), BPF_ALU64_IMM(BPF_AND, BPF_REG_2, 63),
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainerPATCH 1/9 bpf: track spill/fill of constants
In reply to Alexei StarovoitovCompilers often spill induction variables into the stack, hence it is necessary for the verifier to track scalar values of the registers through stack slots.
Also few bpf programs were incorrectly rejected in the past, since the verifier was not able to track such constants while they were used to compute offsets into packet headers.
Tracking constants through the stack significantly decreases the chances of state pruning, since two different constants are considered to be different by state equivalency.
End result that cilium tests suffer serious degradation in the number of states processed and corresponding verification time increase.
before after bpf_lb-DLB_L3.o 1838 6441 bpf_lb-DLB_L4.o 3218 5908 bpf_lb-DUNKNOWN.o 1064 1064 bpf_lxc-DDROP_ALL.o 26935 93790 bpf_lxc-DUNKNOWN.o 34439 123886 bpf_netdev.o 9721 31413 bpf_overlay.o 6184 18561 bpf_lxc_jit.o 39389 359445
After further debugging turned out that cillium progs are getting hurt by clang due to the same constant tracking issue. Newer clang generates better code by spilling less to the stack. Instead it keeps more constants in the registers which
hurts state pruning since the verifier already tracks constants in the registers:
old clang new clang
(no spill/fill tracking introduced by this patch)
bpf_lb-DLB_L3.o 1838 1923 bpf_lb-DLB_L4.o 3218 3077 bpf_lb-DUNKNOWN.o 1064 1062 bpf_lxc-DDROP_ALL.o 26935 166729 bpf_lxc-DUNKNOWN.o 34439 174607 bpf_netdev.o 9721 8407 bpf_overlay.o 6184 5420 bpf_lcx_jit.o 39389 39389
The final table is depressing:
old clang old clang new clang new clang
const spill/fill const spill/fill
bpf_lb-DLB_L3.o 1838 6441 1923 8128 bpf_lb-DLB_L4.o 3218 5908 3077 6707 bpf_lb-DUNKNOWN.o 1064 1064 1062 1062 bpf_lxc-DDROP_ALL.o 26935 93790 166729 380712 bpf_lxc-DUNKNOWN.o 34439 123886 174607 440652 bpf_netdev.o 9721 31413 8407 31904 bpf_overlay.o 6184 18561 5420 23569 bpf_lxc_jit.o 39389 359445 39389 359445
Tracking constants in the registers hurts state pruning already. Adding tracking of constants through stack hurts pruning even more. The later patch address this general constant tracking issue with coarse/precise logic.
--- kernel/bpf/verifier.c | 67 +++++++++++++++++++++++++++++++++---------- 1 file changed, 52 insertions(+), 15 deletions(-)
kernel/bpf/verifier.c +52 -15
@@ -1378,6 +1378,11 @@ static bool register_is_null(struct bpf_reg_state *reg)return reg->type ==SCALAR_VALUE &&tnum_equals_const (reg->var_off,0 ); } +static bool register_is_const (struct bpf_reg_state *reg) +{ +return reg->type ==SCALAR_VALUE &&tnum_is_const (reg->var_off); +} +/* check_stack_read/write functions track spill/fill of registers, * stack boundary and alignment are checked in check_mem_access() */
@@ -1387,7 +1392,7 @@ static int check_stack_write(struct bpf_verifier_env *env, {struct bpf_func_state *cur;/* state of the current function */ int i, slot = -off -1 , spi = slot /BPF_REG_SIZE , err; -enum bpf_reg_type type; +struct bpf_reg_state *reg =NULL ; err =realloc_func_state (state,round_up (slot +1 ,BPF_REG_SIZE ), state->acquired_refs, true);
@@ -1404,27 +1409,37 @@ static int check_stack_write(struct bpf_verifier_env *env, } cur = env->cur_state->frame[env->cur_state->curframe]; -if (value_regno >=0 && -is_spillable_regtype ((type = cur->regs[value_regno].type))) { +if (value_regno >=0 ) + reg = &cur->regs[value_regno]; +if (reg && size ==BPF_REG_SIZE &®ister_is_const (reg) && + !tnum_equals_const (reg->var_off,0 )) { + goto save_reg_state; + }else if (reg &&is_spillable_regtype (reg->type)) {/* register containing pointer is being spilled into stack */ if (size !=BPF_REG_SIZE ) { +verbose_linfo (env, insn_idx,"; " );verbose (env,"invalid size of register spill\n" );return -EACCES ; } -if (state != cur && type ==PTR_TO_STACK ) { +if (state != cur && reg->type ==PTR_TO_STACK ) {verbose (env,"cannot spill pointers to stack into stack frame of the caller\n" );return -EINVAL ; } -/* save register state */ - state->stack[spi].spilled_ptr = cur->regs[value_regno]; - state->stack[spi].spilled_ptr.live |=REG_LIVE_WRITTEN ; +if (!env->allow_ptr_leaks) { +bool sanitize = false; -for (i =0 ; i <BPF_REG_SIZE ; i++) { -if (state->stack[spi].slot_type[i] ==STACK_MISC && - !env->allow_ptr_leaks) { +if (state->stack[spi].slot_type[0 ] ==STACK_SPILL && +register_is_const (&state->stack[spi].spilled_ptr)) + sanitize = true; +for (i =0 ; i <BPF_REG_SIZE ; i++) +if (state->stack[spi].slot_type[i] ==STACK_MISC ) { + sanitize = true; +break ; + } +if (sanitize) {int *poff = &env->insn_aux_data[insn_idx].sanitize_stack_off;int soff = (-spi -1 ) *BPF_REG_SIZE ;
@@ -1447,8 +1462,14 @@ static int check_stack_write(struct bpf_verifier_env *env, } *poff = soff; } - state->stack[spi].slot_type[i] =STACK_SPILL ; } +save_reg_state: +/* save register state */ + state->stack[spi].spilled_ptr = *reg; + state->stack[spi].spilled_ptr.live |=REG_LIVE_WRITTEN ; + +for (i =0 ; i <BPF_REG_SIZE ; i++) + state->stack[spi].slot_type[i] =STACK_SPILL ; }else {u8 type =STACK_MISC ;
@@ -1471,8 +1492,7 @@ static int check_stack_write(struct bpf_verifier_env *env, state->stack[spi].spilled_ptr.live |=REG_LIVE_WRITTEN ;/* when we zero initialize stack slots mark them as such */ -if (value_regno >=0 && -register_is_null (&cur->regs[value_regno])) +if (reg &®ister_is_null (reg)) type =STACK_ZERO ;/* Mark slots affected by this stack write. */
@@ -1501,7 +1521,15 @@ static int check_stack_read(struct bpf_verifier_env *env,if (stype[0 ] ==STACK_SPILL ) {if (size !=BPF_REG_SIZE ) { -verbose (env,"invalid size of register spill\n" ); +if (reg_state->stack[spi].spilled_ptr.type ==SCALAR_VALUE ) { +if (value_regno >=0 ) { +mark_reg_unknown (env, state->regs, value_regno); + state->regs[value_regno].live |=REG_LIVE_WRITTEN ; + } + goto mark_read; + } +verbose_linfo (env, env->insn_idx,"; " ); +verbose (env,"invalid size of register fill\n" );return -EACCES ; }for (i =1 ; i <BPF_REG_SIZE ; i++) {
@@ -1520,6 +1548,7 @@ static int check_stack_read(struct bpf_verifier_env *env,*/ state->regs[value_regno].live |=REG_LIVE_WRITTEN ; } +mark_read:mark_reg_read (env, ®_state->stack[spi].spilled_ptr, reg_state->stack[spi].spilled_ptr.parent,REG_LIVE_READ64 );
@@ -2415,7 +2444,7 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, {struct bpf_reg_state *reg =reg_state (env, regno);struct bpf_func_state *state =func (env, reg); -int err, min_off, max_off, i, slot, spi; +int err, min_off, max_off, i, j, slot, spi;if (reg->type !=PTR_TO_STACK ) {/* Allow zero-byte read from NULL, regardless of pointer type */
@@ -2503,6 +2532,14 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, *stype =STACK_MISC ; goto mark; } +if (state->stack[spi].slot_type[0 ] ==STACK_SPILL && + state->stack[spi].spilled_ptr.type ==SCALAR_VALUE ) { +__mark_reg_unknown (&state->stack[spi].spilled_ptr); +for (j =0 ; j <BPF_REG_SIZE ; j++) + state->stack[spi].slot_type[j] =STACK_MISC ; + goto mark; + } + err:if (tnum_is_const (reg->var_off)) { verbose(env, "invalid indirect read from stack off %d+%d size %d\n",
Signature · 1 line
2.20.0
Alexei Starovoitov
maintainercover bpf: bounded loops and other features
Hi,
this patch set introduces verifier support for bounded loops and adds several other improvements.
Ideally they would be introduced one at a time,
but to support bounded loop the verifier needs to 'step back' in the patch 1. That patch introduces tracking of spill/fill of constants through the stack. Though it's a useful feature it hurts cilium tests.
Patch 3 introduces another feature by extending is_branch_taken logic to 'if rX op rY' conditions. This feature is also necessary to support bounded loops.
Then patch 4 adds support for the loops while adding key heuristics with jmp_processed.
Introduction of parentage chain of verifier states in patch 4 allows patch 9 to add backtracking of precise scalar registers which finally resolves degradation from patch 1.
The end result is much faster verifier for existing programs and new support for loops.
See patch 8 for many kinds of loops that are now validated. Patch 9 is the most tricky one and could be rewritten with a different algorithm in the future.
Alexei Starovoitov (9):
bpf: track spill/fill of constants selftests/bpf: fix tests due to const spill/fill
bpf: extend is_branch_taken to registers
bpf: introduce bounded loops
bpf: fix callees pruning callers selftests/bpf: fix tests
selftests/bpf: add basic verifier tests for loops selftests/bpf: add realistic loop tests
bpf: precise scalar_value tracking
include/linux/bpf_verifier.h | 69 +- kernel/bpf/verifier.c | 688 ++++++++++++++++-- .../bpf/prog_tests/bpf_verif_scale.c | 67 +- tools/testing/selftests/bpf/progs/loop1.c | 28 + tools/testing/selftests/bpf/progs/loop2.c | 28 + tools/testing/selftests/bpf/progs/loop3.c | 22 + tools/testing/selftests/bpf/progs/pyperf.h | 6 +- tools/testing/selftests/bpf/progs/pyperf600.c | 9 + .../selftests/bpf/progs/pyperf600_nounroll.c | 8 + .../testing/selftests/bpf/progs/strobemeta.c | 10 + .../testing/selftests/bpf/progs/strobemeta.h | 528 ++++++++++++++ .../bpf/progs/strobemeta_nounroll1.c | 9 + .../bpf/progs/strobemeta_nounroll2.c | 9 + .../selftests/bpf/progs/test_seg6_loop.c | 261 +++++++ .../selftests/bpf/progs/test_sysctl_loop1.c | 68 ++ .../selftests/bpf/progs/test_sysctl_loop2.c | 69 ++ .../selftests/bpf/progs/test_xdp_loop.c | 231 ++++++ tools/testing/selftests/bpf/test_verifier.c | 11 +- tools/testing/selftests/bpf/verifier/calls.c | 22 +- tools/testing/selftests/bpf/verifier/cfg.c | 11 +- .../bpf/verifier/direct_packet_access.c | 3 +- .../bpf/verifier/helper_access_var_len.c | 28 +- tools/testing/selftests/bpf/verifier/loops1.c | 161 ++++ 23 files changed, 2258 insertions(+), 88 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/loop1.c create mode 100644 tools/testing/selftests/bpf/progs/loop2.c create mode 100644 tools/testing/selftests/bpf/progs/loop3.c create mode 100644 tools/testing/selftests/bpf/progs/pyperf600.c create mode 100644 tools/testing/selftests/bpf/progs/pyperf600_nounroll.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta.h create mode 100644 tools/testing/selftests/bpf/progs/strobemeta_nounroll1.c create mode 100644 tools/testing/selftests/bpf/progs/strobemeta_nounroll2.c create mode 100644 tools/testing/selftests/bpf/progs/test_seg6_loop.c create mode 100644 tools/testing/selftests/bpf/progs/test_sysctl_loop1.c create mode 100644 tools/testing/selftests/bpf/progs/test_sysctl_loop2.c create mode 100644 tools/testing/selftests/bpf/progs/test_xdp_loop.c create mode 100644 tools/testing/selftests/bpf/verifier/loops1.c
Signature · 1 line
2.20.0