125763b3cSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
25aa5bd14SDaniel Borkmann /*
35aa5bd14SDaniel Borkmann * Testsuite for eBPF verifier
45aa5bd14SDaniel Borkmann *
55aa5bd14SDaniel Borkmann * Copyright (c) 2014 PLUMgrid, http://plumgrid.com
6a7ff3ecaSAlexei Starovoitov * Copyright (c) 2017 Facebook
7b584ab88SJoe Stringer * Copyright (c) 2018 Covalent IO, Inc. http://covalent.io
85aa5bd14SDaniel Borkmann */
95aa5bd14SDaniel Borkmann
102c460621SDaniel Borkmann #include <endian.h>
111da8ac7cSAlexei Starovoitov #include <asm/types.h>
121da8ac7cSAlexei Starovoitov #include <linux/types.h>
13702498a1SMickaël Salaün #include <stdint.h>
145aa5bd14SDaniel Borkmann #include <stdio.h>
15702498a1SMickaël Salaün #include <stdlib.h>
165aa5bd14SDaniel Borkmann #include <unistd.h>
175aa5bd14SDaniel Borkmann #include <errno.h>
185aa5bd14SDaniel Borkmann #include <string.h>
195aa5bd14SDaniel Borkmann #include <stddef.h>
205aa5bd14SDaniel Borkmann #include <stdbool.h>
215aa5bd14SDaniel Borkmann #include <sched.h>
2221ccaf21SDaniel Borkmann #include <limits.h>
2380c9b2faSDaniel Borkmann #include <assert.h>
245aa5bd14SDaniel Borkmann
255aa5bd14SDaniel Borkmann #include <linux/unistd.h>
265aa5bd14SDaniel Borkmann #include <linux/filter.h>
275aa5bd14SDaniel Borkmann #include <linux/bpf_perf_event.h>
285aa5bd14SDaniel Borkmann #include <linux/bpf.h>
29111e6b45SAlexei Starovoitov #include <linux/if_ether.h>
30b4d4556cSAlexei Starovoitov #include <linux/btf.h>
315aa5bd14SDaniel Borkmann
320201b807SKumar Kartikeya Dwivedi #include <bpf/btf.h>
332ee89fb9SMickaël Salaün #include <bpf/bpf.h>
348184d44cSStanislav Fomichev #include <bpf/libbpf.h>
352ee89fb9SMickaël Salaün
361d56ade0SEduard Zingerman #include "autoconf_helper.h"
371d56ade0SEduard Zingerman #include "unpriv_helpers.h"
38b1c2768aSMartin KaFai Lau #include "cap_helpers.h"
39a82d8cd3SDaniel Borkmann #include "bpf_rand.h"
40aa5f0c96SMartin KaFai Lau #include "bpf_util.h"
417a9bb976SMartin KaFai Lau #include "test_btf.h"
425aa5bd14SDaniel Borkmann #include "../../../include/linux/filter.h"
43b23b385fSJiri Olsa #include "testing_helpers.h"
445aa5bd14SDaniel Borkmann
455319255bSIlya Leoshkevich #ifndef ENOTSUPP
465319255bSIlya Leoshkevich #define ENOTSUPP 524
475319255bSIlya Leoshkevich #endif
485319255bSIlya Leoshkevich
4993731ef0SDaniel Borkmann #define MAX_INSNS BPF_MAXINSNS
50933ff531SEduard Zingerman #define MAX_EXPECTED_INSNS 32
51933ff531SEduard Zingerman #define MAX_UNEXPECTED_INSNS 32
528aa2d4b4SAlexei Starovoitov #define MAX_TEST_INSNS 1000000
535aa5bd14SDaniel Borkmann #define MAX_FIXUPS 8
5405a945deSKumar Kartikeya Dwivedi #define MAX_NR_MAPS 23
555a8d5209SJakub Kicinski #define MAX_TEST_RUNS 8
56111e6b45SAlexei Starovoitov #define POINTER_VALUE 0xcafe4all
57111e6b45SAlexei Starovoitov #define TEST_DATA_LEN 64
587a42008cSEduard Zingerman #define MAX_FUNC_INFOS 8
597a42008cSEduard Zingerman #define MAX_BTF_STRINGS 256
607a42008cSEduard Zingerman #define MAX_BTF_TYPES 256
615aa5bd14SDaniel Borkmann
62933ff531SEduard Zingerman #define INSN_OFF_MASK ((__s16)0xFFFF)
63933ff531SEduard Zingerman #define INSN_IMM_MASK ((__s32)0xFFFFFFFF)
64933ff531SEduard Zingerman #define SKIP_INSNS() BPF_RAW_INSN(0xde, 0xa, 0xd, 0xbeef, 0xdeadbeef)
65933ff531SEduard Zingerman
667a42008cSEduard Zingerman #define DEFAULT_LIBBPF_LOG_LEVEL 4
677a42008cSEduard Zingerman
6802ea80b1SDaniel Borkmann #define F_NEEDS_EFFICIENT_UNALIGNED_ACCESS (1 << 0)
69614d0d77SDaniel Borkmann #define F_LOAD_WITH_STRICT_ALIGNMENT (1 << 1)
7002ea80b1SDaniel Borkmann
71b1c2768aSMartin KaFai Lau /* need CAP_BPF, CAP_NET_ADMIN, CAP_PERFMON to load progs */
72b1c2768aSMartin KaFai Lau #define ADMIN_CAPS (1ULL << CAP_NET_ADMIN | \
73b1c2768aSMartin KaFai Lau 1ULL << CAP_PERFMON | \
74b1c2768aSMartin KaFai Lau 1ULL << CAP_BPF)
750a674874SJoe Stringer #define UNPRIV_SYSCTL "kernel/unprivileged_bpf_disabled"
760a674874SJoe Stringer static bool unpriv_disabled = false;
778184d44cSStanislav Fomichev static int skips;
78e8c13c4dSAlexei Starovoitov static bool verbose = false;
792a72f595SAndrii Nakryiko static int verif_log_level = 0;
800a674874SJoe Stringer
810201b807SKumar Kartikeya Dwivedi struct kfunc_btf_id_pair {
820201b807SKumar Kartikeya Dwivedi const char *kfunc;
830201b807SKumar Kartikeya Dwivedi int insn_idx;
840201b807SKumar Kartikeya Dwivedi };
850201b807SKumar Kartikeya Dwivedi
865aa5bd14SDaniel Borkmann struct bpf_test {
875aa5bd14SDaniel Borkmann const char *descr;
885aa5bd14SDaniel Borkmann struct bpf_insn insns[MAX_INSNS];
898aa2d4b4SAlexei Starovoitov struct bpf_insn *fill_insns;
90933ff531SEduard Zingerman /* If specified, test engine looks for this sequence of
91933ff531SEduard Zingerman * instructions in the BPF program after loading. Allows to
92933ff531SEduard Zingerman * test rewrites applied by verifier. Use values
93933ff531SEduard Zingerman * INSN_OFF_MASK and INSN_IMM_MASK to mask `off` and `imm`
94933ff531SEduard Zingerman * fields if content does not matter. The test case fails if
95933ff531SEduard Zingerman * specified instructions are not found.
96933ff531SEduard Zingerman *
97933ff531SEduard Zingerman * The sequence could be split into sub-sequences by adding
98933ff531SEduard Zingerman * SKIP_INSNS instruction at the end of each sub-sequence. In
99933ff531SEduard Zingerman * such case sub-sequences are searched for one after another.
100933ff531SEduard Zingerman */
101933ff531SEduard Zingerman struct bpf_insn expected_insns[MAX_EXPECTED_INSNS];
102933ff531SEduard Zingerman /* If specified, test engine applies same pattern matching
103933ff531SEduard Zingerman * logic as for `expected_insns`. If the specified pattern is
104933ff531SEduard Zingerman * matched test case is marked as failed.
105933ff531SEduard Zingerman */
106933ff531SEduard Zingerman struct bpf_insn unexpected_insns[MAX_UNEXPECTED_INSNS];
107908142e6SPrashant Bhole int fixup_map_hash_8b[MAX_FIXUPS];
108908142e6SPrashant Bhole int fixup_map_hash_48b[MAX_FIXUPS];
109908142e6SPrashant Bhole int fixup_map_hash_16b[MAX_FIXUPS];
110908142e6SPrashant Bhole int fixup_map_array_48b[MAX_FIXUPS];
1117c85c448SPrashant Bhole int fixup_map_sockmap[MAX_FIXUPS];
1127c85c448SPrashant Bhole int fixup_map_sockhash[MAX_FIXUPS];
1137c85c448SPrashant Bhole int fixup_map_xskmap[MAX_FIXUPS];
1147c85c448SPrashant Bhole int fixup_map_stacktrace[MAX_FIXUPS];
11506be0864SDaniel Borkmann int fixup_prog1[MAX_FIXUPS];
11606be0864SDaniel Borkmann int fixup_prog2[MAX_FIXUPS];
117fb30d4b7SMartin KaFai Lau int fixup_map_in_map[MAX_FIXUPS];
118d4c9f573SRoman Gushchin int fixup_cgroup_storage[MAX_FIXUPS];
119a3c6054fSRoman Gushchin int fixup_percpu_cgroup_storage[MAX_FIXUPS];
120b4d4556cSAlexei Starovoitov int fixup_map_spin_lock[MAX_FIXUPS];
121fb2abb73SDaniel Borkmann int fixup_map_array_ro[MAX_FIXUPS];
122fb2abb73SDaniel Borkmann int fixup_map_array_wo[MAX_FIXUPS];
123fb2abb73SDaniel Borkmann int fixup_map_array_small[MAX_FIXUPS];
1247a9bb976SMartin KaFai Lau int fixup_sk_storage_map[MAX_FIXUPS];
12503cd1d1aSAllan Zhang int fixup_map_event_output[MAX_FIXUPS];
126c3210222SJakub Sitnicki int fixup_map_reuseport_array[MAX_FIXUPS];
1274237e9f4SGilad Reti int fixup_map_ringbuf[MAX_FIXUPS];
128e60e6962SDmitrii Banshchikov int fixup_map_timer[MAX_FIXUPS];
12905a945deSKumar Kartikeya Dwivedi int fixup_map_kptr[MAX_FIXUPS];
1300201b807SKumar Kartikeya Dwivedi struct kfunc_btf_id_pair fixup_kfunc_btf_id[MAX_FIXUPS];
131060fd103SAndrei Matei /* Expected verifier log output for result REJECT or VERBOSE_ACCEPT.
132060fd103SAndrei Matei * Can be a tab-separated sequence of expected strings. An empty string
133060fd103SAndrei Matei * means no log verification.
134060fd103SAndrei Matei */
1355aa5bd14SDaniel Borkmann const char *errstr;
1365aa5bd14SDaniel Borkmann const char *errstr_unpriv;
137d5e1db99SAndrii Nakryiko uint32_t insn_processed;
1388aa2d4b4SAlexei Starovoitov int prog_len;
1395aa5bd14SDaniel Borkmann enum {
1405aa5bd14SDaniel Borkmann UNDEF,
1415aa5bd14SDaniel Borkmann ACCEPT,
142e8c13c4dSAlexei Starovoitov REJECT,
143e8c13c4dSAlexei Starovoitov VERBOSE_ACCEPT,
1445aa5bd14SDaniel Borkmann } result, result_unpriv;
1455aa5bd14SDaniel Borkmann enum bpf_prog_type prog_type;
14602ea80b1SDaniel Borkmann uint8_t flags;
14793731ef0SDaniel Borkmann void (*fill_helper)(struct bpf_test *self);
148b4f89463SLorenz Bauer int runs;
149d5e1db99SAndrii Nakryiko #define bpf_testdata_struct_t \
150d5e1db99SAndrii Nakryiko struct { \
151d5e1db99SAndrii Nakryiko uint32_t retval, retval_unpriv; \
152d5e1db99SAndrii Nakryiko union { \
153d5e1db99SAndrii Nakryiko __u8 data[TEST_DATA_LEN]; \
154d5e1db99SAndrii Nakryiko __u64 data64[TEST_DATA_LEN / 8]; \
155d5e1db99SAndrii Nakryiko }; \
156d5e1db99SAndrii Nakryiko }
1575a8d5209SJakub Kicinski union {
158d5e1db99SAndrii Nakryiko bpf_testdata_struct_t;
159d5e1db99SAndrii Nakryiko bpf_testdata_struct_t retvals[MAX_TEST_RUNS];
1605a8d5209SJakub Kicinski };
16176d95077SStanislav Fomichev enum bpf_attach_type expected_attach_type;
162762f8515SJiri Olsa const char *kfunc;
1637a42008cSEduard Zingerman struct bpf_func_info func_info[MAX_FUNC_INFOS];
1647a42008cSEduard Zingerman int func_info_cnt;
1657a42008cSEduard Zingerman char btf_strings[MAX_BTF_STRINGS];
1667a42008cSEduard Zingerman /* A set of BTF types to load when specified,
1677a42008cSEduard Zingerman * use macro definitions from test_btf.h,
1687a42008cSEduard Zingerman * must end with BTF_END_RAW
1697a42008cSEduard Zingerman */
1707a42008cSEduard Zingerman __u32 btf_types[MAX_BTF_TYPES];
1715aa5bd14SDaniel Borkmann };
1725aa5bd14SDaniel Borkmann
1735aa5bd14SDaniel Borkmann /* Note we want this to be 64 bit aligned so that the end of our array is
1745aa5bd14SDaniel Borkmann * actually the end of the structure.
1755aa5bd14SDaniel Borkmann */
1765aa5bd14SDaniel Borkmann #define MAX_ENTRIES 11
1775aa5bd14SDaniel Borkmann
1785aa5bd14SDaniel Borkmann struct test_val {
1795aa5bd14SDaniel Borkmann unsigned int index;
1805aa5bd14SDaniel Borkmann int foo[MAX_ENTRIES];
1815aa5bd14SDaniel Borkmann };
1825aa5bd14SDaniel Borkmann
1835f90dd6aSPaul Chaignon struct other_val {
1845f90dd6aSPaul Chaignon long long foo;
1855f90dd6aSPaul Chaignon long long bar;
1865f90dd6aSPaul Chaignon };
1875f90dd6aSPaul Chaignon
bpf_fill_ld_abs_vlan_push_pop(struct bpf_test * self)18893731ef0SDaniel Borkmann static void bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
18993731ef0SDaniel Borkmann {
1908aa2d4b4SAlexei Starovoitov /* test: {skb->data[0], vlan_push} x 51 + {skb->data[0], vlan_pop} x 51 */
19193731ef0SDaniel Borkmann #define PUSH_CNT 51
1928aa2d4b4SAlexei Starovoitov /* jump range is limited to 16 bit. PUSH_CNT of ld_abs needs room */
1938aa2d4b4SAlexei Starovoitov unsigned int len = (1 << 15) - PUSH_CNT * 2 * 5 * 6;
1948aa2d4b4SAlexei Starovoitov struct bpf_insn *insn = self->fill_insns;
19593731ef0SDaniel Borkmann int i = 0, j, k = 0;
19693731ef0SDaniel Borkmann
19793731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_REG(BPF_REG_6, BPF_REG_1);
19893731ef0SDaniel Borkmann loop:
19993731ef0SDaniel Borkmann for (j = 0; j < PUSH_CNT; j++) {
20093731ef0SDaniel Borkmann insn[i++] = BPF_LD_ABS(BPF_B, 0);
201f3b55abbSJiong Wang /* jump to error label */
202f3b55abbSJiong Wang insn[i] = BPF_JMP32_IMM(BPF_JNE, BPF_REG_0, 0x34, len - i - 3);
20393731ef0SDaniel Borkmann i++;
20493731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_REG(BPF_REG_1, BPF_REG_6);
20593731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_IMM(BPF_REG_2, 1);
20693731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_IMM(BPF_REG_3, 2);
20793731ef0SDaniel Borkmann insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
20815080908STiezhu Yang BPF_FUNC_skb_vlan_push);
209f3b55abbSJiong Wang insn[i] = BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, len - i - 3);
21093731ef0SDaniel Borkmann i++;
21193731ef0SDaniel Borkmann }
21293731ef0SDaniel Borkmann
21393731ef0SDaniel Borkmann for (j = 0; j < PUSH_CNT; j++) {
21493731ef0SDaniel Borkmann insn[i++] = BPF_LD_ABS(BPF_B, 0);
215f3b55abbSJiong Wang insn[i] = BPF_JMP32_IMM(BPF_JNE, BPF_REG_0, 0x34, len - i - 3);
21693731ef0SDaniel Borkmann i++;
21793731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_REG(BPF_REG_1, BPF_REG_6);
21893731ef0SDaniel Borkmann insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
21915080908STiezhu Yang BPF_FUNC_skb_vlan_pop);
220f3b55abbSJiong Wang insn[i] = BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, len - i - 3);
22193731ef0SDaniel Borkmann i++;
22293731ef0SDaniel Borkmann }
22393731ef0SDaniel Borkmann if (++k < 5)
22493731ef0SDaniel Borkmann goto loop;
22593731ef0SDaniel Borkmann
226f3b55abbSJiong Wang for (; i < len - 3; i++)
227f3b55abbSJiong Wang insn[i] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0xbef);
228f3b55abbSJiong Wang insn[len - 3] = BPF_JMP_A(1);
229f3b55abbSJiong Wang /* error label */
230f3b55abbSJiong Wang insn[len - 2] = BPF_MOV32_IMM(BPF_REG_0, 0);
23193731ef0SDaniel Borkmann insn[len - 1] = BPF_EXIT_INSN();
2328aa2d4b4SAlexei Starovoitov self->prog_len = len;
23393731ef0SDaniel Borkmann }
23493731ef0SDaniel Borkmann
bpf_fill_jump_around_ld_abs(struct bpf_test * self)23593731ef0SDaniel Borkmann static void bpf_fill_jump_around_ld_abs(struct bpf_test *self)
23693731ef0SDaniel Borkmann {
2378aa2d4b4SAlexei Starovoitov struct bpf_insn *insn = self->fill_insns;
238f3b55abbSJiong Wang /* jump range is limited to 16 bit. every ld_abs is replaced by 6 insns,
239f3b55abbSJiong Wang * but on arches like arm, ppc etc, there will be one BPF_ZEXT inserted
240f3b55abbSJiong Wang * to extend the error value of the inlined ld_abs sequence which then
241f3b55abbSJiong Wang * contains 7 insns. so, set the dividend to 7 so the testcase could
242f3b55abbSJiong Wang * work on all arches.
243f3b55abbSJiong Wang */
244f3b55abbSJiong Wang unsigned int len = (1 << 15) / 7;
24593731ef0SDaniel Borkmann int i = 0;
24693731ef0SDaniel Borkmann
24793731ef0SDaniel Borkmann insn[i++] = BPF_MOV64_REG(BPF_REG_6, BPF_REG_1);
24893731ef0SDaniel Borkmann insn[i++] = BPF_LD_ABS(BPF_B, 0);
24993731ef0SDaniel Borkmann insn[i] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 10, len - i - 2);
25093731ef0SDaniel Borkmann i++;
25193731ef0SDaniel Borkmann while (i < len - 1)
25293731ef0SDaniel Borkmann insn[i++] = BPF_LD_ABS(BPF_B, 1);
25393731ef0SDaniel Borkmann insn[i] = BPF_EXIT_INSN();
2548aa2d4b4SAlexei Starovoitov self->prog_len = i + 1;
25593731ef0SDaniel Borkmann }
25693731ef0SDaniel Borkmann
bpf_fill_rand_ld_dw(struct bpf_test * self)257a82d8cd3SDaniel Borkmann static void bpf_fill_rand_ld_dw(struct bpf_test *self)
258a82d8cd3SDaniel Borkmann {
2598aa2d4b4SAlexei Starovoitov struct bpf_insn *insn = self->fill_insns;
260a82d8cd3SDaniel Borkmann uint64_t res = 0;
261a82d8cd3SDaniel Borkmann int i = 0;
262a82d8cd3SDaniel Borkmann
263a82d8cd3SDaniel Borkmann insn[i++] = BPF_MOV32_IMM(BPF_REG_0, 0);
264a82d8cd3SDaniel Borkmann while (i < self->retval) {
265a82d8cd3SDaniel Borkmann uint64_t val = bpf_semi_rand_get();
266a82d8cd3SDaniel Borkmann struct bpf_insn tmp[2] = { BPF_LD_IMM64(BPF_REG_1, val) };
267a82d8cd3SDaniel Borkmann
268a82d8cd3SDaniel Borkmann res ^= val;
269a82d8cd3SDaniel Borkmann insn[i++] = tmp[0];
270a82d8cd3SDaniel Borkmann insn[i++] = tmp[1];
271a82d8cd3SDaniel Borkmann insn[i++] = BPF_ALU64_REG(BPF_XOR, BPF_REG_0, BPF_REG_1);
272a82d8cd3SDaniel Borkmann }
273a82d8cd3SDaniel Borkmann insn[i++] = BPF_MOV64_REG(BPF_REG_1, BPF_REG_0);
274a82d8cd3SDaniel Borkmann insn[i++] = BPF_ALU64_IMM(BPF_RSH, BPF_REG_1, 32);
275a82d8cd3SDaniel Borkmann insn[i++] = BPF_ALU64_REG(BPF_XOR, BPF_REG_0, BPF_REG_1);
276a82d8cd3SDaniel Borkmann insn[i] = BPF_EXIT_INSN();
2778aa2d4b4SAlexei Starovoitov self->prog_len = i + 1;
278a82d8cd3SDaniel Borkmann res ^= (res >> 32);
279a82d8cd3SDaniel Borkmann self->retval = (uint32_t)res;
280a82d8cd3SDaniel Borkmann }
281a82d8cd3SDaniel Borkmann
2827c0c6095SAlexei Starovoitov #define MAX_JMP_SEQ 8192
2837c0c6095SAlexei Starovoitov
2847c0c6095SAlexei Starovoitov /* test the sequence of 8k jumps */
bpf_fill_scale1(struct bpf_test * self)28508de198cSAlexei Starovoitov static void bpf_fill_scale1(struct bpf_test *self)
28608de198cSAlexei Starovoitov {
28708de198cSAlexei Starovoitov struct bpf_insn *insn = self->fill_insns;
28808de198cSAlexei Starovoitov int i = 0, k = 0;
28908de198cSAlexei Starovoitov
29008de198cSAlexei Starovoitov insn[i++] = BPF_MOV64_REG(BPF_REG_6, BPF_REG_1);
2917c0c6095SAlexei Starovoitov /* test to check that the long sequence of jumps is acceptable */
2927c0c6095SAlexei Starovoitov while (k++ < MAX_JMP_SEQ) {
29308de198cSAlexei Starovoitov insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
29408de198cSAlexei Starovoitov BPF_FUNC_get_prandom_u32);
2957c0c6095SAlexei Starovoitov insn[i++] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, bpf_semi_rand_get(), 2);
29608de198cSAlexei Starovoitov insn[i++] = BPF_MOV64_REG(BPF_REG_1, BPF_REG_10);
29708de198cSAlexei Starovoitov insn[i++] = BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_6,
29808de198cSAlexei Starovoitov -8 * (k % 64 + 1));
29908de198cSAlexei Starovoitov }
300aeee380cSAlexei Starovoitov /* is_state_visited() doesn't allocate state for pruning for every jump.
301aeee380cSAlexei Starovoitov * Hence multiply jmps by 4 to accommodate that heuristic
30208de198cSAlexei Starovoitov */
303aeee380cSAlexei Starovoitov while (i < MAX_TEST_INSNS - MAX_JMP_SEQ * 4)
304f3b55abbSJiong Wang insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 42);
30508de198cSAlexei Starovoitov insn[i] = BPF_EXIT_INSN();
30608de198cSAlexei Starovoitov self->prog_len = i + 1;
30708de198cSAlexei Starovoitov self->retval = 42;
30808de198cSAlexei Starovoitov }
30908de198cSAlexei Starovoitov
3107c0c6095SAlexei Starovoitov /* test the sequence of 8k jumps in inner most function (function depth 8)*/
bpf_fill_scale2(struct bpf_test * self)31108de198cSAlexei Starovoitov static void bpf_fill_scale2(struct bpf_test *self)
31208de198cSAlexei Starovoitov {
31308de198cSAlexei Starovoitov struct bpf_insn *insn = self->fill_insns;
31408de198cSAlexei Starovoitov int i = 0, k = 0;
31508de198cSAlexei Starovoitov
31608de198cSAlexei Starovoitov #define FUNC_NEST 7
31708de198cSAlexei Starovoitov for (k = 0; k < FUNC_NEST; k++) {
31808de198cSAlexei Starovoitov insn[i++] = BPF_CALL_REL(1);
31908de198cSAlexei Starovoitov insn[i++] = BPF_EXIT_INSN();
32008de198cSAlexei Starovoitov }
32108de198cSAlexei Starovoitov insn[i++] = BPF_MOV64_REG(BPF_REG_6, BPF_REG_1);
3227c0c6095SAlexei Starovoitov /* test to check that the long sequence of jumps is acceptable */
3237c0c6095SAlexei Starovoitov k = 0;
3247c0c6095SAlexei Starovoitov while (k++ < MAX_JMP_SEQ) {
32508de198cSAlexei Starovoitov insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
32608de198cSAlexei Starovoitov BPF_FUNC_get_prandom_u32);
3277c0c6095SAlexei Starovoitov insn[i++] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, bpf_semi_rand_get(), 2);
32808de198cSAlexei Starovoitov insn[i++] = BPF_MOV64_REG(BPF_REG_1, BPF_REG_10);
32908de198cSAlexei Starovoitov insn[i++] = BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_6,
33008de198cSAlexei Starovoitov -8 * (k % (64 - 4 * FUNC_NEST) + 1));
33108de198cSAlexei Starovoitov }
332aeee380cSAlexei Starovoitov while (i < MAX_TEST_INSNS - MAX_JMP_SEQ * 4)
333f3b55abbSJiong Wang insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 42);
33408de198cSAlexei Starovoitov insn[i] = BPF_EXIT_INSN();
33508de198cSAlexei Starovoitov self->prog_len = i + 1;
33608de198cSAlexei Starovoitov self->retval = 42;
33708de198cSAlexei Starovoitov }
33808de198cSAlexei Starovoitov
bpf_fill_scale(struct bpf_test * self)33908de198cSAlexei Starovoitov static void bpf_fill_scale(struct bpf_test *self)
34008de198cSAlexei Starovoitov {
34108de198cSAlexei Starovoitov switch (self->retval) {
34208de198cSAlexei Starovoitov case 1:
34308de198cSAlexei Starovoitov return bpf_fill_scale1(self);
34408de198cSAlexei Starovoitov case 2:
34508de198cSAlexei Starovoitov return bpf_fill_scale2(self);
34608de198cSAlexei Starovoitov default:
34708de198cSAlexei Starovoitov self->prog_len = 0;
34808de198cSAlexei Starovoitov break;
34908de198cSAlexei Starovoitov }
35008de198cSAlexei Starovoitov }
35108de198cSAlexei Starovoitov
bpf_fill_torturous_jumps_insn_1(struct bpf_insn * insn)35279d1b684SGary Lin static int bpf_fill_torturous_jumps_insn_1(struct bpf_insn *insn)
35379d1b684SGary Lin {
35479d1b684SGary Lin unsigned int len = 259, hlen = 128;
35579d1b684SGary Lin int i;
35679d1b684SGary Lin
35779d1b684SGary Lin insn[0] = BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32);
35879d1b684SGary Lin for (i = 1; i <= hlen; i++) {
35979d1b684SGary Lin insn[i] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, i, hlen);
36079d1b684SGary Lin insn[i + hlen] = BPF_JMP_A(hlen - i);
36179d1b684SGary Lin }
36279d1b684SGary Lin insn[len - 2] = BPF_MOV64_IMM(BPF_REG_0, 1);
36379d1b684SGary Lin insn[len - 1] = BPF_EXIT_INSN();
36479d1b684SGary Lin
36579d1b684SGary Lin return len;
36679d1b684SGary Lin }
36779d1b684SGary Lin
bpf_fill_torturous_jumps_insn_2(struct bpf_insn * insn)36879d1b684SGary Lin static int bpf_fill_torturous_jumps_insn_2(struct bpf_insn *insn)
36979d1b684SGary Lin {
37079d1b684SGary Lin unsigned int len = 4100, jmp_off = 2048;
37179d1b684SGary Lin int i, j;
37279d1b684SGary Lin
37379d1b684SGary Lin insn[0] = BPF_EMIT_CALL(BPF_FUNC_get_prandom_u32);
37479d1b684SGary Lin for (i = 1; i <= jmp_off; i++) {
37579d1b684SGary Lin insn[i] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, i, jmp_off);
37679d1b684SGary Lin }
37779d1b684SGary Lin insn[i++] = BPF_JMP_A(jmp_off);
37879d1b684SGary Lin for (; i <= jmp_off * 2 + 1; i+=16) {
37979d1b684SGary Lin for (j = 0; j < 16; j++) {
38079d1b684SGary Lin insn[i + j] = BPF_JMP_A(16 - j - 1);
38179d1b684SGary Lin }
38279d1b684SGary Lin }
38379d1b684SGary Lin
38479d1b684SGary Lin insn[len - 2] = BPF_MOV64_IMM(BPF_REG_0, 2);
38579d1b684SGary Lin insn[len - 1] = BPF_EXIT_INSN();
38679d1b684SGary Lin
38779d1b684SGary Lin return len;
38879d1b684SGary Lin }
38979d1b684SGary Lin
bpf_fill_torturous_jumps(struct bpf_test * self)39079d1b684SGary Lin static void bpf_fill_torturous_jumps(struct bpf_test *self)
39179d1b684SGary Lin {
39279d1b684SGary Lin struct bpf_insn *insn = self->fill_insns;
39379d1b684SGary Lin int i = 0;
39479d1b684SGary Lin
39579d1b684SGary Lin switch (self->retval) {
39679d1b684SGary Lin case 1:
39779d1b684SGary Lin self->prog_len = bpf_fill_torturous_jumps_insn_1(insn);
39879d1b684SGary Lin return;
39979d1b684SGary Lin case 2:
40079d1b684SGary Lin self->prog_len = bpf_fill_torturous_jumps_insn_2(insn);
40179d1b684SGary Lin return;
40279d1b684SGary Lin case 3:
40379d1b684SGary Lin /* main */
40479d1b684SGary Lin insn[i++] = BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4);
40579d1b684SGary Lin insn[i++] = BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 262);
40679d1b684SGary Lin insn[i++] = BPF_ST_MEM(BPF_B, BPF_REG_10, -32, 0);
40779d1b684SGary Lin insn[i++] = BPF_MOV64_IMM(BPF_REG_0, 3);
40879d1b684SGary Lin insn[i++] = BPF_EXIT_INSN();
40979d1b684SGary Lin
41079d1b684SGary Lin /* subprog 1 */
41179d1b684SGary Lin i += bpf_fill_torturous_jumps_insn_1(insn + i);
41279d1b684SGary Lin
41379d1b684SGary Lin /* subprog 2 */
41479d1b684SGary Lin i += bpf_fill_torturous_jumps_insn_2(insn + i);
41579d1b684SGary Lin
41679d1b684SGary Lin self->prog_len = i;
41779d1b684SGary Lin return;
41879d1b684SGary Lin default:
41979d1b684SGary Lin self->prog_len = 0;
42079d1b684SGary Lin break;
42179d1b684SGary Lin }
42279d1b684SGary Lin }
42379d1b684SGary Lin
bpf_fill_big_prog_with_loop_1(struct bpf_test * self)42441188e9eSEduard Zingerman static void bpf_fill_big_prog_with_loop_1(struct bpf_test *self)
42541188e9eSEduard Zingerman {
42641188e9eSEduard Zingerman struct bpf_insn *insn = self->fill_insns;
42741188e9eSEduard Zingerman /* This test was added to catch a specific use after free
42841188e9eSEduard Zingerman * error, which happened upon BPF program reallocation.
42941188e9eSEduard Zingerman * Reallocation is handled by core.c:bpf_prog_realloc, which
43041188e9eSEduard Zingerman * reuses old memory if page boundary is not crossed. The
43141188e9eSEduard Zingerman * value of `len` is chosen to cross this boundary on bpf_loop
43241188e9eSEduard Zingerman * patching.
43341188e9eSEduard Zingerman */
43441188e9eSEduard Zingerman const int len = getpagesize() - 25;
43541188e9eSEduard Zingerman int callback_load_idx;
43641188e9eSEduard Zingerman int callback_idx;
43741188e9eSEduard Zingerman int i = 0;
43841188e9eSEduard Zingerman
43941188e9eSEduard Zingerman insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_1, 1);
44041188e9eSEduard Zingerman callback_load_idx = i;
44141188e9eSEduard Zingerman insn[i++] = BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW,
44241188e9eSEduard Zingerman BPF_REG_2, BPF_PSEUDO_FUNC, 0,
44341188e9eSEduard Zingerman 777 /* filled below */);
44441188e9eSEduard Zingerman insn[i++] = BPF_RAW_INSN(0, 0, 0, 0, 0);
44541188e9eSEduard Zingerman insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_3, 0);
44641188e9eSEduard Zingerman insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_4, 0);
44741188e9eSEduard Zingerman insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_loop);
44841188e9eSEduard Zingerman
44941188e9eSEduard Zingerman while (i < len - 3)
45041188e9eSEduard Zingerman insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0);
45141188e9eSEduard Zingerman insn[i++] = BPF_EXIT_INSN();
45241188e9eSEduard Zingerman
45341188e9eSEduard Zingerman callback_idx = i;
45441188e9eSEduard Zingerman insn[i++] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0);
45541188e9eSEduard Zingerman insn[i++] = BPF_EXIT_INSN();
45641188e9eSEduard Zingerman
45741188e9eSEduard Zingerman insn[callback_load_idx].imm = callback_idx - callback_load_idx - 1;
45841188e9eSEduard Zingerman self->func_info[1].insn_off = callback_idx;
45941188e9eSEduard Zingerman self->prog_len = i;
46041188e9eSEduard Zingerman assert(i == len);
46141188e9eSEduard Zingerman }
46241188e9eSEduard Zingerman
463b584ab88SJoe Stringer /* BPF_SK_LOOKUP contains 13 instructions, if you need to fix up maps */
464dbaf2877SLorenz Bauer #define BPF_SK_LOOKUP(func) \
465b584ab88SJoe Stringer /* struct bpf_sock_tuple tuple = {} */ \
466b584ab88SJoe Stringer BPF_MOV64_IMM(BPF_REG_2, 0), \
467b584ab88SJoe Stringer BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_2, -8), \
468b584ab88SJoe Stringer BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_2, -16), \
469b584ab88SJoe Stringer BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_2, -24), \
470b584ab88SJoe Stringer BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_2, -32), \
471b584ab88SJoe Stringer BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_2, -40), \
472b584ab88SJoe Stringer BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_2, -48), \
473dbaf2877SLorenz Bauer /* sk = func(ctx, &tuple, sizeof tuple, 0, 0) */ \
474b584ab88SJoe Stringer BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), \
475b584ab88SJoe Stringer BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -48), \
476b584ab88SJoe Stringer BPF_MOV64_IMM(BPF_REG_3, sizeof(struct bpf_sock_tuple)), \
477b584ab88SJoe Stringer BPF_MOV64_IMM(BPF_REG_4, 0), \
478b584ab88SJoe Stringer BPF_MOV64_IMM(BPF_REG_5, 0), \
479dbaf2877SLorenz Bauer BPF_EMIT_CALL(BPF_FUNC_ ## func)
480b584ab88SJoe Stringer
4816ea848b5SJiong Wang /* BPF_DIRECT_PKT_R2 contains 7 instructions, it initializes default return
4826ea848b5SJiong Wang * value into 0 and does necessary preparation for direct packet access
4836ea848b5SJiong Wang * through r2. The allowed access range is 8 bytes.
4846ea848b5SJiong Wang */
4856ea848b5SJiong Wang #define BPF_DIRECT_PKT_R2 \
4866ea848b5SJiong Wang BPF_MOV64_IMM(BPF_REG_0, 0), \
4876ea848b5SJiong Wang BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, \
4886ea848b5SJiong Wang offsetof(struct __sk_buff, data)), \
4896ea848b5SJiong Wang BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, \
4906ea848b5SJiong Wang offsetof(struct __sk_buff, data_end)), \
4916ea848b5SJiong Wang BPF_MOV64_REG(BPF_REG_4, BPF_REG_2), \
4926ea848b5SJiong Wang BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8), \
4936ea848b5SJiong Wang BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1), \
4946ea848b5SJiong Wang BPF_EXIT_INSN()
4956ea848b5SJiong Wang
4966ea848b5SJiong Wang /* BPF_RAND_UEXT_R7 contains 4 instructions, it initializes R7 into a random
4976ea848b5SJiong Wang * positive u32, and zero-extend it into 64-bit.
4986ea848b5SJiong Wang */
4996ea848b5SJiong Wang #define BPF_RAND_UEXT_R7 \
5006ea848b5SJiong Wang BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, \
5016ea848b5SJiong Wang BPF_FUNC_get_prandom_u32), \
5026ea848b5SJiong Wang BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), \
5036ea848b5SJiong Wang BPF_ALU64_IMM(BPF_LSH, BPF_REG_7, 33), \
5046ea848b5SJiong Wang BPF_ALU64_IMM(BPF_RSH, BPF_REG_7, 33)
5056ea848b5SJiong Wang
5066ea848b5SJiong Wang /* BPF_RAND_SEXT_R7 contains 5 instructions, it initializes R7 into a random
5076ea848b5SJiong Wang * negative u32, and sign-extend it into 64-bit.
5086ea848b5SJiong Wang */
5096ea848b5SJiong Wang #define BPF_RAND_SEXT_R7 \
5106ea848b5SJiong Wang BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, \
5116ea848b5SJiong Wang BPF_FUNC_get_prandom_u32), \
5126ea848b5SJiong Wang BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), \
5136ea848b5SJiong Wang BPF_ALU64_IMM(BPF_OR, BPF_REG_7, 0x80000000), \
5146ea848b5SJiong Wang BPF_ALU64_IMM(BPF_LSH, BPF_REG_7, 32), \
5156ea848b5SJiong Wang BPF_ALU64_IMM(BPF_ARSH, BPF_REG_7, 32)
5166ea848b5SJiong Wang
5175aa5bd14SDaniel Borkmann static struct bpf_test tests[] = {
5182dfb4012SJakub Kicinski #define FILL_ARRAY
5192dfb4012SJakub Kicinski #include <verifier/tests.h>
5202dfb4012SJakub Kicinski #undef FILL_ARRAY
5215aa5bd14SDaniel Borkmann };
5225aa5bd14SDaniel Borkmann
probe_filter_length(const struct bpf_insn * fp)5235aa5bd14SDaniel Borkmann static int probe_filter_length(const struct bpf_insn *fp)
5245aa5bd14SDaniel Borkmann {
5255aa5bd14SDaniel Borkmann int len;
5265aa5bd14SDaniel Borkmann
5275aa5bd14SDaniel Borkmann for (len = MAX_INSNS - 1; len > 0; --len)
5285aa5bd14SDaniel Borkmann if (fp[len].code != 0 || fp[len].imm != 0)
5295aa5bd14SDaniel Borkmann break;
5305aa5bd14SDaniel Borkmann return len + 1;
5315aa5bd14SDaniel Borkmann }
5325aa5bd14SDaniel Borkmann
skip_unsupported_map(enum bpf_map_type map_type)5339acea337SStanislav Fomichev static bool skip_unsupported_map(enum bpf_map_type map_type)
5349acea337SStanislav Fomichev {
53532e608f8SAndrii Nakryiko if (!libbpf_probe_bpf_map_type(map_type, NULL)) {
5369acea337SStanislav Fomichev printf("SKIP (unsupported map type %d)\n", map_type);
5379acea337SStanislav Fomichev skips++;
5389acea337SStanislav Fomichev return true;
5399acea337SStanislav Fomichev }
5409acea337SStanislav Fomichev return false;
5419acea337SStanislav Fomichev }
5429acea337SStanislav Fomichev
__create_map(uint32_t type,uint32_t size_key,uint32_t size_value,uint32_t max_elem,uint32_t extra_flags)543fb2abb73SDaniel Borkmann static int __create_map(uint32_t type, uint32_t size_key,
544fb2abb73SDaniel Borkmann uint32_t size_value, uint32_t max_elem,
545fb2abb73SDaniel Borkmann uint32_t extra_flags)
5465aa5bd14SDaniel Borkmann {
5472fe256a4SAndrii Nakryiko LIBBPF_OPTS(bpf_map_create_opts, opts);
5485aa5bd14SDaniel Borkmann int fd;
5495aa5bd14SDaniel Borkmann
5502fe256a4SAndrii Nakryiko opts.map_flags = (type == BPF_MAP_TYPE_HASH ? BPF_F_NO_PREALLOC : 0) | extra_flags;
5512fe256a4SAndrii Nakryiko fd = bpf_map_create(type, NULL, size_key, size_value, max_elem, &opts);
5529acea337SStanislav Fomichev if (fd < 0) {
5539acea337SStanislav Fomichev if (skip_unsupported_map(type))
5549acea337SStanislav Fomichev return -1;
5555aa5bd14SDaniel Borkmann printf("Failed to create hash map '%s'!\n", strerror(errno));
5569acea337SStanislav Fomichev }
5575aa5bd14SDaniel Borkmann
5585aa5bd14SDaniel Borkmann return fd;
5595aa5bd14SDaniel Borkmann }
5605aa5bd14SDaniel Borkmann
create_map(uint32_t type,uint32_t size_key,uint32_t size_value,uint32_t max_elem)561fb2abb73SDaniel Borkmann static int create_map(uint32_t type, uint32_t size_key,
562fb2abb73SDaniel Borkmann uint32_t size_value, uint32_t max_elem)
563fb2abb73SDaniel Borkmann {
564fb2abb73SDaniel Borkmann return __create_map(type, size_key, size_value, max_elem, 0);
565fb2abb73SDaniel Borkmann }
566fb2abb73SDaniel Borkmann
update_map(int fd,int index)56780c9b2faSDaniel Borkmann static void update_map(int fd, int index)
56880c9b2faSDaniel Borkmann {
56980c9b2faSDaniel Borkmann struct test_val value = {
57080c9b2faSDaniel Borkmann .index = (6 + 1) * sizeof(int),
57180c9b2faSDaniel Borkmann .foo[6] = 0xabcdef12,
57280c9b2faSDaniel Borkmann };
57380c9b2faSDaniel Borkmann
57480c9b2faSDaniel Borkmann assert(!bpf_map_update_elem(fd, &index, &value, 0));
57580c9b2faSDaniel Borkmann }
57680c9b2faSDaniel Borkmann
create_prog_dummy_simple(enum bpf_prog_type prog_type,int ret)5773123d801SDaniel Borkmann static int create_prog_dummy_simple(enum bpf_prog_type prog_type, int ret)
578b33eb735SDaniel Borkmann {
579b33eb735SDaniel Borkmann struct bpf_insn prog[] = {
5803123d801SDaniel Borkmann BPF_MOV64_IMM(BPF_REG_0, ret),
581b33eb735SDaniel Borkmann BPF_EXIT_INSN(),
582b33eb735SDaniel Borkmann };
583b33eb735SDaniel Borkmann
584d8e86407SAndrii Nakryiko return bpf_prog_load(prog_type, NULL, "GPL", prog, ARRAY_SIZE(prog), NULL);
585b33eb735SDaniel Borkmann }
586b33eb735SDaniel Borkmann
create_prog_dummy_loop(enum bpf_prog_type prog_type,int mfd,int idx,int ret)5873123d801SDaniel Borkmann static int create_prog_dummy_loop(enum bpf_prog_type prog_type, int mfd,
5883123d801SDaniel Borkmann int idx, int ret)
589b33eb735SDaniel Borkmann {
590b33eb735SDaniel Borkmann struct bpf_insn prog[] = {
591b33eb735SDaniel Borkmann BPF_MOV64_IMM(BPF_REG_3, idx),
592b33eb735SDaniel Borkmann BPF_LD_MAP_FD(BPF_REG_2, mfd),
593b33eb735SDaniel Borkmann BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
594b33eb735SDaniel Borkmann BPF_FUNC_tail_call),
5953123d801SDaniel Borkmann BPF_MOV64_IMM(BPF_REG_0, ret),
596b33eb735SDaniel Borkmann BPF_EXIT_INSN(),
597b33eb735SDaniel Borkmann };
598b33eb735SDaniel Borkmann
599d8e86407SAndrii Nakryiko return bpf_prog_load(prog_type, NULL, "GPL", prog, ARRAY_SIZE(prog), NULL);
600b33eb735SDaniel Borkmann }
601b33eb735SDaniel Borkmann
create_prog_array(enum bpf_prog_type prog_type,uint32_t max_elem,int p1key,int p2key,int p3key)602aca1a80eSStanislav Fomichev static int create_prog_array(enum bpf_prog_type prog_type, uint32_t max_elem,
6033123d801SDaniel Borkmann int p1key, int p2key, int p3key)
6045aa5bd14SDaniel Borkmann {
6053123d801SDaniel Borkmann int mfd, p1fd, p2fd, p3fd;
6065aa5bd14SDaniel Borkmann
6072fe256a4SAndrii Nakryiko mfd = bpf_map_create(BPF_MAP_TYPE_PROG_ARRAY, NULL, sizeof(int),
6082fe256a4SAndrii Nakryiko sizeof(int), max_elem, NULL);
609b33eb735SDaniel Borkmann if (mfd < 0) {
6109acea337SStanislav Fomichev if (skip_unsupported_map(BPF_MAP_TYPE_PROG_ARRAY))
6119acea337SStanislav Fomichev return -1;
6125aa5bd14SDaniel Borkmann printf("Failed to create prog array '%s'!\n", strerror(errno));
613b33eb735SDaniel Borkmann return -1;
614b33eb735SDaniel Borkmann }
6155aa5bd14SDaniel Borkmann
6163123d801SDaniel Borkmann p1fd = create_prog_dummy_simple(prog_type, 42);
6173123d801SDaniel Borkmann p2fd = create_prog_dummy_loop(prog_type, mfd, p2key, 41);
6183123d801SDaniel Borkmann p3fd = create_prog_dummy_simple(prog_type, 24);
6193123d801SDaniel Borkmann if (p1fd < 0 || p2fd < 0 || p3fd < 0)
6203123d801SDaniel Borkmann goto err;
621b33eb735SDaniel Borkmann if (bpf_map_update_elem(mfd, &p1key, &p1fd, BPF_ANY) < 0)
6223123d801SDaniel Borkmann goto err;
623b33eb735SDaniel Borkmann if (bpf_map_update_elem(mfd, &p2key, &p2fd, BPF_ANY) < 0)
6243123d801SDaniel Borkmann goto err;
6253123d801SDaniel Borkmann if (bpf_map_update_elem(mfd, &p3key, &p3fd, BPF_ANY) < 0) {
6263123d801SDaniel Borkmann err:
627b33eb735SDaniel Borkmann close(mfd);
6283123d801SDaniel Borkmann mfd = -1;
6293123d801SDaniel Borkmann }
6303123d801SDaniel Borkmann close(p3fd);
6313123d801SDaniel Borkmann close(p2fd);
6323123d801SDaniel Borkmann close(p1fd);
6333123d801SDaniel Borkmann return mfd;
6345aa5bd14SDaniel Borkmann }
6355aa5bd14SDaniel Borkmann
create_map_in_map(void)636fb30d4b7SMartin KaFai Lau static int create_map_in_map(void)
637fb30d4b7SMartin KaFai Lau {
6382fe256a4SAndrii Nakryiko LIBBPF_OPTS(bpf_map_create_opts, opts);
639fb30d4b7SMartin KaFai Lau int inner_map_fd, outer_map_fd;
640fb30d4b7SMartin KaFai Lau
6412fe256a4SAndrii Nakryiko inner_map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, sizeof(int),
6422fe256a4SAndrii Nakryiko sizeof(int), 1, NULL);
643fb30d4b7SMartin KaFai Lau if (inner_map_fd < 0) {
6449acea337SStanislav Fomichev if (skip_unsupported_map(BPF_MAP_TYPE_ARRAY))
6459acea337SStanislav Fomichev return -1;
646fb30d4b7SMartin KaFai Lau printf("Failed to create array '%s'!\n", strerror(errno));
647fb30d4b7SMartin KaFai Lau return inner_map_fd;
648fb30d4b7SMartin KaFai Lau }
649fb30d4b7SMartin KaFai Lau
6502fe256a4SAndrii Nakryiko opts.inner_map_fd = inner_map_fd;
6512fe256a4SAndrii Nakryiko outer_map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY_OF_MAPS, NULL,
6522fe256a4SAndrii Nakryiko sizeof(int), sizeof(int), 1, &opts);
6539acea337SStanislav Fomichev if (outer_map_fd < 0) {
6549acea337SStanislav Fomichev if (skip_unsupported_map(BPF_MAP_TYPE_ARRAY_OF_MAPS))
6559acea337SStanislav Fomichev return -1;
656fb30d4b7SMartin KaFai Lau printf("Failed to create array of maps '%s'!\n",
657fb30d4b7SMartin KaFai Lau strerror(errno));
6589acea337SStanislav Fomichev }
659fb30d4b7SMartin KaFai Lau
660fb30d4b7SMartin KaFai Lau close(inner_map_fd);
661fb30d4b7SMartin KaFai Lau
662fb30d4b7SMartin KaFai Lau return outer_map_fd;
663fb30d4b7SMartin KaFai Lau }
664fb30d4b7SMartin KaFai Lau
create_cgroup_storage(bool percpu)665a3c6054fSRoman Gushchin static int create_cgroup_storage(bool percpu)
666d4c9f573SRoman Gushchin {
667a3c6054fSRoman Gushchin enum bpf_map_type type = percpu ? BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE :
668a3c6054fSRoman Gushchin BPF_MAP_TYPE_CGROUP_STORAGE;
669d4c9f573SRoman Gushchin int fd;
670d4c9f573SRoman Gushchin
6712fe256a4SAndrii Nakryiko fd = bpf_map_create(type, NULL, sizeof(struct bpf_cgroup_storage_key),
6722fe256a4SAndrii Nakryiko TEST_DATA_LEN, 0, NULL);
6739acea337SStanislav Fomichev if (fd < 0) {
6749acea337SStanislav Fomichev if (skip_unsupported_map(type))
6759acea337SStanislav Fomichev return -1;
676a3c6054fSRoman Gushchin printf("Failed to create cgroup storage '%s'!\n",
677a3c6054fSRoman Gushchin strerror(errno));
6789acea337SStanislav Fomichev }
679d4c9f573SRoman Gushchin
680d4c9f573SRoman Gushchin return fd;
681d4c9f573SRoman Gushchin }
682d4c9f573SRoman Gushchin
683b4d4556cSAlexei Starovoitov /* struct bpf_spin_lock {
684b4d4556cSAlexei Starovoitov * int val;
685b4d4556cSAlexei Starovoitov * };
686b4d4556cSAlexei Starovoitov * struct val {
687b4d4556cSAlexei Starovoitov * int cnt;
688b4d4556cSAlexei Starovoitov * struct bpf_spin_lock l;
689b4d4556cSAlexei Starovoitov * };
690e60e6962SDmitrii Banshchikov * struct bpf_timer {
691e60e6962SDmitrii Banshchikov * __u64 :64;
692e60e6962SDmitrii Banshchikov * __u64 :64;
693e60e6962SDmitrii Banshchikov * } __attribute__((aligned(8)));
694e60e6962SDmitrii Banshchikov * struct timer {
695e60e6962SDmitrii Banshchikov * struct bpf_timer t;
696e60e6962SDmitrii Banshchikov * };
69705a945deSKumar Kartikeya Dwivedi * struct btf_ptr {
69803b77e17SAlexei Starovoitov * struct prog_test_ref_kfunc __kptr_untrusted *ptr;
69905a945deSKumar Kartikeya Dwivedi * struct prog_test_ref_kfunc __kptr *ptr;
70003b77e17SAlexei Starovoitov * struct prog_test_member __kptr *ptr;
70105a945deSKumar Kartikeya Dwivedi * }
702b4d4556cSAlexei Starovoitov */
70305a945deSKumar Kartikeya Dwivedi static const char btf_str_sec[] = "\0bpf_spin_lock\0val\0cnt\0l\0bpf_timer\0timer\0t"
70403b77e17SAlexei Starovoitov "\0btf_ptr\0prog_test_ref_kfunc\0ptr\0kptr\0kptr_untrusted"
70505a945deSKumar Kartikeya Dwivedi "\0prog_test_member";
706b4d4556cSAlexei Starovoitov static __u32 btf_raw_types[] = {
707b4d4556cSAlexei Starovoitov /* int */
708b4d4556cSAlexei Starovoitov BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
709b4d4556cSAlexei Starovoitov /* struct bpf_spin_lock */ /* [2] */
710b4d4556cSAlexei Starovoitov BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),
711b4d4556cSAlexei Starovoitov BTF_MEMBER_ENC(15, 1, 0), /* int val; */
712b4d4556cSAlexei Starovoitov /* struct val */ /* [3] */
713b4d4556cSAlexei Starovoitov BTF_TYPE_ENC(15, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
714b4d4556cSAlexei Starovoitov BTF_MEMBER_ENC(19, 1, 0), /* int cnt; */
715b4d4556cSAlexei Starovoitov BTF_MEMBER_ENC(23, 2, 32),/* struct bpf_spin_lock l; */
716e60e6962SDmitrii Banshchikov /* struct bpf_timer */ /* [4] */
717e60e6962SDmitrii Banshchikov BTF_TYPE_ENC(25, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 0), 16),
718e60e6962SDmitrii Banshchikov /* struct timer */ /* [5] */
719e60e6962SDmitrii Banshchikov BTF_TYPE_ENC(35, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16),
720e60e6962SDmitrii Banshchikov BTF_MEMBER_ENC(41, 4, 0), /* struct bpf_timer t; */
72105a945deSKumar Kartikeya Dwivedi /* struct prog_test_ref_kfunc */ /* [6] */
72205a945deSKumar Kartikeya Dwivedi BTF_STRUCT_ENC(51, 0, 0),
72303b77e17SAlexei Starovoitov BTF_STRUCT_ENC(95, 0, 0), /* [7] */
72403b77e17SAlexei Starovoitov /* type tag "kptr_untrusted" */
72503b77e17SAlexei Starovoitov BTF_TYPE_TAG_ENC(80, 6), /* [8] */
72605a945deSKumar Kartikeya Dwivedi /* type tag "kptr" */
72703b77e17SAlexei Starovoitov BTF_TYPE_TAG_ENC(75, 6), /* [9] */
72803b77e17SAlexei Starovoitov BTF_TYPE_TAG_ENC(75, 7), /* [10] */
72905a945deSKumar Kartikeya Dwivedi BTF_PTR_ENC(8), /* [11] */
73005a945deSKumar Kartikeya Dwivedi BTF_PTR_ENC(9), /* [12] */
73105a945deSKumar Kartikeya Dwivedi BTF_PTR_ENC(10), /* [13] */
73205a945deSKumar Kartikeya Dwivedi /* struct btf_ptr */ /* [14] */
73305a945deSKumar Kartikeya Dwivedi BTF_STRUCT_ENC(43, 3, 24),
73403b77e17SAlexei Starovoitov BTF_MEMBER_ENC(71, 11, 0), /* struct prog_test_ref_kfunc __kptr_untrusted *ptr; */
73503b77e17SAlexei Starovoitov BTF_MEMBER_ENC(71, 12, 64), /* struct prog_test_ref_kfunc __kptr *ptr; */
73603b77e17SAlexei Starovoitov BTF_MEMBER_ENC(71, 13, 128), /* struct prog_test_member __kptr *ptr; */
737b4d4556cSAlexei Starovoitov };
738b4d4556cSAlexei Starovoitov
7397a42008cSEduard Zingerman static char bpf_vlog[UINT_MAX >> 8];
7407a42008cSEduard Zingerman
load_btf_spec(__u32 * types,int types_len,const char * strings,int strings_len)7417a42008cSEduard Zingerman static int load_btf_spec(__u32 *types, int types_len,
7427a42008cSEduard Zingerman const char *strings, int strings_len)
743b4d4556cSAlexei Starovoitov {
744b4d4556cSAlexei Starovoitov struct btf_header hdr = {
745b4d4556cSAlexei Starovoitov .magic = BTF_MAGIC,
746b4d4556cSAlexei Starovoitov .version = BTF_VERSION,
747b4d4556cSAlexei Starovoitov .hdr_len = sizeof(struct btf_header),
7487a42008cSEduard Zingerman .type_len = types_len,
7497a42008cSEduard Zingerman .str_off = types_len,
7507a42008cSEduard Zingerman .str_len = strings_len,
751b4d4556cSAlexei Starovoitov };
752b4d4556cSAlexei Starovoitov void *ptr, *raw_btf;
753b4d4556cSAlexei Starovoitov int btf_fd;
7547a42008cSEduard Zingerman LIBBPF_OPTS(bpf_btf_load_opts, opts,
7557a42008cSEduard Zingerman .log_buf = bpf_vlog,
7567a42008cSEduard Zingerman .log_size = sizeof(bpf_vlog),
7577a42008cSEduard Zingerman .log_level = (verbose
7582a72f595SAndrii Nakryiko ? verif_log_level
7597a42008cSEduard Zingerman : DEFAULT_LIBBPF_LOG_LEVEL),
7607a42008cSEduard Zingerman );
761b4d4556cSAlexei Starovoitov
7627a42008cSEduard Zingerman raw_btf = malloc(sizeof(hdr) + types_len + strings_len);
763b4d4556cSAlexei Starovoitov
7647a42008cSEduard Zingerman ptr = raw_btf;
765b4d4556cSAlexei Starovoitov memcpy(ptr, &hdr, sizeof(hdr));
766b4d4556cSAlexei Starovoitov ptr += sizeof(hdr);
7677a42008cSEduard Zingerman memcpy(ptr, types, hdr.type_len);
768b4d4556cSAlexei Starovoitov ptr += hdr.type_len;
7697a42008cSEduard Zingerman memcpy(ptr, strings, hdr.str_len);
770b4d4556cSAlexei Starovoitov ptr += hdr.str_len;
771b4d4556cSAlexei Starovoitov
7727a42008cSEduard Zingerman btf_fd = bpf_btf_load(raw_btf, ptr - raw_btf, &opts);
773b4d4556cSAlexei Starovoitov if (btf_fd < 0)
7747a42008cSEduard Zingerman printf("Failed to load BTF spec: '%s'\n", strerror(errno));
7757a42008cSEduard Zingerman
7767a42008cSEduard Zingerman free(raw_btf);
7777a42008cSEduard Zingerman
7787a42008cSEduard Zingerman return btf_fd < 0 ? -1 : btf_fd;
7797a42008cSEduard Zingerman }
7807a42008cSEduard Zingerman
load_btf(void)7817a42008cSEduard Zingerman static int load_btf(void)
7827a42008cSEduard Zingerman {
7837a42008cSEduard Zingerman return load_btf_spec(btf_raw_types, sizeof(btf_raw_types),
7847a42008cSEduard Zingerman btf_str_sec, sizeof(btf_str_sec));
7857a42008cSEduard Zingerman }
7867a42008cSEduard Zingerman
load_btf_for_test(struct bpf_test * test)7877a42008cSEduard Zingerman static int load_btf_for_test(struct bpf_test *test)
7887a42008cSEduard Zingerman {
7897a42008cSEduard Zingerman int types_num = 0;
7907a42008cSEduard Zingerman
7917a42008cSEduard Zingerman while (types_num < MAX_BTF_TYPES &&
7927a42008cSEduard Zingerman test->btf_types[types_num] != BTF_END_RAW)
7937a42008cSEduard Zingerman ++types_num;
7947a42008cSEduard Zingerman
7957a42008cSEduard Zingerman int types_len = types_num * sizeof(test->btf_types[0]);
7967a42008cSEduard Zingerman
7977a42008cSEduard Zingerman return load_btf_spec(test->btf_types, types_len,
7987a42008cSEduard Zingerman test->btf_strings, sizeof(test->btf_strings));
799b4d4556cSAlexei Starovoitov }
800b4d4556cSAlexei Starovoitov
create_map_spin_lock(void)801b4d4556cSAlexei Starovoitov static int create_map_spin_lock(void)
802b4d4556cSAlexei Starovoitov {
8032fe256a4SAndrii Nakryiko LIBBPF_OPTS(bpf_map_create_opts, opts,
804b4d4556cSAlexei Starovoitov .btf_key_type_id = 1,
805b4d4556cSAlexei Starovoitov .btf_value_type_id = 3,
8062fe256a4SAndrii Nakryiko );
807b4d4556cSAlexei Starovoitov int fd, btf_fd;
808b4d4556cSAlexei Starovoitov
809b4d4556cSAlexei Starovoitov btf_fd = load_btf();
810b4d4556cSAlexei Starovoitov if (btf_fd < 0)
811b4d4556cSAlexei Starovoitov return -1;
8122fe256a4SAndrii Nakryiko opts.btf_fd = btf_fd;
8132fe256a4SAndrii Nakryiko fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_map", 4, 8, 1, &opts);
814b4d4556cSAlexei Starovoitov if (fd < 0)
815b4d4556cSAlexei Starovoitov printf("Failed to create map with spin_lock\n");
816b4d4556cSAlexei Starovoitov return fd;
817b4d4556cSAlexei Starovoitov }
818b4d4556cSAlexei Starovoitov
create_sk_storage_map(void)8197a9bb976SMartin KaFai Lau static int create_sk_storage_map(void)
8207a9bb976SMartin KaFai Lau {
8212fe256a4SAndrii Nakryiko LIBBPF_OPTS(bpf_map_create_opts, opts,
8227a9bb976SMartin KaFai Lau .map_flags = BPF_F_NO_PREALLOC,
8237a9bb976SMartin KaFai Lau .btf_key_type_id = 1,
8247a9bb976SMartin KaFai Lau .btf_value_type_id = 3,
8252fe256a4SAndrii Nakryiko );
8267a9bb976SMartin KaFai Lau int fd, btf_fd;
8277a9bb976SMartin KaFai Lau
8287a9bb976SMartin KaFai Lau btf_fd = load_btf();
8297a9bb976SMartin KaFai Lau if (btf_fd < 0)
8307a9bb976SMartin KaFai Lau return -1;
8312fe256a4SAndrii Nakryiko opts.btf_fd = btf_fd;
8322fe256a4SAndrii Nakryiko fd = bpf_map_create(BPF_MAP_TYPE_SK_STORAGE, "test_map", 4, 8, 0, &opts);
8332fe256a4SAndrii Nakryiko close(opts.btf_fd);
8347a9bb976SMartin KaFai Lau if (fd < 0)
8357a9bb976SMartin KaFai Lau printf("Failed to create sk_storage_map\n");
8367a9bb976SMartin KaFai Lau return fd;
8377a9bb976SMartin KaFai Lau }
8387a9bb976SMartin KaFai Lau
create_map_timer(void)839e60e6962SDmitrii Banshchikov static int create_map_timer(void)
840e60e6962SDmitrii Banshchikov {
841f1246882SAndrii Nakryiko LIBBPF_OPTS(bpf_map_create_opts, opts,
842e60e6962SDmitrii Banshchikov .btf_key_type_id = 1,
843e60e6962SDmitrii Banshchikov .btf_value_type_id = 5,
844f1246882SAndrii Nakryiko );
845e60e6962SDmitrii Banshchikov int fd, btf_fd;
846e60e6962SDmitrii Banshchikov
847e60e6962SDmitrii Banshchikov btf_fd = load_btf();
848e60e6962SDmitrii Banshchikov if (btf_fd < 0)
849e60e6962SDmitrii Banshchikov return -1;
850f1246882SAndrii Nakryiko
851f1246882SAndrii Nakryiko opts.btf_fd = btf_fd;
852f1246882SAndrii Nakryiko fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_map", 4, 16, 1, &opts);
853e60e6962SDmitrii Banshchikov if (fd < 0)
854e60e6962SDmitrii Banshchikov printf("Failed to create map with timer\n");
855e60e6962SDmitrii Banshchikov return fd;
856e60e6962SDmitrii Banshchikov }
857e60e6962SDmitrii Banshchikov
create_map_kptr(void)85805a945deSKumar Kartikeya Dwivedi static int create_map_kptr(void)
85905a945deSKumar Kartikeya Dwivedi {
86005a945deSKumar Kartikeya Dwivedi LIBBPF_OPTS(bpf_map_create_opts, opts,
86105a945deSKumar Kartikeya Dwivedi .btf_key_type_id = 1,
86205a945deSKumar Kartikeya Dwivedi .btf_value_type_id = 14,
86305a945deSKumar Kartikeya Dwivedi );
86405a945deSKumar Kartikeya Dwivedi int fd, btf_fd;
86505a945deSKumar Kartikeya Dwivedi
86605a945deSKumar Kartikeya Dwivedi btf_fd = load_btf();
86705a945deSKumar Kartikeya Dwivedi if (btf_fd < 0)
86805a945deSKumar Kartikeya Dwivedi return -1;
86905a945deSKumar Kartikeya Dwivedi
87005a945deSKumar Kartikeya Dwivedi opts.btf_fd = btf_fd;
87105a945deSKumar Kartikeya Dwivedi fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_map", 4, 24, 1, &opts);
87205a945deSKumar Kartikeya Dwivedi if (fd < 0)
87305a945deSKumar Kartikeya Dwivedi printf("Failed to create map with btf_id pointer\n");
87405a945deSKumar Kartikeya Dwivedi return fd;
87505a945deSKumar Kartikeya Dwivedi }
87605a945deSKumar Kartikeya Dwivedi
set_root(bool set)877f26ebdd3SJiri Olsa static void set_root(bool set)
878f26ebdd3SJiri Olsa {
879f26ebdd3SJiri Olsa __u64 caps;
880f26ebdd3SJiri Olsa
881f26ebdd3SJiri Olsa if (set) {
882f26ebdd3SJiri Olsa if (cap_enable_effective(1ULL << CAP_SYS_ADMIN, &caps))
883f26ebdd3SJiri Olsa perror("cap_disable_effective(CAP_SYS_ADMIN)");
884f26ebdd3SJiri Olsa } else {
885f26ebdd3SJiri Olsa if (cap_disable_effective(1ULL << CAP_SYS_ADMIN, &caps))
886f26ebdd3SJiri Olsa perror("cap_disable_effective(CAP_SYS_ADMIN)");
887f26ebdd3SJiri Olsa }
888f26ebdd3SJiri Olsa }
889f26ebdd3SJiri Olsa
ptr_to_u64(const void * ptr)890f26ebdd3SJiri Olsa static __u64 ptr_to_u64(const void *ptr)
891f26ebdd3SJiri Olsa {
892f26ebdd3SJiri Olsa return (uintptr_t) ptr;
893f26ebdd3SJiri Olsa }
894f26ebdd3SJiri Olsa
btf__load_testmod_btf(struct btf * vmlinux)895f26ebdd3SJiri Olsa static struct btf *btf__load_testmod_btf(struct btf *vmlinux)
896f26ebdd3SJiri Olsa {
897f26ebdd3SJiri Olsa struct bpf_btf_info info;
898f26ebdd3SJiri Olsa __u32 len = sizeof(info);
899f26ebdd3SJiri Olsa struct btf *btf = NULL;
900f26ebdd3SJiri Olsa char name[64];
901f26ebdd3SJiri Olsa __u32 id = 0;
902f26ebdd3SJiri Olsa int err, fd;
903f26ebdd3SJiri Olsa
904f26ebdd3SJiri Olsa /* Iterate all loaded BTF objects and find bpf_testmod,
905f26ebdd3SJiri Olsa * we need SYS_ADMIN cap for that.
906f26ebdd3SJiri Olsa */
907f26ebdd3SJiri Olsa set_root(true);
908f26ebdd3SJiri Olsa
909f26ebdd3SJiri Olsa while (true) {
910f26ebdd3SJiri Olsa err = bpf_btf_get_next_id(id, &id);
911f26ebdd3SJiri Olsa if (err) {
912f26ebdd3SJiri Olsa if (errno == ENOENT)
913f26ebdd3SJiri Olsa break;
914f26ebdd3SJiri Olsa perror("bpf_btf_get_next_id failed");
915f26ebdd3SJiri Olsa break;
916f26ebdd3SJiri Olsa }
917f26ebdd3SJiri Olsa
918f26ebdd3SJiri Olsa fd = bpf_btf_get_fd_by_id(id);
919f26ebdd3SJiri Olsa if (fd < 0) {
920f26ebdd3SJiri Olsa if (errno == ENOENT)
921f26ebdd3SJiri Olsa continue;
922f26ebdd3SJiri Olsa perror("bpf_btf_get_fd_by_id failed");
923f26ebdd3SJiri Olsa break;
924f26ebdd3SJiri Olsa }
925f26ebdd3SJiri Olsa
926f26ebdd3SJiri Olsa memset(&info, 0, sizeof(info));
927f26ebdd3SJiri Olsa info.name_len = sizeof(name);
928f26ebdd3SJiri Olsa info.name = ptr_to_u64(name);
929f26ebdd3SJiri Olsa len = sizeof(info);
930f26ebdd3SJiri Olsa
931f26ebdd3SJiri Olsa err = bpf_obj_get_info_by_fd(fd, &info, &len);
932f26ebdd3SJiri Olsa if (err) {
933f26ebdd3SJiri Olsa close(fd);
934f26ebdd3SJiri Olsa perror("bpf_obj_get_info_by_fd failed");
935f26ebdd3SJiri Olsa break;
936f26ebdd3SJiri Olsa }
937f26ebdd3SJiri Olsa
938f26ebdd3SJiri Olsa if (strcmp("bpf_testmod", name)) {
939f26ebdd3SJiri Olsa close(fd);
940f26ebdd3SJiri Olsa continue;
941f26ebdd3SJiri Olsa }
942f26ebdd3SJiri Olsa
943f26ebdd3SJiri Olsa btf = btf__load_from_kernel_by_id_split(id, vmlinux);
944f26ebdd3SJiri Olsa if (!btf) {
945f26ebdd3SJiri Olsa close(fd);
946f26ebdd3SJiri Olsa break;
947f26ebdd3SJiri Olsa }
948f26ebdd3SJiri Olsa
949f26ebdd3SJiri Olsa /* We need the fd to stay open so it can be used in fd_array.
950f26ebdd3SJiri Olsa * The final cleanup call to btf__free will free btf object
951f26ebdd3SJiri Olsa * and close the file descriptor.
952f26ebdd3SJiri Olsa */
953f26ebdd3SJiri Olsa btf__set_fd(btf, fd);
954f26ebdd3SJiri Olsa break;
955f26ebdd3SJiri Olsa }
956f26ebdd3SJiri Olsa
957f26ebdd3SJiri Olsa set_root(false);
958f26ebdd3SJiri Olsa return btf;
959f26ebdd3SJiri Olsa }
960f26ebdd3SJiri Olsa
961f26ebdd3SJiri Olsa static struct btf *testmod_btf;
962f26ebdd3SJiri Olsa static struct btf *vmlinux_btf;
963f26ebdd3SJiri Olsa
kfuncs_cleanup(void)964f26ebdd3SJiri Olsa static void kfuncs_cleanup(void)
965f26ebdd3SJiri Olsa {
966f26ebdd3SJiri Olsa btf__free(testmod_btf);
967f26ebdd3SJiri Olsa btf__free(vmlinux_btf);
968f26ebdd3SJiri Olsa }
969f26ebdd3SJiri Olsa
fixup_prog_kfuncs(struct bpf_insn * prog,int * fd_array,struct kfunc_btf_id_pair * fixup_kfunc_btf_id)970f26ebdd3SJiri Olsa static void fixup_prog_kfuncs(struct bpf_insn *prog, int *fd_array,
971f26ebdd3SJiri Olsa struct kfunc_btf_id_pair *fixup_kfunc_btf_id)
972f26ebdd3SJiri Olsa {
973f26ebdd3SJiri Olsa /* Patch in kfunc BTF IDs */
974f26ebdd3SJiri Olsa while (fixup_kfunc_btf_id->kfunc) {
975f26ebdd3SJiri Olsa int btf_id = 0;
976f26ebdd3SJiri Olsa
977f26ebdd3SJiri Olsa /* try to find kfunc in kernel BTF */
978f26ebdd3SJiri Olsa vmlinux_btf = vmlinux_btf ?: btf__load_vmlinux_btf();
979f26ebdd3SJiri Olsa if (vmlinux_btf) {
980f26ebdd3SJiri Olsa btf_id = btf__find_by_name_kind(vmlinux_btf,
981f26ebdd3SJiri Olsa fixup_kfunc_btf_id->kfunc,
982f26ebdd3SJiri Olsa BTF_KIND_FUNC);
983f26ebdd3SJiri Olsa btf_id = btf_id < 0 ? 0 : btf_id;
984f26ebdd3SJiri Olsa }
985f26ebdd3SJiri Olsa
986f26ebdd3SJiri Olsa /* kfunc not found in kernel BTF, try bpf_testmod BTF */
987f26ebdd3SJiri Olsa if (!btf_id) {
988f26ebdd3SJiri Olsa testmod_btf = testmod_btf ?: btf__load_testmod_btf(vmlinux_btf);
989f26ebdd3SJiri Olsa if (testmod_btf) {
990f26ebdd3SJiri Olsa btf_id = btf__find_by_name_kind(testmod_btf,
991f26ebdd3SJiri Olsa fixup_kfunc_btf_id->kfunc,
992f26ebdd3SJiri Olsa BTF_KIND_FUNC);
993f26ebdd3SJiri Olsa btf_id = btf_id < 0 ? 0 : btf_id;
994f26ebdd3SJiri Olsa if (btf_id) {
995f26ebdd3SJiri Olsa /* We put bpf_testmod module fd into fd_array
996f26ebdd3SJiri Olsa * and its index 1 into instruction 'off'.
997f26ebdd3SJiri Olsa */
998f26ebdd3SJiri Olsa *fd_array = btf__fd(testmod_btf);
999f26ebdd3SJiri Olsa prog[fixup_kfunc_btf_id->insn_idx].off = 1;
1000f26ebdd3SJiri Olsa }
1001f26ebdd3SJiri Olsa }
1002f26ebdd3SJiri Olsa }
1003f26ebdd3SJiri Olsa
1004f26ebdd3SJiri Olsa prog[fixup_kfunc_btf_id->insn_idx].imm = btf_id;
1005f26ebdd3SJiri Olsa fixup_kfunc_btf_id++;
1006f26ebdd3SJiri Olsa }
1007f26ebdd3SJiri Olsa }
1008f26ebdd3SJiri Olsa
do_test_fixup(struct bpf_test * test,enum bpf_prog_type prog_type,struct bpf_insn * prog,int * map_fds,int * fd_array)1009aca1a80eSStanislav Fomichev static void do_test_fixup(struct bpf_test *test, enum bpf_prog_type prog_type,
1010f26ebdd3SJiri Olsa struct bpf_insn *prog, int *map_fds, int *fd_array)
10115aa5bd14SDaniel Borkmann {
1012908142e6SPrashant Bhole int *fixup_map_hash_8b = test->fixup_map_hash_8b;
1013908142e6SPrashant Bhole int *fixup_map_hash_48b = test->fixup_map_hash_48b;
1014908142e6SPrashant Bhole int *fixup_map_hash_16b = test->fixup_map_hash_16b;
1015908142e6SPrashant Bhole int *fixup_map_array_48b = test->fixup_map_array_48b;
10167c85c448SPrashant Bhole int *fixup_map_sockmap = test->fixup_map_sockmap;
10177c85c448SPrashant Bhole int *fixup_map_sockhash = test->fixup_map_sockhash;
10187c85c448SPrashant Bhole int *fixup_map_xskmap = test->fixup_map_xskmap;
10197c85c448SPrashant Bhole int *fixup_map_stacktrace = test->fixup_map_stacktrace;
102006be0864SDaniel Borkmann int *fixup_prog1 = test->fixup_prog1;
102106be0864SDaniel Borkmann int *fixup_prog2 = test->fixup_prog2;
1022fb30d4b7SMartin KaFai Lau int *fixup_map_in_map = test->fixup_map_in_map;
1023d4c9f573SRoman Gushchin int *fixup_cgroup_storage = test->fixup_cgroup_storage;
1024a3c6054fSRoman Gushchin int *fixup_percpu_cgroup_storage = test->fixup_percpu_cgroup_storage;
1025b4d4556cSAlexei Starovoitov int *fixup_map_spin_lock = test->fixup_map_spin_lock;
1026fb2abb73SDaniel Borkmann int *fixup_map_array_ro = test->fixup_map_array_ro;
1027fb2abb73SDaniel Borkmann int *fixup_map_array_wo = test->fixup_map_array_wo;
1028fb2abb73SDaniel Borkmann int *fixup_map_array_small = test->fixup_map_array_small;
10297a9bb976SMartin KaFai Lau int *fixup_sk_storage_map = test->fixup_sk_storage_map;
103003cd1d1aSAllan Zhang int *fixup_map_event_output = test->fixup_map_event_output;
1031c3210222SJakub Sitnicki int *fixup_map_reuseport_array = test->fixup_map_reuseport_array;
10324237e9f4SGilad Reti int *fixup_map_ringbuf = test->fixup_map_ringbuf;
1033e60e6962SDmitrii Banshchikov int *fixup_map_timer = test->fixup_map_timer;
103405a945deSKumar Kartikeya Dwivedi int *fixup_map_kptr = test->fixup_map_kptr;
10355aa5bd14SDaniel Borkmann
10368aa2d4b4SAlexei Starovoitov if (test->fill_helper) {
10378aa2d4b4SAlexei Starovoitov test->fill_insns = calloc(MAX_TEST_INSNS, sizeof(struct bpf_insn));
103893731ef0SDaniel Borkmann test->fill_helper(test);
10398aa2d4b4SAlexei Starovoitov }
104093731ef0SDaniel Borkmann
10415aa5bd14SDaniel Borkmann /* Allocating HTs with 1 elem is fine here, since we only test
10425aa5bd14SDaniel Borkmann * for verifier and not do a runtime lookup, so the only thing
10435aa5bd14SDaniel Borkmann * that really matters is value size in this case.
10445aa5bd14SDaniel Borkmann */
1045908142e6SPrashant Bhole if (*fixup_map_hash_8b) {
104606be0864SDaniel Borkmann map_fds[0] = create_map(BPF_MAP_TYPE_HASH, sizeof(long long),
104706be0864SDaniel Borkmann sizeof(long long), 1);
10485aa5bd14SDaniel Borkmann do {
1049908142e6SPrashant Bhole prog[*fixup_map_hash_8b].imm = map_fds[0];
1050908142e6SPrashant Bhole fixup_map_hash_8b++;
1051908142e6SPrashant Bhole } while (*fixup_map_hash_8b);
10525aa5bd14SDaniel Borkmann }
10535aa5bd14SDaniel Borkmann
1054908142e6SPrashant Bhole if (*fixup_map_hash_48b) {
105506be0864SDaniel Borkmann map_fds[1] = create_map(BPF_MAP_TYPE_HASH, sizeof(long long),
105606be0864SDaniel Borkmann sizeof(struct test_val), 1);
10575aa5bd14SDaniel Borkmann do {
1058908142e6SPrashant Bhole prog[*fixup_map_hash_48b].imm = map_fds[1];
1059908142e6SPrashant Bhole fixup_map_hash_48b++;
1060908142e6SPrashant Bhole } while (*fixup_map_hash_48b);
10615aa5bd14SDaniel Borkmann }
10625aa5bd14SDaniel Borkmann
1063908142e6SPrashant Bhole if (*fixup_map_hash_16b) {
106406be0864SDaniel Borkmann map_fds[2] = create_map(BPF_MAP_TYPE_HASH, sizeof(long long),
106506be0864SDaniel Borkmann sizeof(struct other_val), 1);
10665f90dd6aSPaul Chaignon do {
1067908142e6SPrashant Bhole prog[*fixup_map_hash_16b].imm = map_fds[2];
1068908142e6SPrashant Bhole fixup_map_hash_16b++;
1069908142e6SPrashant Bhole } while (*fixup_map_hash_16b);
10705f90dd6aSPaul Chaignon }
10715f90dd6aSPaul Chaignon
1072908142e6SPrashant Bhole if (*fixup_map_array_48b) {
107306be0864SDaniel Borkmann map_fds[3] = create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
107406be0864SDaniel Borkmann sizeof(struct test_val), 1);
107580c9b2faSDaniel Borkmann update_map(map_fds[3], 0);
10765aa5bd14SDaniel Borkmann do {
1077908142e6SPrashant Bhole prog[*fixup_map_array_48b].imm = map_fds[3];
1078908142e6SPrashant Bhole fixup_map_array_48b++;
1079908142e6SPrashant Bhole } while (*fixup_map_array_48b);
108006be0864SDaniel Borkmann }
108106be0864SDaniel Borkmann
108206be0864SDaniel Borkmann if (*fixup_prog1) {
10833123d801SDaniel Borkmann map_fds[4] = create_prog_array(prog_type, 4, 0, 1, 2);
108406be0864SDaniel Borkmann do {
108506be0864SDaniel Borkmann prog[*fixup_prog1].imm = map_fds[4];
108606be0864SDaniel Borkmann fixup_prog1++;
108706be0864SDaniel Borkmann } while (*fixup_prog1);
108806be0864SDaniel Borkmann }
108906be0864SDaniel Borkmann
109006be0864SDaniel Borkmann if (*fixup_prog2) {
10913123d801SDaniel Borkmann map_fds[5] = create_prog_array(prog_type, 8, 7, 1, 2);
109206be0864SDaniel Borkmann do {
109306be0864SDaniel Borkmann prog[*fixup_prog2].imm = map_fds[5];
109406be0864SDaniel Borkmann fixup_prog2++;
109506be0864SDaniel Borkmann } while (*fixup_prog2);
10965aa5bd14SDaniel Borkmann }
1097fb30d4b7SMartin KaFai Lau
1098fb30d4b7SMartin KaFai Lau if (*fixup_map_in_map) {
109906be0864SDaniel Borkmann map_fds[6] = create_map_in_map();
1100fb30d4b7SMartin KaFai Lau do {
110106be0864SDaniel Borkmann prog[*fixup_map_in_map].imm = map_fds[6];
1102fb30d4b7SMartin KaFai Lau fixup_map_in_map++;
1103fb30d4b7SMartin KaFai Lau } while (*fixup_map_in_map);
1104fb30d4b7SMartin KaFai Lau }
1105d4c9f573SRoman Gushchin
1106d4c9f573SRoman Gushchin if (*fixup_cgroup_storage) {
1107a3c6054fSRoman Gushchin map_fds[7] = create_cgroup_storage(false);
1108d4c9f573SRoman Gushchin do {
1109d4c9f573SRoman Gushchin prog[*fixup_cgroup_storage].imm = map_fds[7];
1110d4c9f573SRoman Gushchin fixup_cgroup_storage++;
1111d4c9f573SRoman Gushchin } while (*fixup_cgroup_storage);
1112d4c9f573SRoman Gushchin }
1113a3c6054fSRoman Gushchin
1114a3c6054fSRoman Gushchin if (*fixup_percpu_cgroup_storage) {
1115a3c6054fSRoman Gushchin map_fds[8] = create_cgroup_storage(true);
1116a3c6054fSRoman Gushchin do {
1117a3c6054fSRoman Gushchin prog[*fixup_percpu_cgroup_storage].imm = map_fds[8];
1118a3c6054fSRoman Gushchin fixup_percpu_cgroup_storage++;
1119a3c6054fSRoman Gushchin } while (*fixup_percpu_cgroup_storage);
1120a3c6054fSRoman Gushchin }
11217c85c448SPrashant Bhole if (*fixup_map_sockmap) {
11227c85c448SPrashant Bhole map_fds[9] = create_map(BPF_MAP_TYPE_SOCKMAP, sizeof(int),
11237c85c448SPrashant Bhole sizeof(int), 1);
11247c85c448SPrashant Bhole do {
11257c85c448SPrashant Bhole prog[*fixup_map_sockmap].imm = map_fds[9];
11267c85c448SPrashant Bhole fixup_map_sockmap++;
11277c85c448SPrashant Bhole } while (*fixup_map_sockmap);
11287c85c448SPrashant Bhole }
11297c85c448SPrashant Bhole if (*fixup_map_sockhash) {
11307c85c448SPrashant Bhole map_fds[10] = create_map(BPF_MAP_TYPE_SOCKHASH, sizeof(int),
11317c85c448SPrashant Bhole sizeof(int), 1);
11327c85c448SPrashant Bhole do {
11337c85c448SPrashant Bhole prog[*fixup_map_sockhash].imm = map_fds[10];
11347c85c448SPrashant Bhole fixup_map_sockhash++;
11357c85c448SPrashant Bhole } while (*fixup_map_sockhash);
11367c85c448SPrashant Bhole }
11377c85c448SPrashant Bhole if (*fixup_map_xskmap) {
11387c85c448SPrashant Bhole map_fds[11] = create_map(BPF_MAP_TYPE_XSKMAP, sizeof(int),
11397c85c448SPrashant Bhole sizeof(int), 1);
11407c85c448SPrashant Bhole do {
11417c85c448SPrashant Bhole prog[*fixup_map_xskmap].imm = map_fds[11];
11427c85c448SPrashant Bhole fixup_map_xskmap++;
11437c85c448SPrashant Bhole } while (*fixup_map_xskmap);
11447c85c448SPrashant Bhole }
11457c85c448SPrashant Bhole if (*fixup_map_stacktrace) {
11467c85c448SPrashant Bhole map_fds[12] = create_map(BPF_MAP_TYPE_STACK_TRACE, sizeof(u32),
11477c85c448SPrashant Bhole sizeof(u64), 1);
11487c85c448SPrashant Bhole do {
11497c85c448SPrashant Bhole prog[*fixup_map_stacktrace].imm = map_fds[12];
11507c85c448SPrashant Bhole fixup_map_stacktrace++;
1151c2a20a27SStanislav Fomichev } while (*fixup_map_stacktrace);
11527c85c448SPrashant Bhole }
1153b4d4556cSAlexei Starovoitov if (*fixup_map_spin_lock) {
1154b4d4556cSAlexei Starovoitov map_fds[13] = create_map_spin_lock();
1155b4d4556cSAlexei Starovoitov do {
1156b4d4556cSAlexei Starovoitov prog[*fixup_map_spin_lock].imm = map_fds[13];
1157b4d4556cSAlexei Starovoitov fixup_map_spin_lock++;
1158b4d4556cSAlexei Starovoitov } while (*fixup_map_spin_lock);
1159b4d4556cSAlexei Starovoitov }
1160fb2abb73SDaniel Borkmann if (*fixup_map_array_ro) {
1161fb2abb73SDaniel Borkmann map_fds[14] = __create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
1162fb2abb73SDaniel Borkmann sizeof(struct test_val), 1,
1163fb2abb73SDaniel Borkmann BPF_F_RDONLY_PROG);
1164fb2abb73SDaniel Borkmann update_map(map_fds[14], 0);
1165fb2abb73SDaniel Borkmann do {
1166fb2abb73SDaniel Borkmann prog[*fixup_map_array_ro].imm = map_fds[14];
1167fb2abb73SDaniel Borkmann fixup_map_array_ro++;
1168fb2abb73SDaniel Borkmann } while (*fixup_map_array_ro);
1169fb2abb73SDaniel Borkmann }
1170fb2abb73SDaniel Borkmann if (*fixup_map_array_wo) {
1171fb2abb73SDaniel Borkmann map_fds[15] = __create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
1172fb2abb73SDaniel Borkmann sizeof(struct test_val), 1,
1173fb2abb73SDaniel Borkmann BPF_F_WRONLY_PROG);
1174fb2abb73SDaniel Borkmann update_map(map_fds[15], 0);
1175fb2abb73SDaniel Borkmann do {
1176fb2abb73SDaniel Borkmann prog[*fixup_map_array_wo].imm = map_fds[15];
1177fb2abb73SDaniel Borkmann fixup_map_array_wo++;
1178fb2abb73SDaniel Borkmann } while (*fixup_map_array_wo);
1179fb2abb73SDaniel Borkmann }
1180fb2abb73SDaniel Borkmann if (*fixup_map_array_small) {
1181fb2abb73SDaniel Borkmann map_fds[16] = __create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
1182fb2abb73SDaniel Borkmann 1, 1, 0);
1183fb2abb73SDaniel Borkmann update_map(map_fds[16], 0);
1184fb2abb73SDaniel Borkmann do {
1185fb2abb73SDaniel Borkmann prog[*fixup_map_array_small].imm = map_fds[16];
1186fb2abb73SDaniel Borkmann fixup_map_array_small++;
1187fb2abb73SDaniel Borkmann } while (*fixup_map_array_small);
1188fb2abb73SDaniel Borkmann }
11897a9bb976SMartin KaFai Lau if (*fixup_sk_storage_map) {
11907a9bb976SMartin KaFai Lau map_fds[17] = create_sk_storage_map();
11917a9bb976SMartin KaFai Lau do {
11927a9bb976SMartin KaFai Lau prog[*fixup_sk_storage_map].imm = map_fds[17];
11937a9bb976SMartin KaFai Lau fixup_sk_storage_map++;
11947a9bb976SMartin KaFai Lau } while (*fixup_sk_storage_map);
11957a9bb976SMartin KaFai Lau }
119603cd1d1aSAllan Zhang if (*fixup_map_event_output) {
119703cd1d1aSAllan Zhang map_fds[18] = __create_map(BPF_MAP_TYPE_PERF_EVENT_ARRAY,
119803cd1d1aSAllan Zhang sizeof(int), sizeof(int), 1, 0);
119903cd1d1aSAllan Zhang do {
120003cd1d1aSAllan Zhang prog[*fixup_map_event_output].imm = map_fds[18];
120103cd1d1aSAllan Zhang fixup_map_event_output++;
120203cd1d1aSAllan Zhang } while (*fixup_map_event_output);
120303cd1d1aSAllan Zhang }
1204c3210222SJakub Sitnicki if (*fixup_map_reuseport_array) {
1205c3210222SJakub Sitnicki map_fds[19] = __create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1206c3210222SJakub Sitnicki sizeof(u32), sizeof(u64), 1, 0);
1207c3210222SJakub Sitnicki do {
1208c3210222SJakub Sitnicki prog[*fixup_map_reuseport_array].imm = map_fds[19];
1209c3210222SJakub Sitnicki fixup_map_reuseport_array++;
1210c3210222SJakub Sitnicki } while (*fixup_map_reuseport_array);
1211c3210222SJakub Sitnicki }
12124237e9f4SGilad Reti if (*fixup_map_ringbuf) {
12134237e9f4SGilad Reti map_fds[20] = create_map(BPF_MAP_TYPE_RINGBUF, 0,
12147283137aSHengqi Chen 0, getpagesize());
12154237e9f4SGilad Reti do {
12164237e9f4SGilad Reti prog[*fixup_map_ringbuf].imm = map_fds[20];
12174237e9f4SGilad Reti fixup_map_ringbuf++;
12184237e9f4SGilad Reti } while (*fixup_map_ringbuf);
12194237e9f4SGilad Reti }
1220e60e6962SDmitrii Banshchikov if (*fixup_map_timer) {
1221e60e6962SDmitrii Banshchikov map_fds[21] = create_map_timer();
1222e60e6962SDmitrii Banshchikov do {
1223e60e6962SDmitrii Banshchikov prog[*fixup_map_timer].imm = map_fds[21];
1224e60e6962SDmitrii Banshchikov fixup_map_timer++;
1225e60e6962SDmitrii Banshchikov } while (*fixup_map_timer);
1226e60e6962SDmitrii Banshchikov }
122705a945deSKumar Kartikeya Dwivedi if (*fixup_map_kptr) {
122805a945deSKumar Kartikeya Dwivedi map_fds[22] = create_map_kptr();
122905a945deSKumar Kartikeya Dwivedi do {
123005a945deSKumar Kartikeya Dwivedi prog[*fixup_map_kptr].imm = map_fds[22];
123105a945deSKumar Kartikeya Dwivedi fixup_map_kptr++;
123205a945deSKumar Kartikeya Dwivedi } while (*fixup_map_kptr);
123305a945deSKumar Kartikeya Dwivedi }
12340201b807SKumar Kartikeya Dwivedi
1235f26ebdd3SJiri Olsa fixup_prog_kfuncs(prog, fd_array, test->fixup_kfunc_btf_id);
12365aa5bd14SDaniel Borkmann }
12375aa5bd14SDaniel Borkmann
123881626001SAlexei Starovoitov struct libcap {
123981626001SAlexei Starovoitov struct __user_cap_header_struct hdr;
124081626001SAlexei Starovoitov struct __user_cap_data_struct data[2];
124181626001SAlexei Starovoitov };
124281626001SAlexei Starovoitov
set_admin(bool admin)1243832c6f2cSDaniel Borkmann static int set_admin(bool admin)
1244832c6f2cSDaniel Borkmann {
1245b1c2768aSMartin KaFai Lau int err;
1246832c6f2cSDaniel Borkmann
124781626001SAlexei Starovoitov if (admin) {
1248b1c2768aSMartin KaFai Lau err = cap_enable_effective(ADMIN_CAPS, NULL);
1249b1c2768aSMartin KaFai Lau if (err)
1250b1c2768aSMartin KaFai Lau perror("cap_enable_effective(ADMIN_CAPS)");
125181626001SAlexei Starovoitov } else {
1252b1c2768aSMartin KaFai Lau err = cap_disable_effective(ADMIN_CAPS, NULL);
1253b1c2768aSMartin KaFai Lau if (err)
1254b1c2768aSMartin KaFai Lau perror("cap_disable_effective(ADMIN_CAPS)");
125581626001SAlexei Starovoitov }
1256b1c2768aSMartin KaFai Lau
1257b1c2768aSMartin KaFai Lau return err;
1258832c6f2cSDaniel Borkmann }
1259832c6f2cSDaniel Borkmann
do_prog_test_run(int fd_prog,bool unpriv,uint32_t expected_val,void * data,size_t size_data)12605a8d5209SJakub Kicinski static int do_prog_test_run(int fd_prog, bool unpriv, uint32_t expected_val,
12615a8d5209SJakub Kicinski void *data, size_t size_data)
12625a8d5209SJakub Kicinski {
12635a8d5209SJakub Kicinski __u8 tmp[TEST_DATA_LEN << 2];
12645a8d5209SJakub Kicinski __u32 size_tmp = sizeof(tmp);
12655f61b7c6SFlorian Lehner int err, saved_errno;
126604fcb5f9SDelyan Kratunov LIBBPF_OPTS(bpf_test_run_opts, topts,
126704fcb5f9SDelyan Kratunov .data_in = data,
126804fcb5f9SDelyan Kratunov .data_size_in = size_data,
126904fcb5f9SDelyan Kratunov .data_out = tmp,
127004fcb5f9SDelyan Kratunov .data_size_out = size_tmp,
127104fcb5f9SDelyan Kratunov .repeat = 1,
127204fcb5f9SDelyan Kratunov );
12735a8d5209SJakub Kicinski
12745a8d5209SJakub Kicinski if (unpriv)
12755a8d5209SJakub Kicinski set_admin(true);
127604fcb5f9SDelyan Kratunov err = bpf_prog_test_run_opts(fd_prog, &topts);
12775f61b7c6SFlorian Lehner saved_errno = errno;
12785f61b7c6SFlorian Lehner
12795a8d5209SJakub Kicinski if (unpriv)
12805a8d5209SJakub Kicinski set_admin(false);
12815f61b7c6SFlorian Lehner
12825f61b7c6SFlorian Lehner if (err) {
12835f61b7c6SFlorian Lehner switch (saved_errno) {
12845319255bSIlya Leoshkevich case ENOTSUPP:
12855f61b7c6SFlorian Lehner printf("Did not run the program (not supported) ");
12865f61b7c6SFlorian Lehner return 0;
12875f61b7c6SFlorian Lehner case EPERM:
12885f61b7c6SFlorian Lehner if (unpriv) {
12895f61b7c6SFlorian Lehner printf("Did not run the program (no permission) ");
12905f61b7c6SFlorian Lehner return 0;
12915f61b7c6SFlorian Lehner }
12925f61b7c6SFlorian Lehner /* fallthrough; */
12935f61b7c6SFlorian Lehner default:
12945f61b7c6SFlorian Lehner printf("FAIL: Unexpected bpf_prog_test_run error (%s) ",
12955f61b7c6SFlorian Lehner strerror(saved_errno));
12965a8d5209SJakub Kicinski return err;
12975a8d5209SJakub Kicinski }
12985f61b7c6SFlorian Lehner }
12995f61b7c6SFlorian Lehner
130004fcb5f9SDelyan Kratunov if (topts.retval != expected_val && expected_val != POINTER_VALUE) {
130104fcb5f9SDelyan Kratunov printf("FAIL retval %d != %d ", topts.retval, expected_val);
13025a8d5209SJakub Kicinski return 1;
13035a8d5209SJakub Kicinski }
13045a8d5209SJakub Kicinski
13055a8d5209SJakub Kicinski return 0;
13065a8d5209SJakub Kicinski }
13075a8d5209SJakub Kicinski
1308060fd103SAndrei Matei /* Returns true if every part of exp (tab-separated) appears in log, in order.
1309060fd103SAndrei Matei *
1310060fd103SAndrei Matei * If exp is an empty string, returns true.
1311060fd103SAndrei Matei */
cmp_str_seq(const char * log,const char * exp)1312e8c13c4dSAlexei Starovoitov static bool cmp_str_seq(const char *log, const char *exp)
1313e8c13c4dSAlexei Starovoitov {
1314060fd103SAndrei Matei char needle[200];
1315e8c13c4dSAlexei Starovoitov const char *p, *q;
1316e8c13c4dSAlexei Starovoitov int len;
1317e8c13c4dSAlexei Starovoitov
1318e8c13c4dSAlexei Starovoitov do {
1319060fd103SAndrei Matei if (!strlen(exp))
1320060fd103SAndrei Matei break;
1321e8c13c4dSAlexei Starovoitov p = strchr(exp, '\t');
1322e8c13c4dSAlexei Starovoitov if (!p)
1323e8c13c4dSAlexei Starovoitov p = exp + strlen(exp);
1324e8c13c4dSAlexei Starovoitov
1325e8c13c4dSAlexei Starovoitov len = p - exp;
1326e8c13c4dSAlexei Starovoitov if (len >= sizeof(needle) || !len) {
1327e8c13c4dSAlexei Starovoitov printf("FAIL\nTestcase bug\n");
1328e8c13c4dSAlexei Starovoitov return false;
1329e8c13c4dSAlexei Starovoitov }
1330e8c13c4dSAlexei Starovoitov strncpy(needle, exp, len);
1331e8c13c4dSAlexei Starovoitov needle[len] = 0;
1332e8c13c4dSAlexei Starovoitov q = strstr(log, needle);
1333e8c13c4dSAlexei Starovoitov if (!q) {
1334060fd103SAndrei Matei printf("FAIL\nUnexpected verifier log!\n"
1335e8c13c4dSAlexei Starovoitov "EXP: %s\nRES:\n", needle);
1336e8c13c4dSAlexei Starovoitov return false;
1337e8c13c4dSAlexei Starovoitov }
1338e8c13c4dSAlexei Starovoitov log = q + len;
1339e8c13c4dSAlexei Starovoitov exp = p + 1;
1340e8c13c4dSAlexei Starovoitov } while (*p);
1341e8c13c4dSAlexei Starovoitov return true;
1342e8c13c4dSAlexei Starovoitov }
1343e8c13c4dSAlexei Starovoitov
get_xlated_program(int fd_prog,int * cnt)1344b23ed4d7SEduard Zingerman static struct bpf_insn *get_xlated_program(int fd_prog, int *cnt)
1345933ff531SEduard Zingerman {
1346b23ed4d7SEduard Zingerman __u32 buf_element_size = sizeof(struct bpf_insn);
1347933ff531SEduard Zingerman struct bpf_prog_info info = {};
1348933ff531SEduard Zingerman __u32 info_len = sizeof(info);
1349933ff531SEduard Zingerman __u32 xlated_prog_len;
1350b23ed4d7SEduard Zingerman struct bpf_insn *buf;
1351933ff531SEduard Zingerman
1352c5a237a4SIlya Leoshkevich if (bpf_prog_get_info_by_fd(fd_prog, &info, &info_len)) {
1353c5a237a4SIlya Leoshkevich perror("bpf_prog_get_info_by_fd failed");
1354b23ed4d7SEduard Zingerman return NULL;
1355933ff531SEduard Zingerman }
1356933ff531SEduard Zingerman
1357933ff531SEduard Zingerman xlated_prog_len = info.xlated_prog_len;
1358933ff531SEduard Zingerman if (xlated_prog_len % buf_element_size) {
1359933ff531SEduard Zingerman printf("Program length %d is not multiple of %d\n",
1360933ff531SEduard Zingerman xlated_prog_len, buf_element_size);
1361b23ed4d7SEduard Zingerman return NULL;
1362933ff531SEduard Zingerman }
1363933ff531SEduard Zingerman
1364933ff531SEduard Zingerman *cnt = xlated_prog_len / buf_element_size;
1365b23ed4d7SEduard Zingerman buf = calloc(*cnt, buf_element_size);
1366933ff531SEduard Zingerman if (!buf) {
1367933ff531SEduard Zingerman perror("can't allocate xlated program buffer");
1368b23ed4d7SEduard Zingerman return NULL;
1369933ff531SEduard Zingerman }
1370933ff531SEduard Zingerman
1371933ff531SEduard Zingerman bzero(&info, sizeof(info));
1372933ff531SEduard Zingerman info.xlated_prog_len = xlated_prog_len;
1373b23ed4d7SEduard Zingerman info.xlated_prog_insns = (__u64)(unsigned long)buf;
1374c5a237a4SIlya Leoshkevich if (bpf_prog_get_info_by_fd(fd_prog, &info, &info_len)) {
1375c5a237a4SIlya Leoshkevich perror("second bpf_prog_get_info_by_fd failed");
1376933ff531SEduard Zingerman goto out_free_buf;
1377933ff531SEduard Zingerman }
1378933ff531SEduard Zingerman
1379b23ed4d7SEduard Zingerman return buf;
1380933ff531SEduard Zingerman
1381933ff531SEduard Zingerman out_free_buf:
1382b23ed4d7SEduard Zingerman free(buf);
1383b23ed4d7SEduard Zingerman return NULL;
1384933ff531SEduard Zingerman }
1385933ff531SEduard Zingerman
is_null_insn(struct bpf_insn * insn)1386933ff531SEduard Zingerman static bool is_null_insn(struct bpf_insn *insn)
1387933ff531SEduard Zingerman {
1388933ff531SEduard Zingerman struct bpf_insn null_insn = {};
1389933ff531SEduard Zingerman
1390933ff531SEduard Zingerman return memcmp(insn, &null_insn, sizeof(null_insn)) == 0;
1391933ff531SEduard Zingerman }
1392933ff531SEduard Zingerman
is_skip_insn(struct bpf_insn * insn)1393933ff531SEduard Zingerman static bool is_skip_insn(struct bpf_insn *insn)
1394933ff531SEduard Zingerman {
1395933ff531SEduard Zingerman struct bpf_insn skip_insn = SKIP_INSNS();
1396933ff531SEduard Zingerman
1397933ff531SEduard Zingerman return memcmp(insn, &skip_insn, sizeof(skip_insn)) == 0;
1398933ff531SEduard Zingerman }
1399933ff531SEduard Zingerman
null_terminated_insn_len(struct bpf_insn * seq,int max_len)1400933ff531SEduard Zingerman static int null_terminated_insn_len(struct bpf_insn *seq, int max_len)
1401933ff531SEduard Zingerman {
1402933ff531SEduard Zingerman int i;
1403933ff531SEduard Zingerman
1404933ff531SEduard Zingerman for (i = 0; i < max_len; ++i) {
1405933ff531SEduard Zingerman if (is_null_insn(&seq[i]))
1406933ff531SEduard Zingerman return i;
1407933ff531SEduard Zingerman }
1408933ff531SEduard Zingerman return max_len;
1409933ff531SEduard Zingerman }
1410933ff531SEduard Zingerman
compare_masked_insn(struct bpf_insn * orig,struct bpf_insn * masked)1411933ff531SEduard Zingerman static bool compare_masked_insn(struct bpf_insn *orig, struct bpf_insn *masked)
1412933ff531SEduard Zingerman {
1413933ff531SEduard Zingerman struct bpf_insn orig_masked;
1414933ff531SEduard Zingerman
1415933ff531SEduard Zingerman memcpy(&orig_masked, orig, sizeof(orig_masked));
1416933ff531SEduard Zingerman if (masked->imm == INSN_IMM_MASK)
1417933ff531SEduard Zingerman orig_masked.imm = INSN_IMM_MASK;
1418933ff531SEduard Zingerman if (masked->off == INSN_OFF_MASK)
1419933ff531SEduard Zingerman orig_masked.off = INSN_OFF_MASK;
1420933ff531SEduard Zingerman
1421933ff531SEduard Zingerman return memcmp(&orig_masked, masked, sizeof(orig_masked)) == 0;
1422933ff531SEduard Zingerman }
1423933ff531SEduard Zingerman
find_insn_subseq(struct bpf_insn * seq,struct bpf_insn * subseq,int seq_len,int subseq_len)1424933ff531SEduard Zingerman static int find_insn_subseq(struct bpf_insn *seq, struct bpf_insn *subseq,
1425933ff531SEduard Zingerman int seq_len, int subseq_len)
1426933ff531SEduard Zingerman {
1427933ff531SEduard Zingerman int i, j;
1428933ff531SEduard Zingerman
1429933ff531SEduard Zingerman if (subseq_len > seq_len)
1430933ff531SEduard Zingerman return -1;
1431933ff531SEduard Zingerman
1432933ff531SEduard Zingerman for (i = 0; i < seq_len - subseq_len + 1; ++i) {
1433933ff531SEduard Zingerman bool found = true;
1434933ff531SEduard Zingerman
1435933ff531SEduard Zingerman for (j = 0; j < subseq_len; ++j) {
1436933ff531SEduard Zingerman if (!compare_masked_insn(&seq[i + j], &subseq[j])) {
1437933ff531SEduard Zingerman found = false;
1438933ff531SEduard Zingerman break;
1439933ff531SEduard Zingerman }
1440933ff531SEduard Zingerman }
1441933ff531SEduard Zingerman if (found)
1442933ff531SEduard Zingerman return i;
1443933ff531SEduard Zingerman }
1444933ff531SEduard Zingerman
1445933ff531SEduard Zingerman return -1;
1446933ff531SEduard Zingerman }
1447933ff531SEduard Zingerman
find_skip_insn_marker(struct bpf_insn * seq,int len)1448933ff531SEduard Zingerman static int find_skip_insn_marker(struct bpf_insn *seq, int len)
1449933ff531SEduard Zingerman {
1450933ff531SEduard Zingerman int i;
1451933ff531SEduard Zingerman
1452933ff531SEduard Zingerman for (i = 0; i < len; ++i)
1453933ff531SEduard Zingerman if (is_skip_insn(&seq[i]))
1454933ff531SEduard Zingerman return i;
1455933ff531SEduard Zingerman
1456933ff531SEduard Zingerman return -1;
1457933ff531SEduard Zingerman }
1458933ff531SEduard Zingerman
1459933ff531SEduard Zingerman /* Return true if all sub-sequences in `subseqs` could be found in
1460933ff531SEduard Zingerman * `seq` one after another. Sub-sequences are separated by a single
1461933ff531SEduard Zingerman * nil instruction.
1462933ff531SEduard Zingerman */
find_all_insn_subseqs(struct bpf_insn * seq,struct bpf_insn * subseqs,int seq_len,int max_subseqs_len)1463933ff531SEduard Zingerman static bool find_all_insn_subseqs(struct bpf_insn *seq, struct bpf_insn *subseqs,
1464933ff531SEduard Zingerman int seq_len, int max_subseqs_len)
1465933ff531SEduard Zingerman {
1466933ff531SEduard Zingerman int subseqs_len = null_terminated_insn_len(subseqs, max_subseqs_len);
1467933ff531SEduard Zingerman
1468933ff531SEduard Zingerman while (subseqs_len > 0) {
1469933ff531SEduard Zingerman int skip_idx = find_skip_insn_marker(subseqs, subseqs_len);
1470933ff531SEduard Zingerman int cur_subseq_len = skip_idx < 0 ? subseqs_len : skip_idx;
1471933ff531SEduard Zingerman int subseq_idx = find_insn_subseq(seq, subseqs,
1472933ff531SEduard Zingerman seq_len, cur_subseq_len);
1473933ff531SEduard Zingerman
1474933ff531SEduard Zingerman if (subseq_idx < 0)
1475933ff531SEduard Zingerman return false;
1476933ff531SEduard Zingerman seq += subseq_idx + cur_subseq_len;
1477933ff531SEduard Zingerman seq_len -= subseq_idx + cur_subseq_len;
1478933ff531SEduard Zingerman subseqs += cur_subseq_len + 1;
1479933ff531SEduard Zingerman subseqs_len -= cur_subseq_len + 1;
1480933ff531SEduard Zingerman }
1481933ff531SEduard Zingerman
1482933ff531SEduard Zingerman return true;
1483933ff531SEduard Zingerman }
1484933ff531SEduard Zingerman
print_insn(struct bpf_insn * buf,int cnt)1485933ff531SEduard Zingerman static void print_insn(struct bpf_insn *buf, int cnt)
1486933ff531SEduard Zingerman {
1487933ff531SEduard Zingerman int i;
1488933ff531SEduard Zingerman
1489933ff531SEduard Zingerman printf(" addr op d s off imm\n");
1490933ff531SEduard Zingerman for (i = 0; i < cnt; ++i) {
1491933ff531SEduard Zingerman struct bpf_insn *insn = &buf[i];
1492933ff531SEduard Zingerman
1493933ff531SEduard Zingerman if (is_null_insn(insn))
1494933ff531SEduard Zingerman break;
1495933ff531SEduard Zingerman
1496933ff531SEduard Zingerman if (is_skip_insn(insn))
1497933ff531SEduard Zingerman printf(" ...\n");
1498933ff531SEduard Zingerman else
1499933ff531SEduard Zingerman printf(" %04x: %02x %1x %x %04hx %08x\n",
1500933ff531SEduard Zingerman i, insn->code, insn->dst_reg,
1501933ff531SEduard Zingerman insn->src_reg, insn->off, insn->imm);
1502933ff531SEduard Zingerman }
1503933ff531SEduard Zingerman }
1504933ff531SEduard Zingerman
check_xlated_program(struct bpf_test * test,int fd_prog)1505933ff531SEduard Zingerman static bool check_xlated_program(struct bpf_test *test, int fd_prog)
1506933ff531SEduard Zingerman {
1507933ff531SEduard Zingerman struct bpf_insn *buf;
1508933ff531SEduard Zingerman int cnt;
1509933ff531SEduard Zingerman bool result = true;
1510933ff531SEduard Zingerman bool check_expected = !is_null_insn(test->expected_insns);
1511933ff531SEduard Zingerman bool check_unexpected = !is_null_insn(test->unexpected_insns);
1512933ff531SEduard Zingerman
1513933ff531SEduard Zingerman if (!check_expected && !check_unexpected)
1514933ff531SEduard Zingerman goto out;
1515933ff531SEduard Zingerman
1516b23ed4d7SEduard Zingerman buf = get_xlated_program(fd_prog, &cnt);
1517b23ed4d7SEduard Zingerman if (!buf) {
1518933ff531SEduard Zingerman printf("FAIL: can't get xlated program\n");
1519933ff531SEduard Zingerman result = false;
1520933ff531SEduard Zingerman goto out;
1521933ff531SEduard Zingerman }
1522933ff531SEduard Zingerman
1523933ff531SEduard Zingerman if (check_expected &&
1524933ff531SEduard Zingerman !find_all_insn_subseqs(buf, test->expected_insns,
1525933ff531SEduard Zingerman cnt, MAX_EXPECTED_INSNS)) {
1526933ff531SEduard Zingerman printf("FAIL: can't find expected subsequence of instructions\n");
1527933ff531SEduard Zingerman result = false;
1528933ff531SEduard Zingerman if (verbose) {
1529933ff531SEduard Zingerman printf("Program:\n");
1530933ff531SEduard Zingerman print_insn(buf, cnt);
1531933ff531SEduard Zingerman printf("Expected subsequence:\n");
1532933ff531SEduard Zingerman print_insn(test->expected_insns, MAX_EXPECTED_INSNS);
1533933ff531SEduard Zingerman }
1534933ff531SEduard Zingerman }
1535933ff531SEduard Zingerman
1536933ff531SEduard Zingerman if (check_unexpected &&
1537933ff531SEduard Zingerman find_all_insn_subseqs(buf, test->unexpected_insns,
1538933ff531SEduard Zingerman cnt, MAX_UNEXPECTED_INSNS)) {
1539933ff531SEduard Zingerman printf("FAIL: found unexpected subsequence of instructions\n");
1540933ff531SEduard Zingerman result = false;
1541933ff531SEduard Zingerman if (verbose) {
1542933ff531SEduard Zingerman printf("Program:\n");
1543933ff531SEduard Zingerman print_insn(buf, cnt);
1544933ff531SEduard Zingerman printf("Un-expected subsequence:\n");
1545933ff531SEduard Zingerman print_insn(test->unexpected_insns, MAX_UNEXPECTED_INSNS);
1546933ff531SEduard Zingerman }
1547933ff531SEduard Zingerman }
1548933ff531SEduard Zingerman
1549933ff531SEduard Zingerman free(buf);
1550933ff531SEduard Zingerman out:
1551933ff531SEduard Zingerman return result;
1552933ff531SEduard Zingerman }
1553933ff531SEduard Zingerman
do_test_single(struct bpf_test * test,bool unpriv,int * passes,int * errors)15545aa5bd14SDaniel Borkmann static void do_test_single(struct bpf_test *test, bool unpriv,
15555aa5bd14SDaniel Borkmann int *passes, int *errors)
15565aa5bd14SDaniel Borkmann {
15577a42008cSEduard Zingerman int fd_prog, btf_fd, expected_ret, alignment_prevented_execution;
155893731ef0SDaniel Borkmann int prog_len, prog_type = test->prog_type;
15595aa5bd14SDaniel Borkmann struct bpf_insn *prog = test->insns;
1560d8e86407SAndrii Nakryiko LIBBPF_OPTS(bpf_prog_load_opts, opts);
15615a8d5209SJakub Kicinski int run_errs, run_successes;
1562fb30d4b7SMartin KaFai Lau int map_fds[MAX_NR_MAPS];
15635aa5bd14SDaniel Borkmann const char *expected_err;
1564f26ebdd3SJiri Olsa int fd_array[2] = { -1, -1 };
15657d171672SFlorian Lehner int saved_errno;
15669acea337SStanislav Fomichev int fixup_skips;
1567c7665702SDavid Miller __u32 pflags;
1568111e6b45SAlexei Starovoitov int i, err;
15695aa5bd14SDaniel Borkmann
15707a42008cSEduard Zingerman fd_prog = -1;
1571fb30d4b7SMartin KaFai Lau for (i = 0; i < MAX_NR_MAPS; i++)
1572fb30d4b7SMartin KaFai Lau map_fds[i] = -1;
15737a42008cSEduard Zingerman btf_fd = -1;
1574fb30d4b7SMartin KaFai Lau
15750c586079SJoe Stringer if (!prog_type)
15760c586079SJoe Stringer prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
15779acea337SStanislav Fomichev fixup_skips = skips;
1578f26ebdd3SJiri Olsa do_test_fixup(test, prog_type, prog, map_fds, &fd_array[1]);
15798aa2d4b4SAlexei Starovoitov if (test->fill_insns) {
15808aa2d4b4SAlexei Starovoitov prog = test->fill_insns;
15818aa2d4b4SAlexei Starovoitov prog_len = test->prog_len;
15828aa2d4b4SAlexei Starovoitov } else {
15838aa2d4b4SAlexei Starovoitov prog_len = probe_filter_length(prog);
15848aa2d4b4SAlexei Starovoitov }
15859acea337SStanislav Fomichev /* If there were some map skips during fixup due to missing bpf
15869acea337SStanislav Fomichev * features, skip this test.
15879acea337SStanislav Fomichev */
15889acea337SStanislav Fomichev if (fixup_skips != skips)
15899acea337SStanislav Fomichev return;
15905aa5bd14SDaniel Borkmann
15919d120b41SJiong Wang pflags = BPF_F_TEST_RND_HI32;
1592c7665702SDavid Miller if (test->flags & F_LOAD_WITH_STRICT_ALIGNMENT)
1593c7665702SDavid Miller pflags |= BPF_F_STRICT_ALIGNMENT;
1594c7665702SDavid Miller if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
1595c7665702SDavid Miller pflags |= BPF_F_ANY_ALIGNMENT;
1596e8c13c4dSAlexei Starovoitov if (test->flags & ~3)
1597e8c13c4dSAlexei Starovoitov pflags |= test->flags;
159876d95077SStanislav Fomichev
1599e8c13c4dSAlexei Starovoitov expected_ret = unpriv && test->result_unpriv != UNDEF ?
1600e8c13c4dSAlexei Starovoitov test->result_unpriv : test->result;
1601e8c13c4dSAlexei Starovoitov expected_err = unpriv && test->errstr_unpriv ?
1602e8c13c4dSAlexei Starovoitov test->errstr_unpriv : test->errstr;
1603d8e86407SAndrii Nakryiko
1604d8e86407SAndrii Nakryiko opts.expected_attach_type = test->expected_attach_type;
16056f8a57ccSAndrii Nakryiko if (verbose)
16062a72f595SAndrii Nakryiko opts.log_level = verif_log_level | 4; /* force stats */
16076f8a57ccSAndrii Nakryiko else if (expected_ret == VERBOSE_ACCEPT)
1608d8e86407SAndrii Nakryiko opts.log_level = 2;
16096f8a57ccSAndrii Nakryiko else
16107a42008cSEduard Zingerman opts.log_level = DEFAULT_LIBBPF_LOG_LEVEL;
1611d8e86407SAndrii Nakryiko opts.prog_flags = pflags;
1612f26ebdd3SJiri Olsa if (fd_array[1] != -1)
1613f26ebdd3SJiri Olsa opts.fd_array = &fd_array[0];
161476d95077SStanislav Fomichev
16157c036ed9SRoberto Sassu if ((prog_type == BPF_PROG_TYPE_TRACING ||
16167c036ed9SRoberto Sassu prog_type == BPF_PROG_TYPE_LSM) && test->kfunc) {
1617d8e86407SAndrii Nakryiko int attach_btf_id;
1618d8e86407SAndrii Nakryiko
1619d8e86407SAndrii Nakryiko attach_btf_id = libbpf_find_vmlinux_btf_id(test->kfunc,
1620d8e86407SAndrii Nakryiko opts.expected_attach_type);
1621d8e86407SAndrii Nakryiko if (attach_btf_id < 0) {
1622762f8515SJiri Olsa printf("FAIL\nFailed to find BTF ID for '%s'!\n",
1623762f8515SJiri Olsa test->kfunc);
1624762f8515SJiri Olsa (*errors)++;
1625762f8515SJiri Olsa return;
1626762f8515SJiri Olsa }
1627d8e86407SAndrii Nakryiko
1628d8e86407SAndrii Nakryiko opts.attach_btf_id = attach_btf_id;
1629762f8515SJiri Olsa }
1630762f8515SJiri Olsa
16317a42008cSEduard Zingerman if (test->btf_types[0] != 0) {
16327a42008cSEduard Zingerman btf_fd = load_btf_for_test(test);
16337a42008cSEduard Zingerman if (btf_fd < 0)
16347a42008cSEduard Zingerman goto fail_log;
16357a42008cSEduard Zingerman opts.prog_btf_fd = btf_fd;
16367a42008cSEduard Zingerman }
16377a42008cSEduard Zingerman
16387a42008cSEduard Zingerman if (test->func_info_cnt != 0) {
16397a42008cSEduard Zingerman opts.func_info = test->func_info;
16407a42008cSEduard Zingerman opts.func_info_cnt = test->func_info_cnt;
16417a42008cSEduard Zingerman opts.func_info_rec_size = sizeof(test->func_info[0]);
16427a42008cSEduard Zingerman }
16437a42008cSEduard Zingerman
1644d8e86407SAndrii Nakryiko opts.log_buf = bpf_vlog;
1645d8e86407SAndrii Nakryiko opts.log_size = sizeof(bpf_vlog);
1646d8e86407SAndrii Nakryiko fd_prog = bpf_prog_load(prog_type, NULL, "GPL", prog, prog_len, &opts);
16477d171672SFlorian Lehner saved_errno = errno;
1648762f8515SJiri Olsa
1649762f8515SJiri Olsa /* BPF_PROG_TYPE_TRACING requires more setup and
1650762f8515SJiri Olsa * bpf_probe_prog_type won't give correct answer
1651762f8515SJiri Olsa */
1652762f8515SJiri Olsa if (fd_prog < 0 && prog_type != BPF_PROG_TYPE_TRACING &&
165332e608f8SAndrii Nakryiko !libbpf_probe_bpf_prog_type(prog_type, NULL)) {
16548184d44cSStanislav Fomichev printf("SKIP (unsupported program type %d)\n", prog_type);
16558184d44cSStanislav Fomichev skips++;
16568184d44cSStanislav Fomichev goto close_fds;
16578184d44cSStanislav Fomichev }
16585aa5bd14SDaniel Borkmann
16595319255bSIlya Leoshkevich if (fd_prog < 0 && saved_errno == ENOTSUPP) {
16605319255bSIlya Leoshkevich printf("SKIP (program uses an unsupported feature)\n");
16615319255bSIlya Leoshkevich skips++;
16625319255bSIlya Leoshkevich goto close_fds;
16635319255bSIlya Leoshkevich }
16645319255bSIlya Leoshkevich
1665c7665702SDavid Miller alignment_prevented_execution = 0;
1666c7665702SDavid Miller
1667e8c13c4dSAlexei Starovoitov if (expected_ret == ACCEPT || expected_ret == VERBOSE_ACCEPT) {
1668c7665702SDavid Miller if (fd_prog < 0) {
16695aa5bd14SDaniel Borkmann printf("FAIL\nFailed to load prog '%s'!\n",
16707d171672SFlorian Lehner strerror(saved_errno));
16715aa5bd14SDaniel Borkmann goto fail_log;
16725aa5bd14SDaniel Borkmann }
1673c7665702SDavid Miller #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1674c7665702SDavid Miller if (fd_prog >= 0 &&
16755a8d5209SJakub Kicinski (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS))
1676c7665702SDavid Miller alignment_prevented_execution = 1;
1677c7665702SDavid Miller #endif
1678e8c13c4dSAlexei Starovoitov if (expected_ret == VERBOSE_ACCEPT && !cmp_str_seq(bpf_vlog, expected_err)) {
1679e8c13c4dSAlexei Starovoitov goto fail_log;
1680e8c13c4dSAlexei Starovoitov }
16815aa5bd14SDaniel Borkmann } else {
16825aa5bd14SDaniel Borkmann if (fd_prog >= 0) {
16835aa5bd14SDaniel Borkmann printf("FAIL\nUnexpected success to load!\n");
16845aa5bd14SDaniel Borkmann goto fail_log;
16855aa5bd14SDaniel Borkmann }
1686060fd103SAndrei Matei if (!expected_err || !cmp_str_seq(bpf_vlog, expected_err)) {
168795f87a97SJoe Stringer printf("FAIL\nUnexpected error message!\n\tEXP: %s\n\tRES: %s\n",
168895f87a97SJoe Stringer expected_err, bpf_vlog);
16895aa5bd14SDaniel Borkmann goto fail_log;
16905aa5bd14SDaniel Borkmann }
16915aa5bd14SDaniel Borkmann }
16925aa5bd14SDaniel Borkmann
1693973377ffSDaniel Borkmann if (!unpriv && test->insn_processed) {
1694730ff40fSAlexei Starovoitov uint32_t insn_processed;
1695730ff40fSAlexei Starovoitov char *proc;
16966e6fddc7SDaniel Borkmann
1697730ff40fSAlexei Starovoitov proc = strstr(bpf_vlog, "processed ");
1698730ff40fSAlexei Starovoitov insn_processed = atoi(proc + 10);
1699730ff40fSAlexei Starovoitov if (test->insn_processed != insn_processed) {
1700730ff40fSAlexei Starovoitov printf("FAIL\nUnexpected insn_processed %u vs %u\n",
1701730ff40fSAlexei Starovoitov insn_processed, test->insn_processed);
1702111e6b45SAlexei Starovoitov goto fail_log;
1703111e6b45SAlexei Starovoitov }
1704111e6b45SAlexei Starovoitov }
1705730ff40fSAlexei Starovoitov
1706e8c13c4dSAlexei Starovoitov if (verbose)
1707e8c13c4dSAlexei Starovoitov printf(", verifier log:\n%s", bpf_vlog);
1708e8c13c4dSAlexei Starovoitov
1709933ff531SEduard Zingerman if (!check_xlated_program(test, fd_prog))
1710933ff531SEduard Zingerman goto fail_log;
1711933ff531SEduard Zingerman
17125a8d5209SJakub Kicinski run_errs = 0;
17135a8d5209SJakub Kicinski run_successes = 0;
1714b4f89463SLorenz Bauer if (!alignment_prevented_execution && fd_prog >= 0 && test->runs >= 0) {
17155a8d5209SJakub Kicinski uint32_t expected_val;
17165a8d5209SJakub Kicinski int i;
17175aa5bd14SDaniel Borkmann
1718d5e1db99SAndrii Nakryiko if (!test->runs)
1719d5e1db99SAndrii Nakryiko test->runs = 1;
17205a8d5209SJakub Kicinski
17215a8d5209SJakub Kicinski for (i = 0; i < test->runs; i++) {
17225a8d5209SJakub Kicinski if (unpriv && test->retvals[i].retval_unpriv)
17235a8d5209SJakub Kicinski expected_val = test->retvals[i].retval_unpriv;
17245a8d5209SJakub Kicinski else
17255a8d5209SJakub Kicinski expected_val = test->retvals[i].retval;
17265a8d5209SJakub Kicinski
17275a8d5209SJakub Kicinski err = do_prog_test_run(fd_prog, unpriv, expected_val,
17285a8d5209SJakub Kicinski test->retvals[i].data,
17295a8d5209SJakub Kicinski sizeof(test->retvals[i].data));
17305a8d5209SJakub Kicinski if (err) {
17315a8d5209SJakub Kicinski printf("(run %d/%d) ", i + 1, test->runs);
17325a8d5209SJakub Kicinski run_errs++;
17335a8d5209SJakub Kicinski } else {
17345a8d5209SJakub Kicinski run_successes++;
17355aa5bd14SDaniel Borkmann }
17365aa5bd14SDaniel Borkmann }
17375a8d5209SJakub Kicinski }
17385a8d5209SJakub Kicinski
17395a8d5209SJakub Kicinski if (!run_errs) {
17405aa5bd14SDaniel Borkmann (*passes)++;
17415a8d5209SJakub Kicinski if (run_successes > 1)
17425a8d5209SJakub Kicinski printf("%d cases ", run_successes);
17435a8d5209SJakub Kicinski printf("OK");
17445a8d5209SJakub Kicinski if (alignment_prevented_execution)
17455a8d5209SJakub Kicinski printf(" (NOTE: not executed due to unknown alignment)");
17465a8d5209SJakub Kicinski printf("\n");
17475a8d5209SJakub Kicinski } else {
17485a8d5209SJakub Kicinski printf("\n");
17495a8d5209SJakub Kicinski goto fail_log;
17505a8d5209SJakub Kicinski }
17515aa5bd14SDaniel Borkmann close_fds:
17528aa2d4b4SAlexei Starovoitov if (test->fill_insns)
17538aa2d4b4SAlexei Starovoitov free(test->fill_insns);
17545aa5bd14SDaniel Borkmann close(fd_prog);
17557a42008cSEduard Zingerman close(btf_fd);
17565aa5bd14SDaniel Borkmann for (i = 0; i < MAX_NR_MAPS; i++)
17575aa5bd14SDaniel Borkmann close(map_fds[i]);
17585aa5bd14SDaniel Borkmann sched_yield();
17595aa5bd14SDaniel Borkmann return;
17605aa5bd14SDaniel Borkmann fail_log:
17615aa5bd14SDaniel Borkmann (*errors)++;
17625aa5bd14SDaniel Borkmann printf("%s", bpf_vlog);
17635aa5bd14SDaniel Borkmann goto close_fds;
17645aa5bd14SDaniel Borkmann }
17655aa5bd14SDaniel Borkmann
is_admin(void)17665aa5bd14SDaniel Borkmann static bool is_admin(void)
17675aa5bd14SDaniel Borkmann {
1768b1c2768aSMartin KaFai Lau __u64 caps;
17695aa5bd14SDaniel Borkmann
1770b1c2768aSMartin KaFai Lau /* The test checks for finer cap as CAP_NET_ADMIN,
1771b1c2768aSMartin KaFai Lau * CAP_PERFMON, and CAP_BPF instead of CAP_SYS_ADMIN.
1772b1c2768aSMartin KaFai Lau * Thus, disable CAP_SYS_ADMIN at the beginning.
1773b1c2768aSMartin KaFai Lau */
1774b1c2768aSMartin KaFai Lau if (cap_disable_effective(1ULL << CAP_SYS_ADMIN, &caps)) {
1775b1c2768aSMartin KaFai Lau perror("cap_disable_effective(CAP_SYS_ADMIN)");
17765aa5bd14SDaniel Borkmann return false;
17775aa5bd14SDaniel Borkmann }
1778b1c2768aSMartin KaFai Lau
1779b1c2768aSMartin KaFai Lau return (caps & ADMIN_CAPS) == ADMIN_CAPS;
17805aa5bd14SDaniel Borkmann }
17815aa5bd14SDaniel Borkmann
test_as_unpriv(struct bpf_test * test)178236641ad6SDaniel Borkmann static bool test_as_unpriv(struct bpf_test *test)
178336641ad6SDaniel Borkmann {
1784c77b0589SBjörn Töpel #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1785c77b0589SBjörn Töpel /* Some architectures have strict alignment requirements. In
1786c77b0589SBjörn Töpel * that case, the BPF verifier detects if a program has
1787c77b0589SBjörn Töpel * unaligned accesses and rejects them. A user can pass
1788c77b0589SBjörn Töpel * BPF_F_ANY_ALIGNMENT to a program to override this
1789c77b0589SBjörn Töpel * check. That, however, will only work when a privileged user
1790c77b0589SBjörn Töpel * loads a program. An unprivileged user loading a program
1791c77b0589SBjörn Töpel * with this flag will be rejected prior entering the
1792c77b0589SBjörn Töpel * verifier.
1793c77b0589SBjörn Töpel */
1794c77b0589SBjörn Töpel if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
1795c77b0589SBjörn Töpel return false;
1796c77b0589SBjörn Töpel #endif
179736641ad6SDaniel Borkmann return !test->prog_type ||
179836641ad6SDaniel Borkmann test->prog_type == BPF_PROG_TYPE_SOCKET_FILTER ||
179936641ad6SDaniel Borkmann test->prog_type == BPF_PROG_TYPE_CGROUP_SKB;
180036641ad6SDaniel Borkmann }
180136641ad6SDaniel Borkmann
do_test(bool unpriv,unsigned int from,unsigned int to)18025aa5bd14SDaniel Borkmann static int do_test(bool unpriv, unsigned int from, unsigned int to)
18035aa5bd14SDaniel Borkmann {
18048184d44cSStanislav Fomichev int i, passes = 0, errors = 0;
18055aa5bd14SDaniel Borkmann
1806b23b385fSJiri Olsa /* ensure previous instance of the module is unloaded */
1807b23b385fSJiri Olsa unload_bpf_testmod(verbose);
1808b23b385fSJiri Olsa
1809b23b385fSJiri Olsa if (load_bpf_testmod(verbose))
1810b23b385fSJiri Olsa return EXIT_FAILURE;
1811b23b385fSJiri Olsa
18125aa5bd14SDaniel Borkmann for (i = from; i < to; i++) {
18135aa5bd14SDaniel Borkmann struct bpf_test *test = &tests[i];
18145aa5bd14SDaniel Borkmann
18155aa5bd14SDaniel Borkmann /* Program types that are not supported by non-root we
18165aa5bd14SDaniel Borkmann * skip right away.
18175aa5bd14SDaniel Borkmann */
181836641ad6SDaniel Borkmann if (test_as_unpriv(test) && unpriv_disabled) {
18190a674874SJoe Stringer printf("#%d/u %s SKIP\n", i, test->descr);
18200a674874SJoe Stringer skips++;
182136641ad6SDaniel Borkmann } else if (test_as_unpriv(test)) {
18225aa5bd14SDaniel Borkmann if (!unpriv)
18235aa5bd14SDaniel Borkmann set_admin(false);
18245aa5bd14SDaniel Borkmann printf("#%d/u %s ", i, test->descr);
18255aa5bd14SDaniel Borkmann do_test_single(test, true, &passes, &errors);
18265aa5bd14SDaniel Borkmann if (!unpriv)
18275aa5bd14SDaniel Borkmann set_admin(true);
18285aa5bd14SDaniel Borkmann }
18295aa5bd14SDaniel Borkmann
1830d0a0e495SJoe Stringer if (unpriv) {
1831d0a0e495SJoe Stringer printf("#%d/p %s SKIP\n", i, test->descr);
1832d0a0e495SJoe Stringer skips++;
1833d0a0e495SJoe Stringer } else {
18345aa5bd14SDaniel Borkmann printf("#%d/p %s ", i, test->descr);
18355aa5bd14SDaniel Borkmann do_test_single(test, false, &passes, &errors);
18365aa5bd14SDaniel Borkmann }
18375aa5bd14SDaniel Borkmann }
18385aa5bd14SDaniel Borkmann
1839b23b385fSJiri Olsa unload_bpf_testmod(verbose);
1840f26ebdd3SJiri Olsa kfuncs_cleanup();
1841b23b385fSJiri Olsa
1842d0a0e495SJoe Stringer printf("Summary: %d PASSED, %d SKIPPED, %d FAILED\n", passes,
1843d0a0e495SJoe Stringer skips, errors);
18445aa5bd14SDaniel Borkmann return errors ? EXIT_FAILURE : EXIT_SUCCESS;
18455aa5bd14SDaniel Borkmann }
18465aa5bd14SDaniel Borkmann
main(int argc,char ** argv)18475aa5bd14SDaniel Borkmann int main(int argc, char **argv)
18485aa5bd14SDaniel Borkmann {
18495aa5bd14SDaniel Borkmann unsigned int from = 0, to = ARRAY_SIZE(tests);
18505aa5bd14SDaniel Borkmann bool unpriv = !is_admin();
1851e8c13c4dSAlexei Starovoitov int arg = 1;
1852e8c13c4dSAlexei Starovoitov
1853e8c13c4dSAlexei Starovoitov if (argc > 1 && strcmp(argv[1], "-v") == 0) {
1854e8c13c4dSAlexei Starovoitov arg++;
1855e8c13c4dSAlexei Starovoitov verbose = true;
18562a72f595SAndrii Nakryiko verif_log_level = 1;
18572a72f595SAndrii Nakryiko argc--;
18582a72f595SAndrii Nakryiko }
18592a72f595SAndrii Nakryiko if (argc > 1 && strcmp(argv[1], "-vv") == 0) {
18602a72f595SAndrii Nakryiko arg++;
18612a72f595SAndrii Nakryiko verbose = true;
18622a72f595SAndrii Nakryiko verif_log_level = 2;
1863e8c13c4dSAlexei Starovoitov argc--;
1864e8c13c4dSAlexei Starovoitov }
18655aa5bd14SDaniel Borkmann
18665aa5bd14SDaniel Borkmann if (argc == 3) {
1867e8c13c4dSAlexei Starovoitov unsigned int l = atoi(argv[arg]);
1868e8c13c4dSAlexei Starovoitov unsigned int u = atoi(argv[arg + 1]);
18695aa5bd14SDaniel Borkmann
18705aa5bd14SDaniel Borkmann if (l < to && u < to) {
18715aa5bd14SDaniel Borkmann from = l;
18725aa5bd14SDaniel Borkmann to = u + 1;
18735aa5bd14SDaniel Borkmann }
18745aa5bd14SDaniel Borkmann } else if (argc == 2) {
1875e8c13c4dSAlexei Starovoitov unsigned int t = atoi(argv[arg]);
18765aa5bd14SDaniel Borkmann
18775aa5bd14SDaniel Borkmann if (t < to) {
18785aa5bd14SDaniel Borkmann from = t;
18795aa5bd14SDaniel Borkmann to = t + 1;
18805aa5bd14SDaniel Borkmann }
18815aa5bd14SDaniel Borkmann }
18825aa5bd14SDaniel Borkmann
1883*d128860dSArtem Savkov unpriv_disabled = get_unpriv_disabled();
18840a674874SJoe Stringer if (unpriv && unpriv_disabled) {
18850a674874SJoe Stringer printf("Cannot run as unprivileged user with sysctl %s.\n",
18860a674874SJoe Stringer UNPRIV_SYSCTL);
18870a674874SJoe Stringer return EXIT_FAILURE;
18880a674874SJoe Stringer }
18890a674874SJoe Stringer
1890c164b8b4SAndrii Nakryiko /* Use libbpf 1.0 API mode */
1891c164b8b4SAndrii Nakryiko libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
1892c164b8b4SAndrii Nakryiko
1893a82d8cd3SDaniel Borkmann bpf_semi_rand_init();
18945aa5bd14SDaniel Borkmann return do_test(unpriv, from, to);
18955aa5bd14SDaniel Borkmann }
1896