1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 #include <test_progs.h>
4 
5 #include "cap_helpers.h"
6 #include "verifier_and.skel.h"
7 #include "verifier_array_access.skel.h"
8 #include "verifier_basic_stack.skel.h"
9 #include "verifier_bounds.skel.h"
10 #include "verifier_bounds_deduction.skel.h"
11 #include "verifier_bounds_deduction_non_const.skel.h"
12 #include "verifier_bounds_mix_sign_unsign.skel.h"
13 #include "verifier_bpf_get_stack.skel.h"
14 #include "verifier_btf_ctx_access.skel.h"
15 #include "verifier_cfg.skel.h"
16 #include "verifier_cgroup_inv_retcode.skel.h"
17 #include "verifier_cgroup_skb.skel.h"
18 #include "verifier_cgroup_storage.skel.h"
19 #include "verifier_const_or.skel.h"
20 #include "verifier_ctx.skel.h"
21 #include "verifier_ctx_sk_msg.skel.h"
22 #include "verifier_d_path.skel.h"
23 #include "verifier_direct_packet_access.skel.h"
24 #include "verifier_direct_stack_access_wraparound.skel.h"
25 #include "verifier_div0.skel.h"
26 #include "verifier_div_overflow.skel.h"
27 #include "verifier_helper_access_var_len.skel.h"
28 #include "verifier_helper_packet_access.skel.h"
29 #include "verifier_helper_restricted.skel.h"
30 #include "verifier_helper_value_access.skel.h"
31 #include "verifier_int_ptr.skel.h"
32 #include "verifier_jeq_infer_not_null.skel.h"
33 #include "verifier_ld_ind.skel.h"
34 #include "verifier_leak_ptr.skel.h"
35 #include "verifier_loops1.skel.h"
36 #include "verifier_lwt.skel.h"
37 #include "verifier_map_in_map.skel.h"
38 #include "verifier_map_ptr.skel.h"
39 #include "verifier_map_ptr_mixing.skel.h"
40 #include "verifier_map_ret_val.skel.h"
41 #include "verifier_masking.skel.h"
42 #include "verifier_meta_access.skel.h"
43 #include "verifier_netfilter_ctx.skel.h"
44 #include "verifier_netfilter_retcode.skel.h"
45 #include "verifier_prevent_map_lookup.skel.h"
46 #include "verifier_raw_stack.skel.h"
47 #include "verifier_raw_tp_writable.skel.h"
48 #include "verifier_reg_equal.skel.h"
49 #include "verifier_ref_tracking.skel.h"
50 #include "verifier_regalloc.skel.h"
51 #include "verifier_ringbuf.skel.h"
52 #include "verifier_runtime_jit.skel.h"
53 #include "verifier_search_pruning.skel.h"
54 #include "verifier_sock.skel.h"
55 #include "verifier_spill_fill.skel.h"
56 #include "verifier_spin_lock.skel.h"
57 #include "verifier_stack_ptr.skel.h"
58 #include "verifier_subreg.skel.h"
59 #include "verifier_uninit.skel.h"
60 #include "verifier_unpriv.skel.h"
61 #include "verifier_unpriv_perf.skel.h"
62 #include "verifier_value_adj_spill.skel.h"
63 #include "verifier_value.skel.h"
64 #include "verifier_value_illegal_alu.skel.h"
65 #include "verifier_value_or_null.skel.h"
66 #include "verifier_value_ptr_arith.skel.h"
67 #include "verifier_var_off.skel.h"
68 #include "verifier_xadd.skel.h"
69 #include "verifier_xdp.skel.h"
70 #include "verifier_xdp_direct_packet_access.skel.h"
71 
72 #define MAX_ENTRIES 11
73 
74 struct test_val {
75 	unsigned int index;
76 	int foo[MAX_ENTRIES];
77 };
78 
79 __maybe_unused
80 static void run_tests_aux(const char *skel_name,
81 			  skel_elf_bytes_fn elf_bytes_factory,
82 			  pre_execution_cb pre_execution_cb)
83 {
84 	struct test_loader tester = {};
85 	__u64 old_caps;
86 	int err;
87 
88 	/* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
89 	err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
90 	if (err) {
91 		PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
92 		return;
93 	}
94 
95 	test_loader__set_pre_execution_cb(&tester, pre_execution_cb);
96 	test_loader__run_subtests(&tester, skel_name, elf_bytes_factory);
97 	test_loader_fini(&tester);
98 
99 	err = cap_enable_effective(old_caps, NULL);
100 	if (err)
101 		PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
102 }
103 
104 #define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)
105 
106 void test_verifier_and(void)                  { RUN(verifier_and); }
107 void test_verifier_basic_stack(void)          { RUN(verifier_basic_stack); }
108 void test_verifier_bounds(void)               { RUN(verifier_bounds); }
109 void test_verifier_bounds_deduction(void)     { RUN(verifier_bounds_deduction); }
110 void test_verifier_bounds_deduction_non_const(void)     { RUN(verifier_bounds_deduction_non_const); }
111 void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); }
112 void test_verifier_bpf_get_stack(void)        { RUN(verifier_bpf_get_stack); }
113 void test_verifier_btf_ctx_access(void)       { RUN(verifier_btf_ctx_access); }
114 void test_verifier_cfg(void)                  { RUN(verifier_cfg); }
115 void test_verifier_cgroup_inv_retcode(void)   { RUN(verifier_cgroup_inv_retcode); }
116 void test_verifier_cgroup_skb(void)           { RUN(verifier_cgroup_skb); }
117 void test_verifier_cgroup_storage(void)       { RUN(verifier_cgroup_storage); }
118 void test_verifier_const_or(void)             { RUN(verifier_const_or); }
119 void test_verifier_ctx(void)                  { RUN(verifier_ctx); }
120 void test_verifier_ctx_sk_msg(void)           { RUN(verifier_ctx_sk_msg); }
121 void test_verifier_d_path(void)               { RUN(verifier_d_path); }
122 void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); }
123 void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); }
124 void test_verifier_div0(void)                 { RUN(verifier_div0); }
125 void test_verifier_div_overflow(void)         { RUN(verifier_div_overflow); }
126 void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); }
127 void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); }
128 void test_verifier_helper_restricted(void)    { RUN(verifier_helper_restricted); }
129 void test_verifier_helper_value_access(void)  { RUN(verifier_helper_value_access); }
130 void test_verifier_int_ptr(void)              { RUN(verifier_int_ptr); }
131 void test_verifier_jeq_infer_not_null(void)   { RUN(verifier_jeq_infer_not_null); }
132 void test_verifier_ld_ind(void)               { RUN(verifier_ld_ind); }
133 void test_verifier_leak_ptr(void)             { RUN(verifier_leak_ptr); }
134 void test_verifier_loops1(void)               { RUN(verifier_loops1); }
135 void test_verifier_lwt(void)                  { RUN(verifier_lwt); }
136 void test_verifier_map_in_map(void)           { RUN(verifier_map_in_map); }
137 void test_verifier_map_ptr(void)              { RUN(verifier_map_ptr); }
138 void test_verifier_map_ptr_mixing(void)       { RUN(verifier_map_ptr_mixing); }
139 void test_verifier_map_ret_val(void)          { RUN(verifier_map_ret_val); }
140 void test_verifier_masking(void)              { RUN(verifier_masking); }
141 void test_verifier_meta_access(void)          { RUN(verifier_meta_access); }
142 void test_verifier_netfilter_ctx(void)        { RUN(verifier_netfilter_ctx); }
143 void test_verifier_netfilter_retcode(void)    { RUN(verifier_netfilter_retcode); }
144 void test_verifier_prevent_map_lookup(void)   { RUN(verifier_prevent_map_lookup); }
145 void test_verifier_raw_stack(void)            { RUN(verifier_raw_stack); }
146 void test_verifier_raw_tp_writable(void)      { RUN(verifier_raw_tp_writable); }
147 void test_verifier_reg_equal(void)            { RUN(verifier_reg_equal); }
148 void test_verifier_ref_tracking(void)         { RUN(verifier_ref_tracking); }
149 void test_verifier_regalloc(void)             { RUN(verifier_regalloc); }
150 void test_verifier_ringbuf(void)              { RUN(verifier_ringbuf); }
151 void test_verifier_runtime_jit(void)          { RUN(verifier_runtime_jit); }
152 void test_verifier_search_pruning(void)       { RUN(verifier_search_pruning); }
153 void test_verifier_sock(void)                 { RUN(verifier_sock); }
154 void test_verifier_spill_fill(void)           { RUN(verifier_spill_fill); }
155 void test_verifier_spin_lock(void)            { RUN(verifier_spin_lock); }
156 void test_verifier_stack_ptr(void)            { RUN(verifier_stack_ptr); }
157 void test_verifier_subreg(void)               { RUN(verifier_subreg); }
158 void test_verifier_uninit(void)               { RUN(verifier_uninit); }
159 void test_verifier_unpriv(void)               { RUN(verifier_unpriv); }
160 void test_verifier_unpriv_perf(void)          { RUN(verifier_unpriv_perf); }
161 void test_verifier_value_adj_spill(void)      { RUN(verifier_value_adj_spill); }
162 void test_verifier_value(void)                { RUN(verifier_value); }
163 void test_verifier_value_illegal_alu(void)    { RUN(verifier_value_illegal_alu); }
164 void test_verifier_value_or_null(void)        { RUN(verifier_value_or_null); }
165 void test_verifier_var_off(void)              { RUN(verifier_var_off); }
166 void test_verifier_xadd(void)                 { RUN(verifier_xadd); }
167 void test_verifier_xdp(void)                  { RUN(verifier_xdp); }
168 void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); }
169 
170 static int init_test_val_map(struct bpf_object *obj, char *map_name)
171 {
172 	struct test_val value = {
173 		.index = (6 + 1) * sizeof(int),
174 		.foo[6] = 0xabcdef12,
175 	};
176 	struct bpf_map *map;
177 	int err, key = 0;
178 
179 	map = bpf_object__find_map_by_name(obj, map_name);
180 	if (!map) {
181 		PRINT_FAIL("Can't find map '%s'\n", map_name);
182 		return -EINVAL;
183 	}
184 
185 	err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0);
186 	if (err) {
187 		PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err);
188 		return err;
189 	}
190 
191 	return 0;
192 }
193 
194 static int init_array_access_maps(struct bpf_object *obj)
195 {
196 	return init_test_val_map(obj, "map_array_ro");
197 }
198 
199 void test_verifier_array_access(void)
200 {
201 	run_tests_aux("verifier_array_access",
202 		      verifier_array_access__elf_bytes,
203 		      init_array_access_maps);
204 }
205 
206 static int init_value_ptr_arith_maps(struct bpf_object *obj)
207 {
208 	return init_test_val_map(obj, "map_array_48b");
209 }
210 
211 void test_verifier_value_ptr_arith(void)
212 {
213 	run_tests_aux("verifier_value_ptr_arith",
214 		      verifier_value_ptr_arith__elf_bytes,
215 		      init_value_ptr_arith_maps);
216 }
217