[linux-block.git] / tools / testing / selftests / bpf / prog_tests / verifier.c

// SPDX-License-Identifier: GPL-2.0-only

#include <test_progs.h>

#include "cap_helpers.h"
#include "verifier_and.skel.h"
#include "verifier_arena.skel.h"
#include "verifier_array_access.skel.h"
#include "verifier_basic_stack.skel.h"
#include "verifier_bitfield_write.skel.h"
#include "verifier_bounds.skel.h"
#include "verifier_bounds_deduction.skel.h"
#include "verifier_bounds_deduction_non_const.skel.h"
#include "verifier_bounds_mix_sign_unsign.skel.h"
#include "verifier_bpf_get_stack.skel.h"
#include "verifier_bswap.skel.h"
#include "verifier_btf_ctx_access.skel.h"
#include "verifier_btf_unreliable_prog.skel.h"
#include "verifier_cfg.skel.h"
#include "verifier_cgroup_inv_retcode.skel.h"
#include "verifier_cgroup_skb.skel.h"
#include "verifier_cgroup_storage.skel.h"
#include "verifier_const_or.skel.h"
#include "verifier_ctx.skel.h"
#include "verifier_ctx_sk_msg.skel.h"
#include "verifier_d_path.skel.h"
#include "verifier_direct_packet_access.skel.h"
#include "verifier_direct_stack_access_wraparound.skel.h"
#include "verifier_div0.skel.h"
#include "verifier_div_overflow.skel.h"
#include "verifier_global_subprogs.skel.h"
#include "verifier_global_ptr_args.skel.h"
#include "verifier_gotol.skel.h"
#include "verifier_helper_access_var_len.skel.h"
#include "verifier_helper_packet_access.skel.h"
#include "verifier_helper_restricted.skel.h"
#include "verifier_helper_value_access.skel.h"
#include "verifier_int_ptr.skel.h"
#include "verifier_iterating_callbacks.skel.h"
#include "verifier_jeq_infer_not_null.skel.h"
#include "verifier_ld_ind.skel.h"
#include "verifier_ldsx.skel.h"
#include "verifier_leak_ptr.skel.h"
#include "verifier_loops1.skel.h"
#include "verifier_lwt.skel.h"
#include "verifier_map_in_map.skel.h"
#include "verifier_map_ptr.skel.h"
#include "verifier_map_ptr_mixing.skel.h"
#include "verifier_map_ret_val.skel.h"
#include "verifier_masking.skel.h"
#include "verifier_meta_access.skel.h"
#include "verifier_movsx.skel.h"
#include "verifier_netfilter_ctx.skel.h"
#include "verifier_netfilter_retcode.skel.h"
#include "verifier_precision.skel.h"
#include "verifier_prevent_map_lookup.skel.h"
#include "verifier_raw_stack.skel.h"
#include "verifier_raw_tp_writable.skel.h"
#include "verifier_reg_equal.skel.h"
#include "verifier_ref_tracking.skel.h"
#include "verifier_regalloc.skel.h"
#include "verifier_ringbuf.skel.h"
#include "verifier_runtime_jit.skel.h"
#include "verifier_scalar_ids.skel.h"
#include "verifier_sdiv.skel.h"
#include "verifier_search_pruning.skel.h"
#include "verifier_sock.skel.h"
#include "verifier_spill_fill.skel.h"
#include "verifier_spin_lock.skel.h"
#include "verifier_stack_ptr.skel.h"
#include "verifier_subprog_precision.skel.h"
#include "verifier_subreg.skel.h"
#include "verifier_typedef.skel.h"
#include "verifier_uninit.skel.h"
#include "verifier_unpriv.skel.h"
#include "verifier_unpriv_perf.skel.h"
#include "verifier_value_adj_spill.skel.h"
#include "verifier_value.skel.h"
#include "verifier_value_illegal_alu.skel.h"
#include "verifier_value_or_null.skel.h"
#include "verifier_value_ptr_arith.skel.h"
#include "verifier_var_off.skel.h"
#include "verifier_xadd.skel.h"
#include "verifier_xdp.skel.h"
#include "verifier_xdp_direct_packet_access.skel.h"

#define MAX_ENTRIES 11

struct test_val {
	unsigned int index;
	int foo[MAX_ENTRIES];
};

__maybe_unused
static void run_tests_aux(const char *skel_name,
			  skel_elf_bytes_fn elf_bytes_factory,
			  pre_execution_cb pre_execution_cb)
{
	struct test_loader tester = {};
	__u64 old_caps;
	int err;

	/* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
	err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
	if (err) {
		PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
		return;
	}

	test_loader__set_pre_execution_cb(&tester, pre_execution_cb);
	test_loader__run_subtests(&tester, skel_name, elf_bytes_factory);
	test_loader_fini(&tester);

	err = cap_enable_effective(old_caps, NULL);
	if (err)
		PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
}

#define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)

void test_verifier_and(void)                  { RUN(verifier_and); }
void test_verifier_arena(void)                { RUN(verifier_arena); }
void test_verifier_basic_stack(void)          { RUN(verifier_basic_stack); }
void test_verifier_bitfield_write(void)       { RUN(verifier_bitfield_write); }
void test_verifier_bounds(void)               { RUN(verifier_bounds); }
void test_verifier_bounds_deduction(void)     { RUN(verifier_bounds_deduction); }
void test_verifier_bounds_deduction_non_const(void)     { RUN(verifier_bounds_deduction_non_const); }
void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); }
void test_verifier_bpf_get_stack(void)        { RUN(verifier_bpf_get_stack); }
void test_verifier_bswap(void)                { RUN(verifier_bswap); }
void test_verifier_btf_ctx_access(void)       { RUN(verifier_btf_ctx_access); }
void test_verifier_btf_unreliable_prog(void)  { RUN(verifier_btf_unreliable_prog); }
void test_verifier_cfg(void)                  { RUN(verifier_cfg); }
void test_verifier_cgroup_inv_retcode(void)   { RUN(verifier_cgroup_inv_retcode); }
void test_verifier_cgroup_skb(void)           { RUN(verifier_cgroup_skb); }
void test_verifier_cgroup_storage(void)       { RUN(verifier_cgroup_storage); }
void test_verifier_const_or(void)             { RUN(verifier_const_or); }
void test_verifier_ctx(void)                  { RUN(verifier_ctx); }
void test_verifier_ctx_sk_msg(void)           { RUN(verifier_ctx_sk_msg); }
void test_verifier_d_path(void)               { RUN(verifier_d_path); }
void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); }
void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); }
void test_verifier_div0(void)                 { RUN(verifier_div0); }
void test_verifier_div_overflow(void)         { RUN(verifier_div_overflow); }
void test_verifier_global_subprogs(void)      { RUN(verifier_global_subprogs); }
void test_verifier_global_ptr_args(void)      { RUN(verifier_global_ptr_args); }
void test_verifier_gotol(void)                { RUN(verifier_gotol); }
void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); }
void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); }
void test_verifier_helper_restricted(void)    { RUN(verifier_helper_restricted); }
void test_verifier_helper_value_access(void)  { RUN(verifier_helper_value_access); }
void test_verifier_int_ptr(void)              { RUN(verifier_int_ptr); }
void test_verifier_iterating_callbacks(void)  { RUN(verifier_iterating_callbacks); }
void test_verifier_jeq_infer_not_null(void)   { RUN(verifier_jeq_infer_not_null); }
void test_verifier_ld_ind(void)               { RUN(verifier_ld_ind); }
void test_verifier_ldsx(void)                  { RUN(verifier_ldsx); }
void test_verifier_leak_ptr(void)             { RUN(verifier_leak_ptr); }
void test_verifier_loops1(void)               { RUN(verifier_loops1); }
void test_verifier_lwt(void)                  { RUN(verifier_lwt); }
void test_verifier_map_in_map(void)           { RUN(verifier_map_in_map); }
void test_verifier_map_ptr(void)              { RUN(verifier_map_ptr); }
void test_verifier_map_ptr_mixing(void)       { RUN(verifier_map_ptr_mixing); }
void test_verifier_map_ret_val(void)          { RUN(verifier_map_ret_val); }
void test_verifier_masking(void)              { RUN(verifier_masking); }
void test_verifier_meta_access(void)          { RUN(verifier_meta_access); }
void test_verifier_movsx(void)                 { RUN(verifier_movsx); }
void test_verifier_netfilter_ctx(void)        { RUN(verifier_netfilter_ctx); }
void test_verifier_netfilter_retcode(void)    { RUN(verifier_netfilter_retcode); }
void test_verifier_precision(void)            { RUN(verifier_precision); }
void test_verifier_prevent_map_lookup(void)   { RUN(verifier_prevent_map_lookup); }
void test_verifier_raw_stack(void)            { RUN(verifier_raw_stack); }
void test_verifier_raw_tp_writable(void)      { RUN(verifier_raw_tp_writable); }
void test_verifier_reg_equal(void)            { RUN(verifier_reg_equal); }
void test_verifier_ref_tracking(void)         { RUN(verifier_ref_tracking); }
void test_verifier_regalloc(void)             { RUN(verifier_regalloc); }
void test_verifier_ringbuf(void)              { RUN(verifier_ringbuf); }
void test_verifier_runtime_jit(void)          { RUN(verifier_runtime_jit); }
void test_verifier_scalar_ids(void)           { RUN(verifier_scalar_ids); }
void test_verifier_sdiv(void)                 { RUN(verifier_sdiv); }
void test_verifier_search_pruning(void)       { RUN(verifier_search_pruning); }
void test_verifier_sock(void)                 { RUN(verifier_sock); }
void test_verifier_spill_fill(void)           { RUN(verifier_spill_fill); }
void test_verifier_spin_lock(void)            { RUN(verifier_spin_lock); }
void test_verifier_stack_ptr(void)            { RUN(verifier_stack_ptr); }
void test_verifier_subprog_precision(void)    { RUN(verifier_subprog_precision); }
void test_verifier_subreg(void)               { RUN(verifier_subreg); }
void test_verifier_typedef(void)              { RUN(verifier_typedef); }
void test_verifier_uninit(void)               { RUN(verifier_uninit); }
void test_verifier_unpriv(void)               { RUN(verifier_unpriv); }
void test_verifier_unpriv_perf(void)          { RUN(verifier_unpriv_perf); }
void test_verifier_value_adj_spill(void)      { RUN(verifier_value_adj_spill); }
void test_verifier_value(void)                { RUN(verifier_value); }
void test_verifier_value_illegal_alu(void)    { RUN(verifier_value_illegal_alu); }
void test_verifier_value_or_null(void)        { RUN(verifier_value_or_null); }
void test_verifier_var_off(void)              { RUN(verifier_var_off); }
void test_verifier_xadd(void)                 { RUN(verifier_xadd); }
void test_verifier_xdp(void)                  { RUN(verifier_xdp); }
void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); }

static int init_test_val_map(struct bpf_object *obj, char *map_name)
{
	struct test_val value = {
		.index = (6 + 1) * sizeof(int),
		.foo[6] = 0xabcdef12,
	};
	struct bpf_map *map;
	int err, key = 0;

	map = bpf_object__find_map_by_name(obj, map_name);
	if (!map) {
		PRINT_FAIL("Can't find map '%s'\n", map_name);
		return -EINVAL;
	}

	err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0);
	if (err) {
		PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err);
		return err;
	}

	return 0;
}

static int init_array_access_maps(struct bpf_object *obj)
{
	return init_test_val_map(obj, "map_array_ro");
}

void test_verifier_array_access(void)
{
	run_tests_aux("verifier_array_access",
		      verifier_array_access__elf_bytes,
		      init_array_access_maps);
}

static int init_value_ptr_arith_maps(struct bpf_object *obj)
{
	return init_test_val_map(obj, "map_array_48b");
}

void test_verifier_value_ptr_arith(void)
{
	run_tests_aux("verifier_value_ptr_arith",
		      verifier_value_ptr_arith__elf_bytes,
		      init_value_ptr_arith_maps);
}
Commit	Line	Data
55108621 EZ	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include <test_progs.h>
	4
	5	#include "cap_helpers.h"
9d0f1568	6	#include "verifier_and.skel.h"
80a4129f	7	#include "verifier_arena.skel.h"
a3c830ae	8	#include "verifier_array_access.skel.h"
0ccbe495	9	#include "verifier_basic_stack.skel.h"
f04f2ce6	10	#include "verifier_bitfield_write.skel.h"
c9233655	11	#include "verifier_bounds.skel.h"
7605f94b	12	#include "verifier_bounds_deduction.skel.h"
aec08d67	13	#include "verifier_bounds_deduction_non_const.skel.h"
b14a702a	14	#include "verifier_bounds_mix_sign_unsign.skel.h"
965a3f91	15	#include "verifier_bpf_get_stack.skel.h"
79dbabc1	16	#include "verifier_bswap.skel.h"
37467c79	17	#include "verifier_btf_ctx_access.skel.h"
f0a50562	18	#include "verifier_btf_unreliable_prog.skel.h"
2f2047c2	19	#include "verifier_cfg.skel.h"
047687a7	20	#include "verifier_cgroup_inv_retcode.skel.h"
b1b63725	21	#include "verifier_cgroup_skb.skel.h"
8f16f3c0	22	#include "verifier_cgroup_storage.skel.h"
a2777eaa	23	#include "verifier_const_or.skel.h"
fcd36964	24	#include "verifier_ctx.skel.h"
a58475a9	25	#include "verifier_ctx_sk_msg.skel.h"
60802802	26	#include "verifier_d_path.skel.h"
0a372c9c	27	#include "verifier_direct_packet_access.skel.h"
84988478	28	#include "verifier_direct_stack_access_wraparound.skel.h"
01a09255	29	#include "verifier_div0.skel.h"
9553de70	30	#include "verifier_div_overflow.skel.h"
e8a339b5	31	#include "verifier_global_subprogs.skel.h"
c381203e	32	#include "verifier_global_ptr_args.skel.h"
613dad49	33	#include "verifier_gotol.skel.h"
b37d776b	34	#include "verifier_helper_access_var_len.skel.h"
fb179fe6	35	#include "verifier_helper_packet_access.skel.h"
77aa2563	36	#include "verifier_helper_restricted.skel.h"
ecc42482	37	#include "verifier_helper_value_access.skel.h"
01481e67	38	#include "verifier_int_ptr.skel.h"
958465e2	39	#include "verifier_iterating_callbacks.skel.h"
a5828e31	40	#include "verifier_jeq_infer_not_null.skel.h"
e2978755	41	#include "verifier_ld_ind.skel.h"
147c8f44	42	#include "verifier_ldsx.skel.h"
583c7ce5	43	#include "verifier_leak_ptr.skel.h"
a6fc14dc	44	#include "verifier_loops1.skel.h"
b427ca57	45	#include "verifier_lwt.skel.h"
4a400ef9	46	#include "verifier_map_in_map.skel.h"
caf345cf	47	#include "verifier_map_ptr.skel.h"
aee1779f	48	#include "verifier_map_ptr_mixing.skel.h"
05e474ec	49	#include "verifier_map_ret_val.skel.h"
ade3f08f	50	#include "verifier_masking.skel.h"
65428312	51	#include "verifier_meta_access.skel.h"
f02ec3ff	52	#include "verifier_movsx.skel.h"
006c0e44 FW	53	#include "verifier_netfilter_ctx.skel.h"
006c0e44 FW	54	#include "verifier_netfilter_retcode.skel.h"
3c419715	55	#include "verifier_precision.skel.h"
35150203	56	#include "verifier_prevent_map_lookup.skel.h"
5a77a01f	57	#include "verifier_raw_stack.skel.h"
18cdc2b5	58	#include "verifier_raw_tp_writable.skel.h"
49859de9	59	#include "verifier_reg_equal.skel.h"
8be63279	60	#include "verifier_ref_tracking.skel.h"
16a42573	61	#include "verifier_regalloc.skel.h"
b7e42030	62	#include "verifier_ringbuf.skel.h"
65222842	63	#include "verifier_runtime_jit.skel.h"
dec02028	64	#include "verifier_scalar_ids.skel.h"
de1c2680	65	#include "verifier_sdiv.skel.h"
034d9ad2	66	#include "verifier_search_pruning.skel.h"
426fc0e3	67	#include "verifier_sock.skel.h"
f4fe3cfe	68	#include "verifier_spill_fill.skel.h"
f323a818	69	#include "verifier_spin_lock.skel.h"
edff37b2	70	#include "verifier_stack_ptr.skel.h"
3ef3d217	71	#include "verifier_subprog_precision.skel.h"
81d1d6dd	72	#include "verifier_subreg.skel.h"
2597a25c	73	#include "verifier_typedef.skel.h"
ab839a58	74	#include "verifier_uninit.skel.h"
82887c25 EZ	75	#include "verifier_unpriv.skel.h"
82887c25 EZ	76	#include "verifier_unpriv_perf.skel.h"
03391494	77	#include "verifier_value_adj_spill.skel.h"
8f59e87a	78	#include "verifier_value.skel.h"
efe25a33	79	#include "verifier_value_illegal_alu.skel.h"
d3305286	80	#include "verifier_value_or_null.skel.h"
4db10a82	81	#include "verifier_value_ptr_arith.skel.h"
d15f5b68	82	#include "verifier_var_off.skel.h"
a8036aea	83	#include "verifier_xadd.skel.h"
ffb515c9	84	#include "verifier_xdp.skel.h"
6e9e141a	85	#include "verifier_xdp_direct_packet_access.skel.h"
55108621	86
cbb110bc EZ	87	#define MAX_ENTRIES 11
	88
	89	struct test_val {
	90	unsigned int index;
	91	int foo[MAX_ENTRIES];
	92	};
	93
55108621	94	__maybe_unused
cbb110bc EZ	95	static void run_tests_aux(const char *skel_name,
	96	skel_elf_bytes_fn elf_bytes_factory,
	97	pre_execution_cb pre_execution_cb)
55108621 EZ	98	{
	99	struct test_loader tester = {};
	100	__u64 old_caps;
	101	int err;
	102
	103	/* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
	104	err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
	105	if (err) {
	106	PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
	107	return;
	108	}
	109
cbb110bc	110	test_loader__set_pre_execution_cb(&tester, pre_execution_cb);
55108621 EZ	111	test_loader__run_subtests(&tester, skel_name, elf_bytes_factory);
	112	test_loader_fini(&tester);
	113
	114	err = cap_enable_effective(old_caps, NULL);
	115	if (err)
	116	PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(err));
	117	}
	118
cbb110bc	119	#define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)
9d0f1568 EZ	120
9d0f1568 EZ	121	void test_verifier_and(void) { RUN(verifier_and); }
80a4129f	122	void test_verifier_arena(void) { RUN(verifier_arena); }
0ccbe495	123	void test_verifier_basic_stack(void) { RUN(verifier_basic_stack); }
f04f2ce6	124	void test_verifier_bitfield_write(void) { RUN(verifier_bitfield_write); }
c9233655	125	void test_verifier_bounds(void) { RUN(verifier_bounds); }
7605f94b	126	void test_verifier_bounds_deduction(void) { RUN(verifier_bounds_deduction); }
aec08d67	127	void test_verifier_bounds_deduction_non_const(void) { RUN(verifier_bounds_deduction_non_const); }
b14a702a	128	void test_verifier_bounds_mix_sign_unsign(void) { RUN(verifier_bounds_mix_sign_unsign); }
965a3f91	129	void test_verifier_bpf_get_stack(void) { RUN(verifier_bpf_get_stack); }
79dbabc1	130	void test_verifier_bswap(void) { RUN(verifier_bswap); }
37467c79	131	void test_verifier_btf_ctx_access(void) { RUN(verifier_btf_ctx_access); }
f0a50562	132	void test_verifier_btf_unreliable_prog(void) { RUN(verifier_btf_unreliable_prog); }
2f2047c2	133	void test_verifier_cfg(void) { RUN(verifier_cfg); }
047687a7	134	void test_verifier_cgroup_inv_retcode(void) { RUN(verifier_cgroup_inv_retcode); }
b1b63725	135	void test_verifier_cgroup_skb(void) { RUN(verifier_cgroup_skb); }
8f16f3c0	136	void test_verifier_cgroup_storage(void) { RUN(verifier_cgroup_storage); }
a2777eaa	137	void test_verifier_const_or(void) { RUN(verifier_const_or); }
fcd36964	138	void test_verifier_ctx(void) { RUN(verifier_ctx); }
a58475a9	139	void test_verifier_ctx_sk_msg(void) { RUN(verifier_ctx_sk_msg); }
60802802	140	void test_verifier_d_path(void) { RUN(verifier_d_path); }
0a372c9c	141	void test_verifier_direct_packet_access(void) { RUN(verifier_direct_packet_access); }
84988478	142	void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_stack_access_wraparound); }
01a09255	143	void test_verifier_div0(void) { RUN(verifier_div0); }
9553de70	144	void test_verifier_div_overflow(void) { RUN(verifier_div_overflow); }
e8a339b5	145	void test_verifier_global_subprogs(void) { RUN(verifier_global_subprogs); }
c381203e	146	void test_verifier_global_ptr_args(void) { RUN(verifier_global_ptr_args); }
613dad49	147	void test_verifier_gotol(void) { RUN(verifier_gotol); }
b37d776b	148	void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); }
fb179fe6	149	void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); }
77aa2563	150	void test_verifier_helper_restricted(void) { RUN(verifier_helper_restricted); }
ecc42482	151	void test_verifier_helper_value_access(void) { RUN(verifier_helper_value_access); }
01481e67	152	void test_verifier_int_ptr(void) { RUN(verifier_int_ptr); }
958465e2	153	void test_verifier_iterating_callbacks(void) { RUN(verifier_iterating_callbacks); }
a5828e31	154	void test_verifier_jeq_infer_not_null(void) { RUN(verifier_jeq_infer_not_null); }
e2978755	155	void test_verifier_ld_ind(void) { RUN(verifier_ld_ind); }
147c8f44	156	void test_verifier_ldsx(void) { RUN(verifier_ldsx); }
583c7ce5	157	void test_verifier_leak_ptr(void) { RUN(verifier_leak_ptr); }
a6fc14dc	158	void test_verifier_loops1(void) { RUN(verifier_loops1); }
b427ca57	159	void test_verifier_lwt(void) { RUN(verifier_lwt); }
4a400ef9	160	void test_verifier_map_in_map(void) { RUN(verifier_map_in_map); }
caf345cf	161	void test_verifier_map_ptr(void) { RUN(verifier_map_ptr); }
aee1779f	162	void test_verifier_map_ptr_mixing(void) { RUN(verifier_map_ptr_mixing); }
05e474ec	163	void test_verifier_map_ret_val(void) { RUN(verifier_map_ret_val); }
ade3f08f	164	void test_verifier_masking(void) { RUN(verifier_masking); }
65428312	165	void test_verifier_meta_access(void) { RUN(verifier_meta_access); }
f02ec3ff	166	void test_verifier_movsx(void) { RUN(verifier_movsx); }
006c0e44 FW	167	void test_verifier_netfilter_ctx(void) { RUN(verifier_netfilter_ctx); }
006c0e44 FW	168	void test_verifier_netfilter_retcode(void) { RUN(verifier_netfilter_retcode); }
3c419715	169	void test_verifier_precision(void) { RUN(verifier_precision); }
35150203	170	void test_verifier_prevent_map_lookup(void) { RUN(verifier_prevent_map_lookup); }
5a77a01f	171	void test_verifier_raw_stack(void) { RUN(verifier_raw_stack); }
18cdc2b5	172	void test_verifier_raw_tp_writable(void) { RUN(verifier_raw_tp_writable); }
49859de9	173	void test_verifier_reg_equal(void) { RUN(verifier_reg_equal); }
8be63279	174	void test_verifier_ref_tracking(void) { RUN(verifier_ref_tracking); }
16a42573	175	void test_verifier_regalloc(void) { RUN(verifier_regalloc); }
b7e42030	176	void test_verifier_ringbuf(void) { RUN(verifier_ringbuf); }
65222842	177	void test_verifier_runtime_jit(void) { RUN(verifier_runtime_jit); }
dec02028	178	void test_verifier_scalar_ids(void) { RUN(verifier_scalar_ids); }
de1c2680	179	void test_verifier_sdiv(void) { RUN(verifier_sdiv); }
034d9ad2	180	void test_verifier_search_pruning(void) { RUN(verifier_search_pruning); }
426fc0e3	181	void test_verifier_sock(void) { RUN(verifier_sock); }
f4fe3cfe	182	void test_verifier_spill_fill(void) { RUN(verifier_spill_fill); }
f323a818	183	void test_verifier_spin_lock(void) { RUN(verifier_spin_lock); }
edff37b2	184	void test_verifier_stack_ptr(void) { RUN(verifier_stack_ptr); }
3ef3d217	185	void test_verifier_subprog_precision(void) { RUN(verifier_subprog_precision); }
81d1d6dd	186	void test_verifier_subreg(void) { RUN(verifier_subreg); }
2597a25c	187	void test_verifier_typedef(void) { RUN(verifier_typedef); }
ab839a58	188	void test_verifier_uninit(void) { RUN(verifier_uninit); }
82887c25 EZ	189	void test_verifier_unpriv(void) { RUN(verifier_unpriv); }
82887c25 EZ	190	void test_verifier_unpriv_perf(void) { RUN(verifier_unpriv_perf); }
03391494	191	void test_verifier_value_adj_spill(void) { RUN(verifier_value_adj_spill); }
8f59e87a	192	void test_verifier_value(void) { RUN(verifier_value); }
efe25a33	193	void test_verifier_value_illegal_alu(void) { RUN(verifier_value_illegal_alu); }
d3305286	194	void test_verifier_value_or_null(void) { RUN(verifier_value_or_null); }
d15f5b68	195	void test_verifier_var_off(void) { RUN(verifier_var_off); }
a8036aea	196	void test_verifier_xadd(void) { RUN(verifier_xadd); }
ffb515c9	197	void test_verifier_xdp(void) { RUN(verifier_xdp); }
6e9e141a	198	void test_verifier_xdp_direct_packet_access(void) { RUN(verifier_xdp_direct_packet_access); }
cbb110bc	199
4db10a82	200	static int init_test_val_map(struct bpf_object obj, char map_name)
cbb110bc	201	{
cbb110bc EZ	202	struct test_val value = {
	203	.index = (6 + 1) * sizeof(int),
	204	.foo[6] = 0xabcdef12,
	205	};
4db10a82	206	struct bpf_map *map;
cbb110bc EZ	207	int err, key = 0;
cbb110bc EZ	208
4db10a82 EZ	209	map = bpf_object__find_map_by_name(obj, map_name);
	210	if (!map) {
	211	PRINT_FAIL("Can't find map '%s'\n", map_name);
cbb110bc	212	return -EINVAL;
4db10a82	213	}
cbb110bc	214
4db10a82 EZ	215	err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0);
	216	if (err) {
	217	PRINT_FAIL("Error while updating map '%s': %d\n", map_name, err);
cbb110bc	218	return err;
4db10a82	219	}
cbb110bc EZ	220
	221	return 0;
	222	}
	223
4db10a82 EZ	224	static int init_array_access_maps(struct bpf_object *obj)
	225	{
	226	return init_test_val_map(obj, "map_array_ro");
	227	}
	228
cbb110bc EZ	229	void test_verifier_array_access(void)
	230	{
	231	run_tests_aux("verifier_array_access",
	232	verifier_array_access__elf_bytes,
	233	init_array_access_maps);
	234	}
4db10a82 EZ	235
	236	static int init_value_ptr_arith_maps(struct bpf_object *obj)
	237	{
	238	return init_test_val_map(obj, "map_array_48b");
	239	}
	240
	241	void test_verifier_value_ptr_arith(void)
	242	{
	243	run_tests_aux("verifier_value_ptr_arith",
	244	verifier_value_ptr_arith__elf_bytes,
	245	init_value_ptr_arith_maps);
	246	}