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