1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2019 Facebook 3 #include <test_progs.h> 4 static int libbpf_debug_print(enum libbpf_print_level level, 5 const char *format, va_list args) 6 { 7 if (level != LIBBPF_DEBUG) { 8 vprintf(format, args); 9 return 0; 10 } 11 12 if (!strstr(format, "verifier log")) 13 return 0; 14 vprintf("%s", args); 15 return 0; 16 } 17 18 extern int extra_prog_load_log_flags; 19 20 static int check_load(const char *file, enum bpf_prog_type type) 21 { 22 struct bpf_object *obj = NULL; 23 struct bpf_program *prog; 24 int err; 25 26 obj = bpf_object__open_file(file, NULL); 27 err = libbpf_get_error(obj); 28 if (err) 29 return err; 30 31 prog = bpf_object__next_program(obj, NULL); 32 if (!prog) { 33 err = -ENOENT; 34 goto err_out; 35 } 36 37 bpf_program__set_type(prog, type); 38 bpf_program__set_flags(prog, testing_prog_flags()); 39 bpf_program__set_log_level(prog, 4 | extra_prog_load_log_flags); 40 41 err = bpf_object__load(obj); 42 43 err_out: 44 bpf_object__close(obj); 45 return err; 46 } 47 48 static void scale_test(const char *file, 49 enum bpf_prog_type attach_type, 50 bool should_fail) 51 { 52 libbpf_print_fn_t old_print_fn = NULL; 53 int err; 54 55 if (env.verifier_stats) { 56 test__force_log(); 57 old_print_fn = libbpf_set_print(libbpf_debug_print); 58 } 59 60 err = check_load(file, attach_type); 61 if (should_fail) 62 ASSERT_ERR(err, "expect_error"); 63 else 64 ASSERT_OK(err, "expect_success"); 65 66 if (env.verifier_stats) 67 libbpf_set_print(old_print_fn); 68 } 69 70 void test_verif_scale1() 71 { 72 scale_test("test_verif_scale1.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false); 73 } 74 75 void test_verif_scale2() 76 { 77 scale_test("test_verif_scale2.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false); 78 } 79 80 void test_verif_scale3() 81 { 82 scale_test("test_verif_scale3.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false); 83 } 84 85 void test_verif_scale_pyperf_global() 86 { 87 scale_test("pyperf_global.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 88 } 89 90 void test_verif_scale_pyperf_subprogs() 91 { 92 scale_test("pyperf_subprogs.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 93 } 94 95 void test_verif_scale_pyperf50() 96 { 97 /* full unroll by llvm */ 98 scale_test("pyperf50.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 99 } 100 101 void test_verif_scale_pyperf100() 102 { 103 /* full unroll by llvm */ 104 scale_test("pyperf100.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 105 } 106 107 void test_verif_scale_pyperf180() 108 { 109 /* full unroll by llvm */ 110 scale_test("pyperf180.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 111 } 112 113 void test_verif_scale_pyperf600() 114 { 115 /* partial unroll. llvm will unroll loop ~150 times. 116 * C loop count -> 600. 117 * Asm loop count -> 4. 118 * 16k insns in loop body. 119 * Total of 5 such loops. Total program size ~82k insns. 120 */ 121 scale_test("pyperf600.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 122 } 123 124 void test_verif_scale_pyperf600_bpf_loop(void) 125 { 126 /* use the bpf_loop helper*/ 127 scale_test("pyperf600_bpf_loop.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 128 } 129 130 void test_verif_scale_pyperf600_nounroll() 131 { 132 /* no unroll at all. 133 * C loop count -> 600. 134 * ASM loop count -> 600. 135 * ~110 insns in loop body. 136 * Total of 5 such loops. Total program size ~1500 insns. 137 */ 138 scale_test("pyperf600_nounroll.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 139 } 140 141 void test_verif_scale_pyperf600_iter() 142 { 143 /* open-coded BPF iterator version */ 144 scale_test("pyperf600_iter.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 145 } 146 147 void test_verif_scale_loop1() 148 { 149 scale_test("loop1.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 150 } 151 152 void test_verif_scale_loop2() 153 { 154 scale_test("loop2.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 155 } 156 157 void test_verif_scale_loop3_fail() 158 { 159 scale_test("loop3.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, true /* fails */); 160 } 161 162 void test_verif_scale_loop4() 163 { 164 scale_test("loop4.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false); 165 } 166 167 void test_verif_scale_loop5() 168 { 169 scale_test("loop5.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false); 170 } 171 172 void test_verif_scale_loop6() 173 { 174 scale_test("loop6.bpf.o", BPF_PROG_TYPE_KPROBE, false); 175 } 176 177 void test_verif_scale_strobemeta() 178 { 179 /* partial unroll. 19k insn in a loop. 180 * Total program size 20.8k insn. 181 * ~350k processed_insns 182 */ 183 scale_test("strobemeta.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 184 } 185 186 void test_verif_scale_strobemeta_bpf_loop(void) 187 { 188 /* use the bpf_loop helper*/ 189 scale_test("strobemeta_bpf_loop.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 190 } 191 192 void test_verif_scale_strobemeta_nounroll1() 193 { 194 /* no unroll, tiny loops */ 195 scale_test("strobemeta_nounroll1.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 196 } 197 198 void test_verif_scale_strobemeta_nounroll2() 199 { 200 /* no unroll, tiny loops */ 201 scale_test("strobemeta_nounroll2.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 202 } 203 204 void test_verif_scale_strobemeta_subprogs() 205 { 206 /* non-inlined subprogs */ 207 scale_test("strobemeta_subprogs.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false); 208 } 209 210 void test_verif_scale_sysctl_loop1() 211 { 212 scale_test("test_sysctl_loop1.bpf.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false); 213 } 214 215 void test_verif_scale_sysctl_loop2() 216 { 217 scale_test("test_sysctl_loop2.bpf.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false); 218 } 219 220 void test_verif_scale_xdp_loop() 221 { 222 scale_test("test_xdp_loop.bpf.o", BPF_PROG_TYPE_XDP, false); 223 } 224 225 void test_verif_scale_seg6_loop() 226 { 227 scale_test("test_seg6_loop.bpf.o", BPF_PROG_TYPE_LWT_SEG6LOCAL, false); 228 } 229 230 void test_verif_twfw() 231 { 232 scale_test("twfw.bpf.o", BPF_PROG_TYPE_CGROUP_SKB, false); 233 } 234