Eduard Zingerman | 5510862 | 2023-03-25 04:54:46 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
| 2 | |
| 3 | #include <test_progs.h> |
| 4 | |
| 5 | #include "cap_helpers.h" |
Eduard Zingerman | 9d0f156 | 2023-03-25 04:54:47 +0200 | [diff] [blame] | 6 | #include "verifier_and.skel.h" |
Alexei Starovoitov | 80a4129 | 2024-03-07 17:08:10 -0800 | [diff] [blame] | 7 | #include "verifier_arena.skel.h" |
Alexei Starovoitov | a90c584 | 2024-03-14 19:18:34 -0700 | [diff] [blame] | 8 | #include "verifier_arena_large.skel.h" |
Eduard Zingerman | a3c830a | 2023-03-25 04:54:48 +0200 | [diff] [blame] | 9 | #include "verifier_array_access.skel.h" |
Eduard Zingerman | 0ccbe49 | 2023-03-25 04:54:49 +0200 | [diff] [blame] | 10 | #include "verifier_basic_stack.skel.h" |
Daniel Xu | f04f2ce | 2023-12-11 13:20:09 -0700 | [diff] [blame] | 11 | #include "verifier_bitfield_write.skel.h" |
Eduard Zingerman | c923365 | 2023-04-21 20:42:12 +0300 | [diff] [blame] | 12 | #include "verifier_bounds.skel.h" |
Eduard Zingerman | 7605f94 | 2023-03-25 04:54:50 +0200 | [diff] [blame] | 13 | #include "verifier_bounds_deduction.skel.h" |
Yonghong Song | aec08d6 | 2023-04-06 09:45:00 -0700 | [diff] [blame] | 14 | #include "verifier_bounds_deduction_non_const.skel.h" |
Eduard Zingerman | b14a702 | 2023-03-25 04:54:51 +0200 | [diff] [blame] | 15 | #include "verifier_bounds_mix_sign_unsign.skel.h" |
Eduard Zingerman | 965a3f9 | 2023-04-21 20:42:13 +0300 | [diff] [blame] | 16 | #include "verifier_bpf_get_stack.skel.h" |
Yonghong Song | 79dbabc | 2023-07-27 18:13:14 -0700 | [diff] [blame] | 17 | #include "verifier_bswap.skel.h" |
Eduard Zingerman | 37467c7 | 2023-04-21 20:42:14 +0300 | [diff] [blame] | 18 | #include "verifier_btf_ctx_access.skel.h" |
Andrii Nakryiko | f0a5056 | 2023-12-14 17:13:34 -0800 | [diff] [blame] | 19 | #include "verifier_btf_unreliable_prog.skel.h" |
Eduard Zingerman | 2f2047c | 2023-03-25 04:54:52 +0200 | [diff] [blame] | 20 | #include "verifier_cfg.skel.h" |
Eduard Zingerman | 047687a | 2023-03-25 04:54:53 +0200 | [diff] [blame] | 21 | #include "verifier_cgroup_inv_retcode.skel.h" |
Eduard Zingerman | b1b6372 | 2023-03-25 04:54:54 +0200 | [diff] [blame] | 22 | #include "verifier_cgroup_skb.skel.h" |
Eduard Zingerman | 8f16f3c | 2023-03-25 04:54:55 +0200 | [diff] [blame] | 23 | #include "verifier_cgroup_storage.skel.h" |
Daniel Borkmann | 2e3f066 | 2024-09-13 21:17:53 +0200 | [diff] [blame] | 24 | #include "verifier_const.skel.h" |
Eduard Zingerman | a2777ea | 2023-03-25 04:54:56 +0200 | [diff] [blame] | 25 | #include "verifier_const_or.skel.h" |
Eduard Zingerman | fcd3696 | 2023-04-21 20:42:15 +0300 | [diff] [blame] | 26 | #include "verifier_ctx.skel.h" |
Eduard Zingerman | a58475a | 2023-03-25 04:54:57 +0200 | [diff] [blame] | 27 | #include "verifier_ctx_sk_msg.skel.h" |
Eduard Zingerman | 6080280 | 2023-04-21 20:42:16 +0300 | [diff] [blame] | 28 | #include "verifier_d_path.skel.h" |
Eduard Zingerman | 0a372c9 | 2023-04-21 20:42:17 +0300 | [diff] [blame] | 29 | #include "verifier_direct_packet_access.skel.h" |
Eduard Zingerman | 8498847 | 2023-03-25 04:54:58 +0200 | [diff] [blame] | 30 | #include "verifier_direct_stack_access_wraparound.skel.h" |
Eduard Zingerman | 01a0925 | 2023-03-25 04:54:59 +0200 | [diff] [blame] | 31 | #include "verifier_div0.skel.h" |
Eduard Zingerman | 9553de7 | 2023-03-25 04:55:00 +0200 | [diff] [blame] | 32 | #include "verifier_div_overflow.skel.h" |
Andrii Nakryiko | e8a339b | 2023-11-23 19:59:37 -0800 | [diff] [blame] | 33 | #include "verifier_global_subprogs.skel.h" |
Andrii Nakryiko | c381203 | 2024-01-29 16:06:48 -0800 | [diff] [blame] | 34 | #include "verifier_global_ptr_args.skel.h" |
Yonghong Song | 613dad4 | 2023-07-27 18:13:29 -0700 | [diff] [blame] | 35 | #include "verifier_gotol.skel.h" |
Eduard Zingerman | b37d776 | 2023-03-25 04:55:01 +0200 | [diff] [blame] | 36 | #include "verifier_helper_access_var_len.skel.h" |
Eduard Zingerman | fb179fe | 2023-03-25 04:55:02 +0200 | [diff] [blame] | 37 | #include "verifier_helper_packet_access.skel.h" |
Eduard Zingerman | 77aa256 | 2023-03-25 04:55:03 +0200 | [diff] [blame] | 38 | #include "verifier_helper_restricted.skel.h" |
Eduard Zingerman | ecc4248 | 2023-03-25 04:55:04 +0200 | [diff] [blame] | 39 | #include "verifier_helper_value_access.skel.h" |
Eduard Zingerman | 01481e6 | 2023-03-25 04:55:05 +0200 | [diff] [blame] | 40 | #include "verifier_int_ptr.skel.h" |
Eduard Zingerman | 958465e2 | 2023-11-21 04:06:57 +0200 | [diff] [blame] | 41 | #include "verifier_iterating_callbacks.skel.h" |
Eduard Zingerman | a5828e3 | 2023-04-21 20:42:18 +0300 | [diff] [blame] | 42 | #include "verifier_jeq_infer_not_null.skel.h" |
Yonghong Song | eff5b5f | 2024-09-04 15:12:56 -0700 | [diff] [blame] | 43 | #include "verifier_jit_convergence.skel.h" |
Eduard Zingerman | e297875 | 2023-03-25 04:55:06 +0200 | [diff] [blame] | 44 | #include "verifier_ld_ind.skel.h" |
Yonghong Song | 147c8f4 | 2023-07-27 18:13:04 -0700 | [diff] [blame] | 45 | #include "verifier_ldsx.skel.h" |
Eduard Zingerman | 583c7ce | 2023-03-25 04:55:07 +0200 | [diff] [blame] | 46 | #include "verifier_leak_ptr.skel.h" |
Daniel Borkmann | db123e4 | 2024-10-16 15:49:13 +0200 | [diff] [blame] | 47 | #include "verifier_linked_scalars.skel.h" |
Eduard Zingerman | a6fc14d | 2023-04-21 20:42:19 +0300 | [diff] [blame] | 48 | #include "verifier_loops1.skel.h" |
Eduard Zingerman | b427ca5 | 2023-04-21 20:42:20 +0300 | [diff] [blame] | 49 | #include "verifier_lwt.skel.h" |
Eduard Zingerman | 4a400ef | 2023-04-21 20:42:21 +0300 | [diff] [blame] | 50 | #include "verifier_map_in_map.skel.h" |
Eduard Zingerman | caf345c | 2023-03-25 04:55:08 +0200 | [diff] [blame] | 51 | #include "verifier_map_ptr.skel.h" |
Eduard Zingerman | aee1779 | 2023-04-21 20:42:22 +0300 | [diff] [blame] | 52 | #include "verifier_map_ptr_mixing.skel.h" |
Eduard Zingerman | 05e474e | 2023-03-25 04:55:09 +0200 | [diff] [blame] | 53 | #include "verifier_map_ret_val.skel.h" |
Eduard Zingerman | ade3f08 | 2023-03-25 04:55:10 +0200 | [diff] [blame] | 54 | #include "verifier_masking.skel.h" |
Eduard Zingerman | 6542831 | 2023-03-25 04:55:11 +0200 | [diff] [blame] | 55 | #include "verifier_meta_access.skel.h" |
Yonghong Song | f02ec3ff | 2023-07-27 18:13:09 -0700 | [diff] [blame] | 56 | #include "verifier_movsx.skel.h" |
Daniel Borkmann | 82bbe13 | 2024-10-21 17:28:09 +0200 | [diff] [blame] | 57 | #include "verifier_mtu.skel.h" |
Florian Westphal | 006c0e4 | 2023-04-21 19:03:00 +0200 | [diff] [blame] | 58 | #include "verifier_netfilter_ctx.skel.h" |
| 59 | #include "verifier_netfilter_retcode.skel.h" |
Eduard Zingerman | adec67d | 2024-08-22 01:41:08 -0700 | [diff] [blame] | 60 | #include "verifier_bpf_fastcall.skel.h" |
Daniel Borkmann | ceb65eb | 2024-06-13 13:53:10 +0200 | [diff] [blame] | 61 | #include "verifier_or_jmp32_k.skel.h" |
Shung-Hsi Yu | 3c41971 | 2023-11-02 13:39:05 +0800 | [diff] [blame] | 62 | #include "verifier_precision.skel.h" |
Eduard Zingerman | 3515020 | 2023-04-21 23:45:14 +0300 | [diff] [blame] | 63 | #include "verifier_prevent_map_lookup.skel.h" |
Eduard Zingerman | 5a77a01 | 2023-03-25 04:55:12 +0200 | [diff] [blame] | 64 | #include "verifier_raw_stack.skel.h" |
Eduard Zingerman | 18cdc2b | 2023-03-25 04:55:13 +0200 | [diff] [blame] | 65 | #include "verifier_raw_tp_writable.skel.h" |
Yonghong Song | 49859de | 2023-04-17 15:21:39 -0700 | [diff] [blame] | 66 | #include "verifier_reg_equal.skel.h" |
Eduard Zingerman | 8be6327 | 2023-04-21 20:42:25 +0300 | [diff] [blame] | 67 | #include "verifier_ref_tracking.skel.h" |
Eduard Zingerman | 16a4257 | 2023-04-21 20:42:26 +0300 | [diff] [blame] | 68 | #include "verifier_regalloc.skel.h" |
Eduard Zingerman | b7e4203 | 2023-03-25 04:55:14 +0200 | [diff] [blame] | 69 | #include "verifier_ringbuf.skel.h" |
Eduard Zingerman | 6522284 | 2023-04-21 20:42:27 +0300 | [diff] [blame] | 70 | #include "verifier_runtime_jit.skel.h" |
Eduard Zingerman | dec0202 | 2023-06-13 18:38:22 +0300 | [diff] [blame] | 71 | #include "verifier_scalar_ids.skel.h" |
Yonghong Song | de1c268 | 2023-07-27 18:13:21 -0700 | [diff] [blame] | 72 | #include "verifier_sdiv.skel.h" |
Eduard Zingerman | 034d9ad | 2023-04-21 20:42:28 +0300 | [diff] [blame] | 73 | #include "verifier_search_pruning.skel.h" |
Eduard Zingerman | 426fc0e | 2023-04-21 20:42:29 +0300 | [diff] [blame] | 74 | #include "verifier_sock.skel.h" |
Jordan Rife | 73964e9 | 2024-05-10 14:02:18 -0500 | [diff] [blame] | 75 | #include "verifier_sock_addr.skel.h" |
Jakub Sitnicki | a63bf55 | 2024-05-27 13:20:09 +0200 | [diff] [blame] | 76 | #include "verifier_sockmap_mutate.skel.h" |
Eduard Zingerman | f4fe3cf | 2023-03-25 04:55:15 +0200 | [diff] [blame] | 77 | #include "verifier_spill_fill.skel.h" |
Eduard Zingerman | f323a81 | 2023-04-21 20:42:30 +0300 | [diff] [blame] | 78 | #include "verifier_spin_lock.skel.h" |
Eduard Zingerman | edff37b | 2023-03-25 04:55:16 +0200 | [diff] [blame] | 79 | #include "verifier_stack_ptr.skel.h" |
Andrii Nakryiko | 3ef3d21 | 2023-05-04 21:33:16 -0700 | [diff] [blame] | 80 | #include "verifier_subprog_precision.skel.h" |
Eduard Zingerman | 81d1d6d | 2023-04-21 20:42:31 +0300 | [diff] [blame] | 81 | #include "verifier_subreg.skel.h" |
Eduard Zingerman | e5bdd6a | 2024-08-20 03:23:56 -0700 | [diff] [blame] | 82 | #include "verifier_tailcall_jit.skel.h" |
Stanislav Fomichev | 2597a25 | 2023-06-26 14:25:22 -0700 | [diff] [blame] | 83 | #include "verifier_typedef.skel.h" |
Eduard Zingerman | ab839a5 | 2023-03-25 04:55:17 +0200 | [diff] [blame] | 84 | #include "verifier_uninit.skel.h" |
Eduard Zingerman | 82887c2 | 2023-04-21 20:42:32 +0300 | [diff] [blame] | 85 | #include "verifier_unpriv.skel.h" |
| 86 | #include "verifier_unpriv_perf.skel.h" |
Eduard Zingerman | 0339149 | 2023-03-25 04:55:18 +0200 | [diff] [blame] | 87 | #include "verifier_value_adj_spill.skel.h" |
Eduard Zingerman | 8f59e87 | 2023-03-25 04:55:19 +0200 | [diff] [blame] | 88 | #include "verifier_value.skel.h" |
Eduard Zingerman | efe25a3 | 2023-04-21 20:42:33 +0300 | [diff] [blame] | 89 | #include "verifier_value_illegal_alu.skel.h" |
Eduard Zingerman | d330528 | 2023-03-25 04:55:20 +0200 | [diff] [blame] | 90 | #include "verifier_value_or_null.skel.h" |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 91 | #include "verifier_value_ptr_arith.skel.h" |
Eduard Zingerman | d15f5b6 | 2023-03-25 04:55:21 +0200 | [diff] [blame] | 92 | #include "verifier_var_off.skel.h" |
Matt Bobrowski | 2b399b9 | 2024-07-31 11:08:33 +0000 | [diff] [blame] | 93 | #include "verifier_vfs_accept.skel.h" |
Matt Bobrowski | ff358ada | 2024-07-31 11:08:32 +0000 | [diff] [blame] | 94 | #include "verifier_vfs_reject.skel.h" |
Eduard Zingerman | a8036ae | 2023-03-25 04:55:22 +0200 | [diff] [blame] | 95 | #include "verifier_xadd.skel.h" |
Eduard Zingerman | ffb515c | 2023-03-25 04:55:23 +0200 | [diff] [blame] | 96 | #include "verifier_xdp.skel.h" |
Eduard Zingerman | 6e9e141 | 2023-03-28 05:08:12 +0300 | [diff] [blame] | 97 | #include "verifier_xdp_direct_packet_access.skel.h" |
Yafang Shao | 6ba7acd | 2024-05-17 10:30:34 +0800 | [diff] [blame] | 98 | #include "verifier_bits_iter.skel.h" |
Xu Kuohai | 04d8243 | 2024-07-19 19:00:59 +0800 | [diff] [blame] | 99 | #include "verifier_lsm.skel.h" |
Eduard Zingerman | 5510862 | 2023-03-25 04:54:46 +0200 | [diff] [blame] | 100 | |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 101 | #define MAX_ENTRIES 11 |
| 102 | |
| 103 | struct test_val { |
| 104 | unsigned int index; |
| 105 | int foo[MAX_ENTRIES]; |
| 106 | }; |
| 107 | |
Eduard Zingerman | 5510862 | 2023-03-25 04:54:46 +0200 | [diff] [blame] | 108 | __maybe_unused |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 109 | static void run_tests_aux(const char *skel_name, |
| 110 | skel_elf_bytes_fn elf_bytes_factory, |
| 111 | pre_execution_cb pre_execution_cb) |
Eduard Zingerman | 5510862 | 2023-03-25 04:54:46 +0200 | [diff] [blame] | 112 | { |
| 113 | struct test_loader tester = {}; |
| 114 | __u64 old_caps; |
| 115 | int err; |
| 116 | |
| 117 | /* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */ |
| 118 | err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps); |
| 119 | if (err) { |
| 120 | PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(err)); |
| 121 | return; |
| 122 | } |
| 123 | |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 124 | test_loader__set_pre_execution_cb(&tester, pre_execution_cb); |
Eduard Zingerman | 5510862 | 2023-03-25 04:54:46 +0200 | [diff] [blame] | 125 | test_loader__run_subtests(&tester, skel_name, elf_bytes_factory); |
| 126 | test_loader_fini(&tester); |
| 127 | |
| 128 | err = cap_enable_effective(old_caps, NULL); |
| 129 | if (err) |
| 130 | PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(err)); |
| 131 | } |
| 132 | |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 133 | #define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL) |
Eduard Zingerman | 9d0f156 | 2023-03-25 04:54:47 +0200 | [diff] [blame] | 134 | |
| 135 | void test_verifier_and(void) { RUN(verifier_and); } |
Alexei Starovoitov | 80a4129 | 2024-03-07 17:08:10 -0800 | [diff] [blame] | 136 | void test_verifier_arena(void) { RUN(verifier_arena); } |
Alexei Starovoitov | a90c584 | 2024-03-14 19:18:34 -0700 | [diff] [blame] | 137 | void test_verifier_arena_large(void) { RUN(verifier_arena_large); } |
Eduard Zingerman | 0ccbe49 | 2023-03-25 04:54:49 +0200 | [diff] [blame] | 138 | void test_verifier_basic_stack(void) { RUN(verifier_basic_stack); } |
Daniel Xu | f04f2ce | 2023-12-11 13:20:09 -0700 | [diff] [blame] | 139 | void test_verifier_bitfield_write(void) { RUN(verifier_bitfield_write); } |
Eduard Zingerman | c923365 | 2023-04-21 20:42:12 +0300 | [diff] [blame] | 140 | void test_verifier_bounds(void) { RUN(verifier_bounds); } |
Eduard Zingerman | 7605f94 | 2023-03-25 04:54:50 +0200 | [diff] [blame] | 141 | void test_verifier_bounds_deduction(void) { RUN(verifier_bounds_deduction); } |
Yonghong Song | aec08d6 | 2023-04-06 09:45:00 -0700 | [diff] [blame] | 142 | void test_verifier_bounds_deduction_non_const(void) { RUN(verifier_bounds_deduction_non_const); } |
Eduard Zingerman | b14a702 | 2023-03-25 04:54:51 +0200 | [diff] [blame] | 143 | void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); } |
Eduard Zingerman | 965a3f9 | 2023-04-21 20:42:13 +0300 | [diff] [blame] | 144 | void test_verifier_bpf_get_stack(void) { RUN(verifier_bpf_get_stack); } |
Yonghong Song | 79dbabc | 2023-07-27 18:13:14 -0700 | [diff] [blame] | 145 | void test_verifier_bswap(void) { RUN(verifier_bswap); } |
Eduard Zingerman | 37467c7 | 2023-04-21 20:42:14 +0300 | [diff] [blame] | 146 | void test_verifier_btf_ctx_access(void) { RUN(verifier_btf_ctx_access); } |
Andrii Nakryiko | f0a5056 | 2023-12-14 17:13:34 -0800 | [diff] [blame] | 147 | void test_verifier_btf_unreliable_prog(void) { RUN(verifier_btf_unreliable_prog); } |
Eduard Zingerman | 2f2047c | 2023-03-25 04:54:52 +0200 | [diff] [blame] | 148 | void test_verifier_cfg(void) { RUN(verifier_cfg); } |
Eduard Zingerman | 047687a | 2023-03-25 04:54:53 +0200 | [diff] [blame] | 149 | void test_verifier_cgroup_inv_retcode(void) { RUN(verifier_cgroup_inv_retcode); } |
Eduard Zingerman | b1b6372 | 2023-03-25 04:54:54 +0200 | [diff] [blame] | 150 | void test_verifier_cgroup_skb(void) { RUN(verifier_cgroup_skb); } |
Eduard Zingerman | 8f16f3c | 2023-03-25 04:54:55 +0200 | [diff] [blame] | 151 | void test_verifier_cgroup_storage(void) { RUN(verifier_cgroup_storage); } |
Daniel Borkmann | 2e3f066 | 2024-09-13 21:17:53 +0200 | [diff] [blame] | 152 | void test_verifier_const(void) { RUN(verifier_const); } |
Eduard Zingerman | a2777ea | 2023-03-25 04:54:56 +0200 | [diff] [blame] | 153 | void test_verifier_const_or(void) { RUN(verifier_const_or); } |
Eduard Zingerman | fcd3696 | 2023-04-21 20:42:15 +0300 | [diff] [blame] | 154 | void test_verifier_ctx(void) { RUN(verifier_ctx); } |
Eduard Zingerman | a58475a | 2023-03-25 04:54:57 +0200 | [diff] [blame] | 155 | void test_verifier_ctx_sk_msg(void) { RUN(verifier_ctx_sk_msg); } |
Eduard Zingerman | 6080280 | 2023-04-21 20:42:16 +0300 | [diff] [blame] | 156 | void test_verifier_d_path(void) { RUN(verifier_d_path); } |
Eduard Zingerman | 0a372c9 | 2023-04-21 20:42:17 +0300 | [diff] [blame] | 157 | void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); } |
Eduard Zingerman | 8498847 | 2023-03-25 04:54:58 +0200 | [diff] [blame] | 158 | void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); } |
Eduard Zingerman | 01a0925 | 2023-03-25 04:54:59 +0200 | [diff] [blame] | 159 | void test_verifier_div0(void) { RUN(verifier_div0); } |
Eduard Zingerman | 9553de7 | 2023-03-25 04:55:00 +0200 | [diff] [blame] | 160 | void test_verifier_div_overflow(void) { RUN(verifier_div_overflow); } |
Andrii Nakryiko | e8a339b | 2023-11-23 19:59:37 -0800 | [diff] [blame] | 161 | void test_verifier_global_subprogs(void) { RUN(verifier_global_subprogs); } |
Andrii Nakryiko | c381203 | 2024-01-29 16:06:48 -0800 | [diff] [blame] | 162 | void test_verifier_global_ptr_args(void) { RUN(verifier_global_ptr_args); } |
Yonghong Song | 613dad4 | 2023-07-27 18:13:29 -0700 | [diff] [blame] | 163 | void test_verifier_gotol(void) { RUN(verifier_gotol); } |
Eduard Zingerman | b37d776 | 2023-03-25 04:55:01 +0200 | [diff] [blame] | 164 | void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); } |
Eduard Zingerman | fb179fe | 2023-03-25 04:55:02 +0200 | [diff] [blame] | 165 | void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); } |
Eduard Zingerman | 77aa256 | 2023-03-25 04:55:03 +0200 | [diff] [blame] | 166 | void test_verifier_helper_restricted(void) { RUN(verifier_helper_restricted); } |
Eduard Zingerman | ecc4248 | 2023-03-25 04:55:04 +0200 | [diff] [blame] | 167 | void test_verifier_helper_value_access(void) { RUN(verifier_helper_value_access); } |
Eduard Zingerman | 01481e6 | 2023-03-25 04:55:05 +0200 | [diff] [blame] | 168 | void test_verifier_int_ptr(void) { RUN(verifier_int_ptr); } |
Eduard Zingerman | 958465e2 | 2023-11-21 04:06:57 +0200 | [diff] [blame] | 169 | void test_verifier_iterating_callbacks(void) { RUN(verifier_iterating_callbacks); } |
Eduard Zingerman | a5828e3 | 2023-04-21 20:42:18 +0300 | [diff] [blame] | 170 | void test_verifier_jeq_infer_not_null(void) { RUN(verifier_jeq_infer_not_null); } |
Yonghong Song | eff5b5f | 2024-09-04 15:12:56 -0700 | [diff] [blame] | 171 | void test_verifier_jit_convergence(void) { RUN(verifier_jit_convergence); } |
Eduard Zingerman | e297875 | 2023-03-25 04:55:06 +0200 | [diff] [blame] | 172 | void test_verifier_ld_ind(void) { RUN(verifier_ld_ind); } |
Yonghong Song | 147c8f4 | 2023-07-27 18:13:04 -0700 | [diff] [blame] | 173 | void test_verifier_ldsx(void) { RUN(verifier_ldsx); } |
Eduard Zingerman | 583c7ce | 2023-03-25 04:55:07 +0200 | [diff] [blame] | 174 | void test_verifier_leak_ptr(void) { RUN(verifier_leak_ptr); } |
Daniel Borkmann | db123e4 | 2024-10-16 15:49:13 +0200 | [diff] [blame] | 175 | void test_verifier_linked_scalars(void) { RUN(verifier_linked_scalars); } |
Eduard Zingerman | a6fc14d | 2023-04-21 20:42:19 +0300 | [diff] [blame] | 176 | void test_verifier_loops1(void) { RUN(verifier_loops1); } |
Eduard Zingerman | b427ca5 | 2023-04-21 20:42:20 +0300 | [diff] [blame] | 177 | void test_verifier_lwt(void) { RUN(verifier_lwt); } |
Eduard Zingerman | 4a400ef | 2023-04-21 20:42:21 +0300 | [diff] [blame] | 178 | void test_verifier_map_in_map(void) { RUN(verifier_map_in_map); } |
Eduard Zingerman | caf345c | 2023-03-25 04:55:08 +0200 | [diff] [blame] | 179 | void test_verifier_map_ptr(void) { RUN(verifier_map_ptr); } |
Eduard Zingerman | aee1779 | 2023-04-21 20:42:22 +0300 | [diff] [blame] | 180 | void test_verifier_map_ptr_mixing(void) { RUN(verifier_map_ptr_mixing); } |
Eduard Zingerman | 05e474e | 2023-03-25 04:55:09 +0200 | [diff] [blame] | 181 | void test_verifier_map_ret_val(void) { RUN(verifier_map_ret_val); } |
Eduard Zingerman | ade3f08 | 2023-03-25 04:55:10 +0200 | [diff] [blame] | 182 | void test_verifier_masking(void) { RUN(verifier_masking); } |
Eduard Zingerman | 6542831 | 2023-03-25 04:55:11 +0200 | [diff] [blame] | 183 | void test_verifier_meta_access(void) { RUN(verifier_meta_access); } |
Yonghong Song | f02ec3ff | 2023-07-27 18:13:09 -0700 | [diff] [blame] | 184 | void test_verifier_movsx(void) { RUN(verifier_movsx); } |
Florian Westphal | 006c0e4 | 2023-04-21 19:03:00 +0200 | [diff] [blame] | 185 | void test_verifier_netfilter_ctx(void) { RUN(verifier_netfilter_ctx); } |
| 186 | void test_verifier_netfilter_retcode(void) { RUN(verifier_netfilter_retcode); } |
Eduard Zingerman | adec67d | 2024-08-22 01:41:08 -0700 | [diff] [blame] | 187 | void test_verifier_bpf_fastcall(void) { RUN(verifier_bpf_fastcall); } |
Daniel Borkmann | ceb65eb | 2024-06-13 13:53:10 +0200 | [diff] [blame] | 188 | void test_verifier_or_jmp32_k(void) { RUN(verifier_or_jmp32_k); } |
Shung-Hsi Yu | 3c41971 | 2023-11-02 13:39:05 +0800 | [diff] [blame] | 189 | void test_verifier_precision(void) { RUN(verifier_precision); } |
Eduard Zingerman | 3515020 | 2023-04-21 23:45:14 +0300 | [diff] [blame] | 190 | void test_verifier_prevent_map_lookup(void) { RUN(verifier_prevent_map_lookup); } |
Eduard Zingerman | 5a77a01 | 2023-03-25 04:55:12 +0200 | [diff] [blame] | 191 | void test_verifier_raw_stack(void) { RUN(verifier_raw_stack); } |
Eduard Zingerman | 18cdc2b | 2023-03-25 04:55:13 +0200 | [diff] [blame] | 192 | void test_verifier_raw_tp_writable(void) { RUN(verifier_raw_tp_writable); } |
Yonghong Song | 49859de | 2023-04-17 15:21:39 -0700 | [diff] [blame] | 193 | void test_verifier_reg_equal(void) { RUN(verifier_reg_equal); } |
Eduard Zingerman | 8be6327 | 2023-04-21 20:42:25 +0300 | [diff] [blame] | 194 | void test_verifier_ref_tracking(void) { RUN(verifier_ref_tracking); } |
Eduard Zingerman | 16a4257 | 2023-04-21 20:42:26 +0300 | [diff] [blame] | 195 | void test_verifier_regalloc(void) { RUN(verifier_regalloc); } |
Eduard Zingerman | b7e4203 | 2023-03-25 04:55:14 +0200 | [diff] [blame] | 196 | void test_verifier_ringbuf(void) { RUN(verifier_ringbuf); } |
Eduard Zingerman | 6522284 | 2023-04-21 20:42:27 +0300 | [diff] [blame] | 197 | void test_verifier_runtime_jit(void) { RUN(verifier_runtime_jit); } |
Eduard Zingerman | dec0202 | 2023-06-13 18:38:22 +0300 | [diff] [blame] | 198 | void test_verifier_scalar_ids(void) { RUN(verifier_scalar_ids); } |
Yonghong Song | de1c268 | 2023-07-27 18:13:21 -0700 | [diff] [blame] | 199 | void test_verifier_sdiv(void) { RUN(verifier_sdiv); } |
Eduard Zingerman | 034d9ad | 2023-04-21 20:42:28 +0300 | [diff] [blame] | 200 | void test_verifier_search_pruning(void) { RUN(verifier_search_pruning); } |
Eduard Zingerman | 426fc0e | 2023-04-21 20:42:29 +0300 | [diff] [blame] | 201 | void test_verifier_sock(void) { RUN(verifier_sock); } |
Jordan Rife | 73964e9 | 2024-05-10 14:02:18 -0500 | [diff] [blame] | 202 | void test_verifier_sock_addr(void) { RUN(verifier_sock_addr); } |
Jakub Sitnicki | a63bf55 | 2024-05-27 13:20:09 +0200 | [diff] [blame] | 203 | void test_verifier_sockmap_mutate(void) { RUN(verifier_sockmap_mutate); } |
Eduard Zingerman | f4fe3cf | 2023-03-25 04:55:15 +0200 | [diff] [blame] | 204 | void test_verifier_spill_fill(void) { RUN(verifier_spill_fill); } |
Eduard Zingerman | f323a81 | 2023-04-21 20:42:30 +0300 | [diff] [blame] | 205 | void test_verifier_spin_lock(void) { RUN(verifier_spin_lock); } |
Eduard Zingerman | edff37b | 2023-03-25 04:55:16 +0200 | [diff] [blame] | 206 | void test_verifier_stack_ptr(void) { RUN(verifier_stack_ptr); } |
Andrii Nakryiko | 3ef3d21 | 2023-05-04 21:33:16 -0700 | [diff] [blame] | 207 | void test_verifier_subprog_precision(void) { RUN(verifier_subprog_precision); } |
Eduard Zingerman | 81d1d6d | 2023-04-21 20:42:31 +0300 | [diff] [blame] | 208 | void test_verifier_subreg(void) { RUN(verifier_subreg); } |
Eduard Zingerman | e5bdd6a | 2024-08-20 03:23:56 -0700 | [diff] [blame] | 209 | void test_verifier_tailcall_jit(void) { RUN(verifier_tailcall_jit); } |
Stanislav Fomichev | 2597a25 | 2023-06-26 14:25:22 -0700 | [diff] [blame] | 210 | void test_verifier_typedef(void) { RUN(verifier_typedef); } |
Eduard Zingerman | ab839a5 | 2023-03-25 04:55:17 +0200 | [diff] [blame] | 211 | void test_verifier_uninit(void) { RUN(verifier_uninit); } |
Eduard Zingerman | 82887c2 | 2023-04-21 20:42:32 +0300 | [diff] [blame] | 212 | void test_verifier_unpriv(void) { RUN(verifier_unpriv); } |
| 213 | void test_verifier_unpriv_perf(void) { RUN(verifier_unpriv_perf); } |
Eduard Zingerman | 0339149 | 2023-03-25 04:55:18 +0200 | [diff] [blame] | 214 | void test_verifier_value_adj_spill(void) { RUN(verifier_value_adj_spill); } |
Eduard Zingerman | 8f59e87 | 2023-03-25 04:55:19 +0200 | [diff] [blame] | 215 | void test_verifier_value(void) { RUN(verifier_value); } |
Eduard Zingerman | efe25a3 | 2023-04-21 20:42:33 +0300 | [diff] [blame] | 216 | void test_verifier_value_illegal_alu(void) { RUN(verifier_value_illegal_alu); } |
Eduard Zingerman | d330528 | 2023-03-25 04:55:20 +0200 | [diff] [blame] | 217 | void test_verifier_value_or_null(void) { RUN(verifier_value_or_null); } |
Eduard Zingerman | d15f5b6 | 2023-03-25 04:55:21 +0200 | [diff] [blame] | 218 | void test_verifier_var_off(void) { RUN(verifier_var_off); } |
Matt Bobrowski | 2b399b9 | 2024-07-31 11:08:33 +0000 | [diff] [blame] | 219 | void test_verifier_vfs_accept(void) { RUN(verifier_vfs_accept); } |
Matt Bobrowski | ff358ada | 2024-07-31 11:08:32 +0000 | [diff] [blame] | 220 | void test_verifier_vfs_reject(void) { RUN(verifier_vfs_reject); } |
Eduard Zingerman | a8036ae | 2023-03-25 04:55:22 +0200 | [diff] [blame] | 221 | void test_verifier_xadd(void) { RUN(verifier_xadd); } |
Eduard Zingerman | ffb515c | 2023-03-25 04:55:23 +0200 | [diff] [blame] | 222 | void test_verifier_xdp(void) { RUN(verifier_xdp); } |
Eduard Zingerman | 6e9e141 | 2023-03-28 05:08:12 +0300 | [diff] [blame] | 223 | void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); } |
Yafang Shao | 6ba7acd | 2024-05-17 10:30:34 +0800 | [diff] [blame] | 224 | void test_verifier_bits_iter(void) { RUN(verifier_bits_iter); } |
Xu Kuohai | 04d8243 | 2024-07-19 19:00:59 +0800 | [diff] [blame] | 225 | void test_verifier_lsm(void) { RUN(verifier_lsm); } |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 226 | |
Daniel Borkmann | 82bbe13 | 2024-10-21 17:28:09 +0200 | [diff] [blame] | 227 | void test_verifier_mtu(void) |
| 228 | { |
| 229 | __u64 caps = 0; |
| 230 | int ret; |
| 231 | |
| 232 | /* In case CAP_BPF and CAP_PERFMON is not set */ |
| 233 | ret = cap_enable_effective(1ULL << CAP_BPF | 1ULL << CAP_NET_ADMIN, &caps); |
| 234 | if (!ASSERT_OK(ret, "set_cap_bpf_cap_net_admin")) |
| 235 | return; |
| 236 | ret = cap_disable_effective(1ULL << CAP_SYS_ADMIN | 1ULL << CAP_PERFMON, NULL); |
| 237 | if (!ASSERT_OK(ret, "disable_cap_sys_admin")) |
| 238 | goto restore_cap; |
| 239 | RUN(verifier_mtu); |
| 240 | restore_cap: |
| 241 | if (caps) |
| 242 | cap_enable_effective(caps, NULL); |
| 243 | } |
| 244 | |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 245 | static int init_test_val_map(struct bpf_object *obj, char *map_name) |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 246 | { |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 247 | struct test_val value = { |
| 248 | .index = (6 + 1) * sizeof(int), |
| 249 | .foo[6] = 0xabcdef12, |
| 250 | }; |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 251 | struct bpf_map *map; |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 252 | int err, key = 0; |
| 253 | |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 254 | map = bpf_object__find_map_by_name(obj, map_name); |
| 255 | if (!map) { |
| 256 | PRINT_FAIL("Can't find map '%s'\n", map_name); |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 257 | return -EINVAL; |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 258 | } |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 259 | |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 260 | err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0); |
| 261 | if (err) { |
| 262 | PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err); |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 263 | return err; |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 264 | } |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 265 | |
| 266 | return 0; |
| 267 | } |
| 268 | |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 269 | static int init_array_access_maps(struct bpf_object *obj) |
| 270 | { |
| 271 | return init_test_val_map(obj, "map_array_ro"); |
| 272 | } |
| 273 | |
Eduard Zingerman | cbb110b | 2023-04-21 02:23:17 +0300 | [diff] [blame] | 274 | void test_verifier_array_access(void) |
| 275 | { |
| 276 | run_tests_aux("verifier_array_access", |
| 277 | verifier_array_access__elf_bytes, |
| 278 | init_array_access_maps); |
| 279 | } |
Eduard Zingerman | 4db10a824 | 2023-04-21 20:42:34 +0300 | [diff] [blame] | 280 | |
| 281 | static int init_value_ptr_arith_maps(struct bpf_object *obj) |
| 282 | { |
| 283 | return init_test_val_map(obj, "map_array_48b"); |
| 284 | } |
| 285 | |
| 286 | void test_verifier_value_ptr_arith(void) |
| 287 | { |
| 288 | run_tests_aux("verifier_value_ptr_arith", |
| 289 | verifier_value_ptr_arith__elf_bytes, |
| 290 | init_value_ptr_arith_maps); |
| 291 | } |