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