1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <test_progs.h> 4 5 #include "arena_kfunc.skel.h" 6 #include "arena_noarena.skel.h" 7 #include "arena_kfunc_jit.skel.h" 8 #include "cap_helpers.h" 9 #include "cb_refs.skel.h" 10 #include "verifier_aggregate_arg.skel.h" 11 #include "verifier_aggregate_ret.skel.h" 12 #include "verifier_align.skel.h" 13 #include "verifier_and.skel.h" 14 #include "verifier_arena.skel.h" 15 #include "verifier_arena_large.skel.h" 16 #include "verifier_arena_scalar.skel.h" 17 #include "verifier_arena_globals1.skel.h" 18 #include "verifier_arena_globals2.skel.h" 19 #include "verifier_array_access.skel.h" 20 #include "verifier_async_cb_context.skel.h" 21 #include "verifier_basic_stack.skel.h" 22 #include "verifier_bitfield_write.skel.h" 23 #include "verifier_bounds.skel.h" 24 #include "verifier_bounds_step.skel.h" 25 #include "verifier_bounds_deduction.skel.h" 26 #include "verifier_bounds_deduction_non_const.skel.h" 27 #include "verifier_bounds_mix_sign_unsign.skel.h" 28 #include "verifier_bpf_get_stack.skel.h" 29 #include "verifier_bpf_trap.skel.h" 30 #include "verifier_bswap.skel.h" 31 #include "verifier_btf_array_access.skel.h" 32 #include "verifier_btf_ctx_access.skel.h" 33 #include "verifier_btf_flex_array.skel.h" 34 #include "verifier_btf_unreliable_prog.skel.h" 35 #include "verifier_call_large_imm.skel.h" 36 #include "verifier_callx.skel.h" 37 #include "verifier_callx_rodata.skel.h" 38 #include "verifier_cfg.skel.h" 39 #include "verifier_cgroup_inv_retcode.skel.h" 40 #include "verifier_cgroup_skb.skel.h" 41 #include "verifier_cgroup_storage.skel.h" 42 #include "verifier_const.skel.h" 43 #include "verifier_const_or.skel.h" 44 #include "verifier_ctx.skel.h" 45 #include "verifier_ctx_sk_msg.skel.h" 46 #include "verifier_d_path.skel.h" 47 #include "verifier_default_trusted_ptr.skel.h" 48 #include "verifier_direct_packet_access.skel.h" 49 #include "verifier_direct_stack_access_wraparound.skel.h" 50 #include "verifier_div0.skel.h" 51 #include "verifier_div_mod_bounds.skel.h" 52 #include "verifier_div_overflow.skel.h" 53 #include "verifier_flow_keys.skel.h" 54 #include "verifier_global_subprogs.skel.h" 55 #include "verifier_global_ptr_args.skel.h" 56 #include "verifier_gotol.skel.h" 57 #include "verifier_gotox.skel.h" 58 #include "verifier_helper_access_var_len.skel.h" 59 #include "verifier_helper_packet_access.skel.h" 60 #include "verifier_helper_restricted.skel.h" 61 #include "verifier_helper_value_access.skel.h" 62 #include "verifier_idoms.skel.h" 63 #include "verifier_int_ptr.skel.h" 64 #include "verifier_iterating_callbacks.skel.h" 65 #include "verifier_jeq_infer_not_null.skel.h" 66 #include "verifier_jit_convergence.skel.h" 67 #include "verifier_kfunc_packet_access.skel.h" 68 #include "verifier_kfunc_uninit.skel.h" 69 #include "verifier_kfunc_uninit_multi.skel.h" 70 #include "verifier_kfunc_perfmon.skel.h" 71 #include "verifier_ld_ind.skel.h" 72 #include "verifier_large_stack.skel.h" 73 #include "verifier_ldsx.skel.h" 74 #include "verifier_leak_ptr.skel.h" 75 #include "verifier_linked_scalars.skel.h" 76 #include "verifier_live_stack.skel.h" 77 #include "verifier_liveness_exp.skel.h" 78 #include "verifier_load_acquire.skel.h" 79 #include "verifier_loop_hierarchy.skel.h" 80 #include "verifier_loops1.skel.h" 81 #include "verifier_lwt.skel.h" 82 #include "verifier_map_in_map.skel.h" 83 #include "verifier_map_lookup_refine.skel.h" 84 #include "verifier_map_ptr.skel.h" 85 #include "verifier_map_ptr_mixing.skel.h" 86 #include "verifier_map_ret_val.skel.h" 87 #include "verifier_masking.skel.h" 88 #include "verifier_may_goto_1.skel.h" 89 #include "verifier_may_goto_2.skel.h" 90 #include "verifier_mem_size_reg.skel.h" 91 #include "verifier_meta_access.skel.h" 92 #include "verifier_movsx.skel.h" 93 #include "verifier_mtu.skel.h" 94 #include "verifier_mul.skel.h" 95 #include "verifier_netfilter_ctx.skel.h" 96 #include "verifier_netfilter_retcode.skel.h" 97 #include "verifier_bpf_fastcall.skel.h" 98 #include "verifier_or_jmp32_k.skel.h" 99 #include "verifier_percpu_addr.skel.h" 100 #include "verifier_precision.skel.h" 101 #include "verifier_prevent_map_lookup.skel.h" 102 #include "verifier_private_stack.skel.h" 103 #include "verifier_ptr_to_buf.skel.h" 104 #include "verifier_raw_stack.skel.h" 105 #include "verifier_raw_tp_writable.skel.h" 106 #include "verifier_reg_equal.skel.h" 107 #include "verifier_ref_tracking.skel.h" 108 #include "verifier_regalloc.skel.h" 109 #include "verifier_ringbuf.skel.h" 110 #include "verifier_runtime_jit.skel.h" 111 #include "verifier_scalar_ids.skel.h" 112 #include "verifier_scev.skel.h" 113 #include "verifier_sdiv.skel.h" 114 #include "verifier_search_pruning.skel.h" 115 #include "verifier_sock.skel.h" 116 #include "verifier_sock_addr.skel.h" 117 #include "verifier_sockmap_mutate.skel.h" 118 #include "verifier_spill_fill.skel.h" 119 #include "verifier_spin_lock.skel.h" 120 #include "verifier_stack_arg.skel.h" 121 #include "verifier_stack_arg_order.skel.h" 122 #include "verifier_stack_ptr.skel.h" 123 #include "verifier_store_release.skel.h" 124 #include "verifier_subprog_insn_stats.skel.h" 125 #include "verifier_subprog_precision.skel.h" 126 #include "verifier_subprog_topo.skel.h" 127 #include "verifier_subreg.skel.h" 128 #include "verifier_tailcall.skel.h" 129 #include "verifier_tailcall_jit.skel.h" 130 #include "verifier_typedef.skel.h" 131 #include "verifier_uninit.skel.h" 132 #include "verifier_unpriv.skel.h" 133 #include "verifier_unwind.skel.h" 134 #include "verifier_unpriv_perf.skel.h" 135 #include "verifier_value_adj_spill.skel.h" 136 #include "verifier_value.skel.h" 137 #include "verifier_value_illegal_alu.skel.h" 138 #include "verifier_value_or_null.skel.h" 139 #include "verifier_value_ptr_arith.skel.h" 140 #include "verifier_var_off.skel.h" 141 #include "verifier_vfs_accept.skel.h" 142 #include "verifier_vfs_reject.skel.h" 143 #include "verifier_xadd.skel.h" 144 #include "verifier_xdp.skel.h" 145 #include "verifier_xdp_direct_packet_access.skel.h" 146 #include "verifier_bits_iter.skel.h" 147 #include "verifier_set_retval.skel.h" 148 #include "verifier_lsm.skel.h" 149 #include "verifier_lsm_init_xattr.skel.h" 150 #include "verifier_jit_inline.skel.h" 151 #include "irq.skel.h" 152 #include "verifier_ctx_ptr_param.skel.h" 153 #include "verifier_zext.skel.h" 154 155 #define MAX_ENTRIES 11 156 157 struct test_val { 158 unsigned int index; 159 int foo[MAX_ENTRIES]; 160 }; 161 162 __maybe_unused 163 static void run_tests_aux(const char *skel_name, 164 skel_elf_bytes_fn elf_bytes_factory, 165 pre_execution_cb pre_execution_cb) 166 { 167 struct test_loader tester = {}; 168 __u64 old_caps; 169 int err; 170 171 /* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */ 172 err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps); 173 if (err) { 174 PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err)); 175 return; 176 } 177 178 test_loader__set_pre_execution_cb(&tester, pre_execution_cb); 179 test_loader__run_subtests(&tester, skel_name, elf_bytes_factory); 180 test_loader_fini(&tester); 181 182 err = cap_enable_effective(old_caps, NULL); 183 if (err) 184 PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err)); 185 } 186 187 #define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL) 188 189 /* for tests of what the interpreter doesn't support */ 190 #define RUN_JITED(skel) do { \ 191 if (is_jit_enabled()) \ 192 RUN(skel); \ 193 else \ 194 test__skip(); \ 195 } while (0) 196 197 void test_arena_kfunc(void) { RUN_TESTS(arena_kfunc); } 198 void test_arena_noarena(void) { RUN_TESTS(arena_noarena); } 199 200 void test_arena_kfunc_jit(void) { RUN_TESTS(arena_kfunc_jit); } 201 202 void test_cb_refs(void) { RUN_TESTS(cb_refs); } 203 204 void test_verifier_aggregate_arg(void) { RUN_TESTS(verifier_aggregate_arg); } 205 void test_verifier_aggregate_ret(void) { RUN_TESTS(verifier_aggregate_ret); } 206 void test_verifier_align(void) { RUN(verifier_align); } 207 void test_verifier_and(void) { RUN(verifier_and); } 208 void test_verifier_arena(void) { RUN(verifier_arena); } 209 void test_verifier_arena_large(void) { RUN(verifier_arena_large); } 210 void test_verifier_arena_scalar(void) { RUN(verifier_arena_scalar); } 211 void test_verifier_arena_globals1(void) { RUN(verifier_arena_globals1); } 212 void test_verifier_arena_globals2(void) { RUN(verifier_arena_globals2); } 213 void test_verifier_basic_stack(void) { RUN(verifier_basic_stack); } 214 void test_verifier_bitfield_write(void) { RUN(verifier_bitfield_write); } 215 void test_verifier_bounds(void) { RUN(verifier_bounds); } 216 void test_verifier_bounds_step(void) { RUN(verifier_bounds_step); } 217 void test_verifier_bounds_deduction(void) { RUN(verifier_bounds_deduction); } 218 void test_verifier_bounds_deduction_non_const(void) { RUN(verifier_bounds_deduction_non_const); } 219 void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); } 220 void test_verifier_bpf_get_stack(void) { RUN(verifier_bpf_get_stack); } 221 void test_verifier_bpf_trap(void) { RUN(verifier_bpf_trap); } 222 void test_verifier_bswap(void) { RUN(verifier_bswap); } 223 void test_verifier_btf_array_access(void) { RUN(verifier_btf_array_access); } 224 void test_verifier_btf_ctx_access(void) { RUN(verifier_btf_ctx_access); } 225 void test_verifier_btf_flex_array(void) { RUN(verifier_btf_flex_array); } 226 void test_verifier_btf_unreliable_prog(void) { RUN(verifier_btf_unreliable_prog); } 227 void test_verifier_call_large_imm(void) { RUN(verifier_call_large_imm); } 228 void test_verifier_callx(void) { RUN_JITED(verifier_callx); } 229 void test_verifier_callx_rodata(void) { RUN_JITED(verifier_callx_rodata); } 230 void test_verifier_cfg(void) { RUN(verifier_cfg); } 231 void test_verifier_cgroup_inv_retcode(void) { RUN(verifier_cgroup_inv_retcode); } 232 void test_verifier_cgroup_skb(void) { RUN(verifier_cgroup_skb); } 233 void test_verifier_cgroup_storage(void) { RUN(verifier_cgroup_storage); } 234 void test_verifier_const(void) { RUN(verifier_const); } 235 void test_verifier_const_or(void) { RUN(verifier_const_or); } 236 void test_verifier_ctx(void) { RUN_TESTS(verifier_ctx); } 237 void test_verifier_ctx_sk_msg(void) { RUN(verifier_ctx_sk_msg); } 238 void test_verifier_d_path(void) { RUN(verifier_d_path); } 239 void test_verifier_default_trusted_ptr(void) { RUN_TESTS(verifier_default_trusted_ptr); } 240 void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); } 241 void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); } 242 void test_verifier_div0(void) { RUN(verifier_div0); } 243 void test_verifier_div_mod_bounds(void) { RUN(verifier_div_mod_bounds); } 244 void test_verifier_div_overflow(void) { RUN(verifier_div_overflow); } 245 void test_verifier_flow_keys(void) { RUN(verifier_flow_keys); } 246 void test_verifier_global_subprogs(void) { RUN(verifier_global_subprogs); } 247 void test_verifier_global_ptr_args(void) { RUN(verifier_global_ptr_args); } 248 void test_verifier_gotol(void) { RUN(verifier_gotol); } 249 void test_verifier_gotox(void) { RUN(verifier_gotox); } 250 void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); } 251 void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); } 252 void test_verifier_helper_restricted(void) { RUN(verifier_helper_restricted); } 253 void test_verifier_helper_value_access(void) { RUN(verifier_helper_value_access); } 254 void test_verifier_idoms(void) { RUN(verifier_idoms); } 255 void test_verifier_int_ptr(void) { RUN(verifier_int_ptr); } 256 void test_verifier_iterating_callbacks(void) { RUN(verifier_iterating_callbacks); } 257 void test_verifier_jeq_infer_not_null(void) { RUN(verifier_jeq_infer_not_null); } 258 void test_verifier_jit_convergence(void) { RUN(verifier_jit_convergence); } 259 void test_verifier_kfunc_packet_access(void) { RUN_TESTS(verifier_kfunc_packet_access); } 260 void test_verifier_kfunc_uninit(void) { RUN_TESTS(verifier_kfunc_uninit); } 261 void test_verifier_kfunc_uninit_multi(void) { RUN_TESTS(verifier_kfunc_uninit_multi); } 262 void test_verifier_kfunc_perfmon(void) { RUN(verifier_kfunc_perfmon); } 263 void test_verifier_load_acquire(void) { RUN(verifier_load_acquire); } 264 void test_verifier_ld_ind(void) { RUN(verifier_ld_ind); } 265 void test_verifier_large_stack(void) { RUN(verifier_large_stack); } 266 void test_verifier_ldsx(void) { RUN(verifier_ldsx); } 267 void test_verifier_leak_ptr(void) { RUN(verifier_leak_ptr); } 268 void test_verifier_linked_scalars(void) { RUN(verifier_linked_scalars); } 269 void test_verifier_live_stack(void) { RUN(verifier_live_stack); } 270 void test_verifier_liveness_exp(void) { RUN(verifier_liveness_exp); } 271 void test_verifier_loop_hierarchy(void) { RUN(verifier_loop_hierarchy); } 272 void test_verifier_loops1(void) { RUN(verifier_loops1); } 273 void test_verifier_lwt(void) { RUN(verifier_lwt); } 274 void test_verifier_map_in_map(void) { RUN(verifier_map_in_map); } 275 void test_verifier_map_lookup_refine(void) { RUN(verifier_map_lookup_refine); } 276 void test_verifier_map_ptr(void) { RUN(verifier_map_ptr); } 277 void test_verifier_map_ptr_mixing(void) { RUN(verifier_map_ptr_mixing); } 278 void test_verifier_map_ret_val(void) { RUN(verifier_map_ret_val); } 279 void test_verifier_masking(void) { RUN(verifier_masking); } 280 void test_verifier_may_goto_1(void) { RUN(verifier_may_goto_1); } 281 void test_verifier_may_goto_2(void) { RUN(verifier_may_goto_2); } 282 void test_verifier_mem_size_reg(void) { RUN(verifier_mem_size_reg); } 283 void test_verifier_meta_access(void) { RUN(verifier_meta_access); } 284 void test_verifier_movsx(void) { RUN(verifier_movsx); } 285 void test_verifier_mul(void) { RUN(verifier_mul); } 286 void test_verifier_netfilter_ctx(void) { RUN(verifier_netfilter_ctx); } 287 void test_verifier_netfilter_retcode(void) { RUN(verifier_netfilter_retcode); } 288 void test_verifier_bpf_fastcall(void) { RUN(verifier_bpf_fastcall); } 289 void test_verifier_or_jmp32_k(void) { RUN(verifier_or_jmp32_k); } 290 void test_verifier_percpu_addr(void) { RUN(verifier_percpu_addr); } 291 void test_verifier_precision(void) { RUN(verifier_precision); } 292 void test_verifier_prevent_map_lookup(void) { RUN(verifier_prevent_map_lookup); } 293 void test_verifier_private_stack(void) { RUN(verifier_private_stack); } 294 void test_verifier_ptr_to_buf(void) { RUN(verifier_ptr_to_buf); } 295 void test_verifier_raw_stack(void) { RUN(verifier_raw_stack); } 296 void test_verifier_raw_tp_writable(void) { RUN(verifier_raw_tp_writable); } 297 void test_verifier_reg_equal(void) { RUN(verifier_reg_equal); } 298 void test_verifier_ref_tracking(void) { RUN(verifier_ref_tracking); } 299 void test_verifier_regalloc(void) { RUN(verifier_regalloc); } 300 void test_verifier_ringbuf(void) { RUN(verifier_ringbuf); } 301 void test_verifier_runtime_jit(void) { RUN(verifier_runtime_jit); } 302 void test_verifier_scalar_ids(void) { RUN(verifier_scalar_ids); } 303 void test_verifier_scev(void) { RUN(verifier_scev); } 304 void test_verifier_sdiv(void) { RUN(verifier_sdiv); } 305 void test_verifier_search_pruning(void) { RUN(verifier_search_pruning); } 306 void test_verifier_sock(void) { RUN(verifier_sock); } 307 void test_verifier_sock_addr(void) { RUN(verifier_sock_addr); } 308 void test_verifier_sockmap_mutate(void) { RUN(verifier_sockmap_mutate); } 309 void test_verifier_spill_fill(void) { RUN(verifier_spill_fill); } 310 void test_verifier_spin_lock(void) { RUN(verifier_spin_lock); } 311 void test_verifier_stack_arg(void) { RUN(verifier_stack_arg); } 312 void test_verifier_stack_arg_order(void) { RUN(verifier_stack_arg_order); } 313 void test_verifier_stack_ptr(void) { RUN(verifier_stack_ptr); } 314 void test_verifier_store_release(void) { RUN(verifier_store_release); } 315 void test_verifier_subprog_insn_stats(void) { RUN(verifier_subprog_insn_stats); } 316 void test_verifier_subprog_precision(void) { RUN(verifier_subprog_precision); } 317 void test_verifier_subprog_topo(void) { RUN(verifier_subprog_topo); } 318 void test_verifier_subreg(void) { RUN(verifier_subreg); } 319 void test_verifier_tailcall(void) { RUN(verifier_tailcall); } 320 void test_verifier_tailcall_jit(void) { RUN(verifier_tailcall_jit); } 321 void test_verifier_typedef(void) { RUN(verifier_typedef); } 322 void test_verifier_uninit(void) { RUN(verifier_uninit); } 323 void test_verifier_unpriv(void) { RUN(verifier_unpriv); } 324 void test_verifier_unwind(void) { RUN(verifier_unwind); } 325 void test_verifier_unpriv_perf(void) { RUN(verifier_unpriv_perf); } 326 void test_verifier_value_adj_spill(void) { RUN(verifier_value_adj_spill); } 327 void test_verifier_value(void) { RUN(verifier_value); } 328 void test_verifier_value_illegal_alu(void) { RUN(verifier_value_illegal_alu); } 329 void test_verifier_value_or_null(void) { RUN(verifier_value_or_null); } 330 void test_verifier_var_off(void) { RUN(verifier_var_off); } 331 void test_verifier_vfs_accept(void) { RUN(verifier_vfs_accept); } 332 void test_verifier_vfs_reject(void) { RUN(verifier_vfs_reject); } 333 void test_verifier_xadd(void) { RUN(verifier_xadd); } 334 void test_verifier_xdp(void) { RUN(verifier_xdp); } 335 void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); } 336 void test_verifier_bits_iter(void) { RUN(verifier_bits_iter); } 337 void test_verifier_set_retval(void) { RUN(verifier_set_retval); } 338 void test_verifier_lsm(void) { RUN(verifier_lsm); } 339 void test_verifier_lsm_init_xattr(void) { RUN(verifier_lsm_init_xattr); } 340 void test_irq(void) { RUN(irq); } 341 void test_verifier_mtu(void) { RUN(verifier_mtu); } 342 void test_verifier_jit_inline(void) { RUN(verifier_jit_inline); } 343 void test_verifier_ctx_ptr_param(void) { RUN(verifier_ctx_ptr_param); } 344 void test_verifier_zext(void) { RUN_TESTS(verifier_zext); } 345 346 static int init_test_val_map(struct bpf_object *obj, char *map_name) 347 { 348 struct test_val value = { 349 .index = (6 + 1) * sizeof(int), 350 .foo[6] = 0xabcdef12, 351 }; 352 struct bpf_map *map; 353 int err, key = 0; 354 355 map = bpf_object__find_map_by_name(obj, map_name); 356 if (!map) { 357 PRINT_FAIL("Can't find map '%s'\n", map_name); 358 return -EINVAL; 359 } 360 361 err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0); 362 if (err) { 363 PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err); 364 return err; 365 } 366 367 return 0; 368 } 369 370 static int init_array_access_maps(struct bpf_object *obj) 371 { 372 return init_test_val_map(obj, "map_array_ro"); 373 } 374 375 void test_verifier_array_access(void) 376 { 377 run_tests_aux("verifier_array_access", 378 verifier_array_access__elf_bytes, 379 init_array_access_maps); 380 } 381 void test_verifier_async_cb_context(void) { RUN(verifier_async_cb_context); } 382 383 static int init_value_ptr_arith_maps(struct bpf_object *obj) 384 { 385 return init_test_val_map(obj, "map_array_48b"); 386 } 387 388 void test_verifier_value_ptr_arith(void) 389 { 390 run_tests_aux("verifier_value_ptr_arith", 391 verifier_value_ptr_arith__elf_bytes, 392 init_value_ptr_arith_maps); 393 } 394