1958465e2SEduard Zingerman // SPDX-License-Identifier: GPL-2.0
2958465e2SEduard Zingerman #include "bpf_misc.h"
30c8bbf99SAlexei Starovoitov #include "bpf_experimental.h"
4958465e2SEduard Zingerman
5958465e2SEduard Zingerman struct {
6958465e2SEduard Zingerman __uint(type, BPF_MAP_TYPE_ARRAY);
7958465e2SEduard Zingerman __uint(max_entries, 8);
8958465e2SEduard Zingerman __type(key, __u32);
9958465e2SEduard Zingerman __type(value, __u64);
10958465e2SEduard Zingerman } map SEC(".maps");
11958465e2SEduard Zingerman
12958465e2SEduard Zingerman struct {
13958465e2SEduard Zingerman __uint(type, BPF_MAP_TYPE_USER_RINGBUF);
14958465e2SEduard Zingerman __uint(max_entries, 8);
15958465e2SEduard Zingerman } ringbuf SEC(".maps");
16958465e2SEduard Zingerman
17958465e2SEduard Zingerman struct vm_area_struct;
18958465e2SEduard Zingerman struct bpf_map;
19958465e2SEduard Zingerman
20958465e2SEduard Zingerman struct buf_context {
21958465e2SEduard Zingerman char *buf;
22958465e2SEduard Zingerman };
23958465e2SEduard Zingerman
24958465e2SEduard Zingerman struct num_context {
25958465e2SEduard Zingerman __u64 i;
269f3330aaSEduard Zingerman __u64 j;
27958465e2SEduard Zingerman };
28958465e2SEduard Zingerman
29958465e2SEduard Zingerman __u8 choice_arr[2] = { 0, 1 };
30958465e2SEduard Zingerman
unsafe_on_2nd_iter_cb(__u32 idx,struct buf_context * ctx)31958465e2SEduard Zingerman static int unsafe_on_2nd_iter_cb(__u32 idx, struct buf_context *ctx)
32958465e2SEduard Zingerman {
33958465e2SEduard Zingerman if (idx == 0) {
34958465e2SEduard Zingerman ctx->buf = (char *)(0xDEAD);
35958465e2SEduard Zingerman return 0;
36958465e2SEduard Zingerman }
37958465e2SEduard Zingerman
38958465e2SEduard Zingerman if (bpf_probe_read_user(ctx->buf, 8, (void *)(0xBADC0FFEE)))
39958465e2SEduard Zingerman return 1;
40958465e2SEduard Zingerman
41958465e2SEduard Zingerman return 0;
42958465e2SEduard Zingerman }
43958465e2SEduard Zingerman
44958465e2SEduard Zingerman SEC("?raw_tp")
45958465e2SEduard Zingerman __failure __msg("R1 type=scalar expected=fp")
unsafe_on_2nd_iter(void * unused)46958465e2SEduard Zingerman int unsafe_on_2nd_iter(void *unused)
47958465e2SEduard Zingerman {
48958465e2SEduard Zingerman char buf[4];
49958465e2SEduard Zingerman struct buf_context loop_ctx = { .buf = buf };
50958465e2SEduard Zingerman
51958465e2SEduard Zingerman bpf_loop(100, unsafe_on_2nd_iter_cb, &loop_ctx, 0);
52958465e2SEduard Zingerman return 0;
53958465e2SEduard Zingerman }
54958465e2SEduard Zingerman
unsafe_on_zero_iter_cb(__u32 idx,struct num_context * ctx)55958465e2SEduard Zingerman static int unsafe_on_zero_iter_cb(__u32 idx, struct num_context *ctx)
56958465e2SEduard Zingerman {
57958465e2SEduard Zingerman ctx->i = 0;
58958465e2SEduard Zingerman return 0;
59958465e2SEduard Zingerman }
60958465e2SEduard Zingerman
61958465e2SEduard Zingerman SEC("?raw_tp")
62958465e2SEduard Zingerman __failure __msg("invalid access to map value, value_size=2 off=32 size=1")
unsafe_on_zero_iter(void * unused)63958465e2SEduard Zingerman int unsafe_on_zero_iter(void *unused)
64958465e2SEduard Zingerman {
65958465e2SEduard Zingerman struct num_context loop_ctx = { .i = 32 };
66958465e2SEduard Zingerman
67958465e2SEduard Zingerman bpf_loop(100, unsafe_on_zero_iter_cb, &loop_ctx, 0);
68958465e2SEduard Zingerman return choice_arr[loop_ctx.i];
69958465e2SEduard Zingerman }
70958465e2SEduard Zingerman
widening_cb(__u32 idx,struct num_context * ctx)719f3330aaSEduard Zingerman static int widening_cb(__u32 idx, struct num_context *ctx)
729f3330aaSEduard Zingerman {
739f3330aaSEduard Zingerman ++ctx->i;
749f3330aaSEduard Zingerman return 0;
759f3330aaSEduard Zingerman }
769f3330aaSEduard Zingerman
779f3330aaSEduard Zingerman SEC("?raw_tp")
789f3330aaSEduard Zingerman __success
widening(void * unused)799f3330aaSEduard Zingerman int widening(void *unused)
809f3330aaSEduard Zingerman {
819f3330aaSEduard Zingerman struct num_context loop_ctx = { .i = 0, .j = 1 };
829f3330aaSEduard Zingerman
839f3330aaSEduard Zingerman bpf_loop(100, widening_cb, &loop_ctx, 0);
849f3330aaSEduard Zingerman /* loop_ctx.j is not changed during callback iteration,
859f3330aaSEduard Zingerman * verifier should not apply widening to it.
869f3330aaSEduard Zingerman */
879f3330aaSEduard Zingerman return choice_arr[loop_ctx.j];
889f3330aaSEduard Zingerman }
899f3330aaSEduard Zingerman
loop_detection_cb(__u32 idx,struct num_context * ctx)90958465e2SEduard Zingerman static int loop_detection_cb(__u32 idx, struct num_context *ctx)
91958465e2SEduard Zingerman {
92958465e2SEduard Zingerman for (;;) {}
93958465e2SEduard Zingerman return 0;
94958465e2SEduard Zingerman }
95958465e2SEduard Zingerman
96958465e2SEduard Zingerman SEC("?raw_tp")
97958465e2SEduard Zingerman __failure __msg("infinite loop detected")
loop_detection(void * unused)98958465e2SEduard Zingerman int loop_detection(void *unused)
99958465e2SEduard Zingerman {
100958465e2SEduard Zingerman struct num_context loop_ctx = { .i = 0 };
101958465e2SEduard Zingerman
102958465e2SEduard Zingerman bpf_loop(100, loop_detection_cb, &loop_ctx, 0);
103958465e2SEduard Zingerman return 0;
104958465e2SEduard Zingerman }
105958465e2SEduard Zingerman
oob_state_machine(struct num_context * ctx)106958465e2SEduard Zingerman static __always_inline __u64 oob_state_machine(struct num_context *ctx)
107958465e2SEduard Zingerman {
108958465e2SEduard Zingerman switch (ctx->i) {
109958465e2SEduard Zingerman case 0:
110958465e2SEduard Zingerman ctx->i = 1;
111958465e2SEduard Zingerman break;
112958465e2SEduard Zingerman case 1:
113958465e2SEduard Zingerman ctx->i = 32;
114958465e2SEduard Zingerman break;
115958465e2SEduard Zingerman }
116958465e2SEduard Zingerman return 0;
117958465e2SEduard Zingerman }
118958465e2SEduard Zingerman
for_each_map_elem_cb(struct bpf_map * map,__u32 * key,__u64 * val,void * data)119958465e2SEduard Zingerman static __u64 for_each_map_elem_cb(struct bpf_map *map, __u32 *key, __u64 *val, void *data)
120958465e2SEduard Zingerman {
121958465e2SEduard Zingerman return oob_state_machine(data);
122958465e2SEduard Zingerman }
123958465e2SEduard Zingerman
124958465e2SEduard Zingerman SEC("?raw_tp")
125958465e2SEduard Zingerman __failure __msg("invalid access to map value, value_size=2 off=32 size=1")
unsafe_for_each_map_elem(void * unused)126958465e2SEduard Zingerman int unsafe_for_each_map_elem(void *unused)
127958465e2SEduard Zingerman {
128958465e2SEduard Zingerman struct num_context loop_ctx = { .i = 0 };
129958465e2SEduard Zingerman
130958465e2SEduard Zingerman bpf_for_each_map_elem(&map, for_each_map_elem_cb, &loop_ctx, 0);
131958465e2SEduard Zingerman return choice_arr[loop_ctx.i];
132958465e2SEduard Zingerman }
133958465e2SEduard Zingerman
ringbuf_drain_cb(struct bpf_dynptr * dynptr,void * data)134958465e2SEduard Zingerman static __u64 ringbuf_drain_cb(struct bpf_dynptr *dynptr, void *data)
135958465e2SEduard Zingerman {
136958465e2SEduard Zingerman return oob_state_machine(data);
137958465e2SEduard Zingerman }
138958465e2SEduard Zingerman
139958465e2SEduard Zingerman SEC("?raw_tp")
140958465e2SEduard Zingerman __failure __msg("invalid access to map value, value_size=2 off=32 size=1")
unsafe_ringbuf_drain(void * unused)141958465e2SEduard Zingerman int unsafe_ringbuf_drain(void *unused)
142958465e2SEduard Zingerman {
143958465e2SEduard Zingerman struct num_context loop_ctx = { .i = 0 };
144958465e2SEduard Zingerman
145958465e2SEduard Zingerman bpf_user_ringbuf_drain(&ringbuf, ringbuf_drain_cb, &loop_ctx, 0);
146958465e2SEduard Zingerman return choice_arr[loop_ctx.i];
147958465e2SEduard Zingerman }
148958465e2SEduard Zingerman
find_vma_cb(struct task_struct * task,struct vm_area_struct * vma,void * data)149958465e2SEduard Zingerman static __u64 find_vma_cb(struct task_struct *task, struct vm_area_struct *vma, void *data)
150958465e2SEduard Zingerman {
151958465e2SEduard Zingerman return oob_state_machine(data);
152958465e2SEduard Zingerman }
153958465e2SEduard Zingerman
154958465e2SEduard Zingerman SEC("?raw_tp")
155958465e2SEduard Zingerman __failure __msg("invalid access to map value, value_size=2 off=32 size=1")
unsafe_find_vma(void * unused)156958465e2SEduard Zingerman int unsafe_find_vma(void *unused)
157958465e2SEduard Zingerman {
158958465e2SEduard Zingerman struct task_struct *task = bpf_get_current_task_btf();
159958465e2SEduard Zingerman struct num_context loop_ctx = { .i = 0 };
160958465e2SEduard Zingerman
161958465e2SEduard Zingerman bpf_find_vma(task, 0, find_vma_cb, &loop_ctx, 0);
162958465e2SEduard Zingerman return choice_arr[loop_ctx.i];
163958465e2SEduard Zingerman }
164958465e2SEduard Zingerman
iter_limit_cb(__u32 idx,struct num_context * ctx)16557e2a52dSEduard Zingerman static int iter_limit_cb(__u32 idx, struct num_context *ctx)
16657e2a52dSEduard Zingerman {
16757e2a52dSEduard Zingerman ctx->i++;
16857e2a52dSEduard Zingerman return 0;
16957e2a52dSEduard Zingerman }
17057e2a52dSEduard Zingerman
17157e2a52dSEduard Zingerman SEC("?raw_tp")
17257e2a52dSEduard Zingerman __success
bpf_loop_iter_limit_ok(void * unused)17357e2a52dSEduard Zingerman int bpf_loop_iter_limit_ok(void *unused)
17457e2a52dSEduard Zingerman {
17557e2a52dSEduard Zingerman struct num_context ctx = { .i = 0 };
17657e2a52dSEduard Zingerman
17757e2a52dSEduard Zingerman bpf_loop(1, iter_limit_cb, &ctx, 0);
17857e2a52dSEduard Zingerman return choice_arr[ctx.i];
17957e2a52dSEduard Zingerman }
18057e2a52dSEduard Zingerman
18157e2a52dSEduard Zingerman SEC("?raw_tp")
18257e2a52dSEduard Zingerman __failure __msg("invalid access to map value, value_size=2 off=2 size=1")
bpf_loop_iter_limit_overflow(void * unused)18357e2a52dSEduard Zingerman int bpf_loop_iter_limit_overflow(void *unused)
18457e2a52dSEduard Zingerman {
18557e2a52dSEduard Zingerman struct num_context ctx = { .i = 0 };
18657e2a52dSEduard Zingerman
18757e2a52dSEduard Zingerman bpf_loop(2, iter_limit_cb, &ctx, 0);
18857e2a52dSEduard Zingerman return choice_arr[ctx.i];
18957e2a52dSEduard Zingerman }
19057e2a52dSEduard Zingerman
iter_limit_level2a_cb(__u32 idx,struct num_context * ctx)19157e2a52dSEduard Zingerman static int iter_limit_level2a_cb(__u32 idx, struct num_context *ctx)
19257e2a52dSEduard Zingerman {
19357e2a52dSEduard Zingerman ctx->i += 100;
19457e2a52dSEduard Zingerman return 0;
19557e2a52dSEduard Zingerman }
19657e2a52dSEduard Zingerman
iter_limit_level2b_cb(__u32 idx,struct num_context * ctx)19757e2a52dSEduard Zingerman static int iter_limit_level2b_cb(__u32 idx, struct num_context *ctx)
19857e2a52dSEduard Zingerman {
19957e2a52dSEduard Zingerman ctx->i += 10;
20057e2a52dSEduard Zingerman return 0;
20157e2a52dSEduard Zingerman }
20257e2a52dSEduard Zingerman
iter_limit_level1_cb(__u32 idx,struct num_context * ctx)20357e2a52dSEduard Zingerman static int iter_limit_level1_cb(__u32 idx, struct num_context *ctx)
20457e2a52dSEduard Zingerman {
20557e2a52dSEduard Zingerman ctx->i += 1;
20657e2a52dSEduard Zingerman bpf_loop(1, iter_limit_level2a_cb, ctx, 0);
20757e2a52dSEduard Zingerman bpf_loop(1, iter_limit_level2b_cb, ctx, 0);
20857e2a52dSEduard Zingerman return 0;
20957e2a52dSEduard Zingerman }
21057e2a52dSEduard Zingerman
21157e2a52dSEduard Zingerman /* Check that path visiting every callback function once had been
21257e2a52dSEduard Zingerman * reached by verifier. Variables 'ctx{1,2}i' below serve as flags,
21357e2a52dSEduard Zingerman * with each decimal digit corresponding to a callback visit marker.
21457e2a52dSEduard Zingerman */
21557e2a52dSEduard Zingerman SEC("socket")
21657e2a52dSEduard Zingerman __success __retval(111111)
bpf_loop_iter_limit_nested(void * unused)21757e2a52dSEduard Zingerman int bpf_loop_iter_limit_nested(void *unused)
21857e2a52dSEduard Zingerman {
21957e2a52dSEduard Zingerman struct num_context ctx1 = { .i = 0 };
22057e2a52dSEduard Zingerman struct num_context ctx2 = { .i = 0 };
22157e2a52dSEduard Zingerman __u64 a, b, c;
22257e2a52dSEduard Zingerman
22357e2a52dSEduard Zingerman bpf_loop(1, iter_limit_level1_cb, &ctx1, 0);
22457e2a52dSEduard Zingerman bpf_loop(1, iter_limit_level1_cb, &ctx2, 0);
22557e2a52dSEduard Zingerman a = ctx1.i;
22657e2a52dSEduard Zingerman b = ctx2.i;
22757e2a52dSEduard Zingerman /* Force 'ctx1.i' and 'ctx2.i' precise. */
22857e2a52dSEduard Zingerman c = choice_arr[(a + b) % 2];
22957e2a52dSEduard Zingerman /* This makes 'c' zero, but neither clang nor verifier know it. */
23057e2a52dSEduard Zingerman c /= 10;
23157e2a52dSEduard Zingerman /* Make sure that verifier does not visit 'impossible' states:
23257e2a52dSEduard Zingerman * enumerate all possible callback visit masks.
23357e2a52dSEduard Zingerman */
23457e2a52dSEduard Zingerman if (a != 0 && a != 1 && a != 11 && a != 101 && a != 111 &&
23557e2a52dSEduard Zingerman b != 0 && b != 1 && b != 11 && b != 101 && b != 111)
23657e2a52dSEduard Zingerman asm volatile ("r0 /= 0;" ::: "r0");
23757e2a52dSEduard Zingerman return 1000 * a + b + c;
23857e2a52dSEduard Zingerman }
23957e2a52dSEduard Zingerman
2405c2bc5e2SEduard Zingerman struct iter_limit_bug_ctx {
2415c2bc5e2SEduard Zingerman __u64 a;
2425c2bc5e2SEduard Zingerman __u64 b;
2435c2bc5e2SEduard Zingerman __u64 c;
2445c2bc5e2SEduard Zingerman };
2455c2bc5e2SEduard Zingerman
iter_limit_bug_cb(void)2465c2bc5e2SEduard Zingerman static __naked void iter_limit_bug_cb(void)
2475c2bc5e2SEduard Zingerman {
2485c2bc5e2SEduard Zingerman /* This is the same as C code below, but written
2495c2bc5e2SEduard Zingerman * in assembly to control which branches are fall-through.
2505c2bc5e2SEduard Zingerman *
2515c2bc5e2SEduard Zingerman * switch (bpf_get_prandom_u32()) {
2525c2bc5e2SEduard Zingerman * case 1: ctx->a = 42; break;
2535c2bc5e2SEduard Zingerman * case 2: ctx->b = 42; break;
2545c2bc5e2SEduard Zingerman * default: ctx->c = 42; break;
2555c2bc5e2SEduard Zingerman * }
2565c2bc5e2SEduard Zingerman */
2575c2bc5e2SEduard Zingerman asm volatile (
2585c2bc5e2SEduard Zingerman "r9 = r2;"
2595c2bc5e2SEduard Zingerman "call %[bpf_get_prandom_u32];"
2605c2bc5e2SEduard Zingerman "r1 = r0;"
2615c2bc5e2SEduard Zingerman "r2 = 42;"
2625c2bc5e2SEduard Zingerman "r0 = 0;"
2635c2bc5e2SEduard Zingerman "if r1 == 0x1 goto 1f;"
2645c2bc5e2SEduard Zingerman "if r1 == 0x2 goto 2f;"
2655c2bc5e2SEduard Zingerman "*(u64 *)(r9 + 16) = r2;"
2665c2bc5e2SEduard Zingerman "exit;"
2675c2bc5e2SEduard Zingerman "1: *(u64 *)(r9 + 0) = r2;"
2685c2bc5e2SEduard Zingerman "exit;"
2695c2bc5e2SEduard Zingerman "2: *(u64 *)(r9 + 8) = r2;"
2705c2bc5e2SEduard Zingerman "exit;"
2715c2bc5e2SEduard Zingerman :
2725c2bc5e2SEduard Zingerman : __imm(bpf_get_prandom_u32)
2735c2bc5e2SEduard Zingerman : __clobber_all
2745c2bc5e2SEduard Zingerman );
2755c2bc5e2SEduard Zingerman }
2765c2bc5e2SEduard Zingerman
277280e4ebfSAlexei Starovoitov int tmp_var;
278280e4ebfSAlexei Starovoitov SEC("socket")
279280e4ebfSAlexei Starovoitov __failure __msg("infinite loop detected at insn 2")
jgt_imm64_and_may_goto(void)280280e4ebfSAlexei Starovoitov __naked void jgt_imm64_and_may_goto(void)
281280e4ebfSAlexei Starovoitov {
282280e4ebfSAlexei Starovoitov asm volatile (" \
283280e4ebfSAlexei Starovoitov r0 = %[tmp_var] ll; \
284280e4ebfSAlexei Starovoitov l0_%=: .byte 0xe5; /* may_goto */ \
285280e4ebfSAlexei Starovoitov .byte 0; /* regs */ \
286280e4ebfSAlexei Starovoitov .short -3; /* off -3 */ \
287280e4ebfSAlexei Starovoitov .long 0; /* imm */ \
288280e4ebfSAlexei Starovoitov if r0 > 10 goto l0_%=; \
289280e4ebfSAlexei Starovoitov r0 = 0; \
290280e4ebfSAlexei Starovoitov exit; \
291280e4ebfSAlexei Starovoitov " :: __imm_addr(tmp_var)
292280e4ebfSAlexei Starovoitov : __clobber_all);
293280e4ebfSAlexei Starovoitov }
294280e4ebfSAlexei Starovoitov
295280e4ebfSAlexei Starovoitov SEC("socket")
296280e4ebfSAlexei Starovoitov __failure __msg("infinite loop detected at insn 1")
may_goto_self(void)297280e4ebfSAlexei Starovoitov __naked void may_goto_self(void)
298280e4ebfSAlexei Starovoitov {
299280e4ebfSAlexei Starovoitov asm volatile (" \
300280e4ebfSAlexei Starovoitov r0 = *(u32 *)(r10 - 4); \
301280e4ebfSAlexei Starovoitov l0_%=: .byte 0xe5; /* may_goto */ \
302280e4ebfSAlexei Starovoitov .byte 0; /* regs */ \
303280e4ebfSAlexei Starovoitov .short -1; /* off -1 */ \
304280e4ebfSAlexei Starovoitov .long 0; /* imm */ \
305280e4ebfSAlexei Starovoitov if r0 > 10 goto l0_%=; \
306280e4ebfSAlexei Starovoitov r0 = 0; \
307280e4ebfSAlexei Starovoitov exit; \
308280e4ebfSAlexei Starovoitov " ::: __clobber_all);
309280e4ebfSAlexei Starovoitov }
310280e4ebfSAlexei Starovoitov
311280e4ebfSAlexei Starovoitov SEC("socket")
312280e4ebfSAlexei Starovoitov __success __retval(0)
may_goto_neg_off(void)313280e4ebfSAlexei Starovoitov __naked void may_goto_neg_off(void)
314280e4ebfSAlexei Starovoitov {
315280e4ebfSAlexei Starovoitov asm volatile (" \
316280e4ebfSAlexei Starovoitov r0 = *(u32 *)(r10 - 4); \
317280e4ebfSAlexei Starovoitov goto l0_%=; \
318280e4ebfSAlexei Starovoitov goto l1_%=; \
319280e4ebfSAlexei Starovoitov l0_%=: .byte 0xe5; /* may_goto */ \
320280e4ebfSAlexei Starovoitov .byte 0; /* regs */ \
321280e4ebfSAlexei Starovoitov .short -2; /* off -2 */ \
322280e4ebfSAlexei Starovoitov .long 0; /* imm */ \
323280e4ebfSAlexei Starovoitov if r0 > 10 goto l0_%=; \
324280e4ebfSAlexei Starovoitov l1_%=: r0 = 0; \
325280e4ebfSAlexei Starovoitov exit; \
326280e4ebfSAlexei Starovoitov " ::: __clobber_all);
327280e4ebfSAlexei Starovoitov }
328280e4ebfSAlexei Starovoitov
3295c2bc5e2SEduard Zingerman SEC("tc")
3305c2bc5e2SEduard Zingerman __failure
__flag(BPF_F_TEST_STATE_FREQ)3315c2bc5e2SEduard Zingerman __flag(BPF_F_TEST_STATE_FREQ)
3325c2bc5e2SEduard Zingerman int iter_limit_bug(struct __sk_buff *skb)
3335c2bc5e2SEduard Zingerman {
3345c2bc5e2SEduard Zingerman struct iter_limit_bug_ctx ctx = { 7, 7, 7 };
3355c2bc5e2SEduard Zingerman
3365c2bc5e2SEduard Zingerman bpf_loop(2, iter_limit_bug_cb, &ctx, 0);
3375c2bc5e2SEduard Zingerman
3385c2bc5e2SEduard Zingerman /* This is the same as C code below,
3395c2bc5e2SEduard Zingerman * written in assembly to guarantee checks order.
3405c2bc5e2SEduard Zingerman *
3415c2bc5e2SEduard Zingerman * if (ctx.a == 42 && ctx.b == 42 && ctx.c == 7)
3425c2bc5e2SEduard Zingerman * asm volatile("r1 /= 0;":::"r1");
3435c2bc5e2SEduard Zingerman */
3445c2bc5e2SEduard Zingerman asm volatile (
3455c2bc5e2SEduard Zingerman "r1 = *(u64 *)%[ctx_a];"
3465c2bc5e2SEduard Zingerman "if r1 != 42 goto 1f;"
3475c2bc5e2SEduard Zingerman "r1 = *(u64 *)%[ctx_b];"
3485c2bc5e2SEduard Zingerman "if r1 != 42 goto 1f;"
3495c2bc5e2SEduard Zingerman "r1 = *(u64 *)%[ctx_c];"
3505c2bc5e2SEduard Zingerman "if r1 != 7 goto 1f;"
3515c2bc5e2SEduard Zingerman "r1 /= 0;"
3525c2bc5e2SEduard Zingerman "1:"
3535c2bc5e2SEduard Zingerman :
3545c2bc5e2SEduard Zingerman : [ctx_a]"m"(ctx.a),
3555c2bc5e2SEduard Zingerman [ctx_b]"m"(ctx.b),
3565c2bc5e2SEduard Zingerman [ctx_c]"m"(ctx.c)
3575c2bc5e2SEduard Zingerman : "r1"
3585c2bc5e2SEduard Zingerman );
3595c2bc5e2SEduard Zingerman return 0;
3605c2bc5e2SEduard Zingerman }
3615c2bc5e2SEduard Zingerman
36226733159SAlexei Starovoitov SEC("socket")
36326733159SAlexei Starovoitov __success __retval(0)
ja_and_may_goto(void)36426733159SAlexei Starovoitov __naked void ja_and_may_goto(void)
36526733159SAlexei Starovoitov {
36626733159SAlexei Starovoitov asm volatile (" \
36726733159SAlexei Starovoitov l0_%=: .byte 0xe5; /* may_goto */ \
36826733159SAlexei Starovoitov .byte 0; /* regs */ \
36926733159SAlexei Starovoitov .short 1; /* off 1 */ \
37026733159SAlexei Starovoitov .long 0; /* imm */ \
37126733159SAlexei Starovoitov goto l0_%=; \
37226733159SAlexei Starovoitov r0 = 0; \
37326733159SAlexei Starovoitov exit; \
37426733159SAlexei Starovoitov " ::: __clobber_common);
37526733159SAlexei Starovoitov }
37626733159SAlexei Starovoitov
37726733159SAlexei Starovoitov SEC("socket")
37826733159SAlexei Starovoitov __success __retval(0)
ja_and_may_goto2(void)37926733159SAlexei Starovoitov __naked void ja_and_may_goto2(void)
38026733159SAlexei Starovoitov {
38126733159SAlexei Starovoitov asm volatile (" \
38226733159SAlexei Starovoitov l0_%=: r0 = 0; \
38326733159SAlexei Starovoitov .byte 0xe5; /* may_goto */ \
38426733159SAlexei Starovoitov .byte 0; /* regs */ \
38526733159SAlexei Starovoitov .short 1; /* off 1 */ \
38626733159SAlexei Starovoitov .long 0; /* imm */ \
38726733159SAlexei Starovoitov goto l0_%=; \
38826733159SAlexei Starovoitov r0 = 0; \
38926733159SAlexei Starovoitov exit; \
39026733159SAlexei Starovoitov " ::: __clobber_common);
39126733159SAlexei Starovoitov }
39226733159SAlexei Starovoitov
39326733159SAlexei Starovoitov SEC("socket")
39426733159SAlexei Starovoitov __success __retval(0)
jlt_and_may_goto(void)39526733159SAlexei Starovoitov __naked void jlt_and_may_goto(void)
39626733159SAlexei Starovoitov {
39726733159SAlexei Starovoitov asm volatile (" \
39826733159SAlexei Starovoitov l0_%=: call %[bpf_jiffies64]; \
39926733159SAlexei Starovoitov .byte 0xe5; /* may_goto */ \
40026733159SAlexei Starovoitov .byte 0; /* regs */ \
40126733159SAlexei Starovoitov .short 1; /* off 1 */ \
40226733159SAlexei Starovoitov .long 0; /* imm */ \
40326733159SAlexei Starovoitov if r0 < 10 goto l0_%=; \
40426733159SAlexei Starovoitov r0 = 0; \
40526733159SAlexei Starovoitov exit; \
40626733159SAlexei Starovoitov " :: __imm(bpf_jiffies64)
40726733159SAlexei Starovoitov : __clobber_all);
40826733159SAlexei Starovoitov }
40926733159SAlexei Starovoitov
41026733159SAlexei Starovoitov #if (defined(__TARGET_ARCH_arm64) || defined(__TARGET_ARCH_x86) || \
41126733159SAlexei Starovoitov (defined(__TARGET_ARCH_riscv) && __riscv_xlen == 64) || \
41226733159SAlexei Starovoitov defined(__TARGET_ARCH_arm) || defined(__TARGET_ARCH_s390) || \
41326733159SAlexei Starovoitov defined(__TARGET_ARCH_loongarch)) && \
41426733159SAlexei Starovoitov __clang_major__ >= 18
41526733159SAlexei Starovoitov SEC("socket")
41626733159SAlexei Starovoitov __success __retval(0)
gotol_and_may_goto(void)41726733159SAlexei Starovoitov __naked void gotol_and_may_goto(void)
41826733159SAlexei Starovoitov {
41926733159SAlexei Starovoitov asm volatile (" \
42026733159SAlexei Starovoitov l0_%=: r0 = 0; \
42126733159SAlexei Starovoitov .byte 0xe5; /* may_goto */ \
42226733159SAlexei Starovoitov .byte 0; /* regs */ \
42326733159SAlexei Starovoitov .short 1; /* off 1 */ \
42426733159SAlexei Starovoitov .long 0; /* imm */ \
42526733159SAlexei Starovoitov gotol l0_%=; \
42626733159SAlexei Starovoitov r0 = 0; \
42726733159SAlexei Starovoitov exit; \
42826733159SAlexei Starovoitov " ::: __clobber_common);
42926733159SAlexei Starovoitov }
43026733159SAlexei Starovoitov #endif
43126733159SAlexei Starovoitov
43226733159SAlexei Starovoitov SEC("socket")
43326733159SAlexei Starovoitov __success __retval(0)
ja_and_may_goto_subprog(void)43426733159SAlexei Starovoitov __naked void ja_and_may_goto_subprog(void)
43526733159SAlexei Starovoitov {
43626733159SAlexei Starovoitov asm volatile (" \
43726733159SAlexei Starovoitov call subprog_with_may_goto; \
43826733159SAlexei Starovoitov exit; \
43926733159SAlexei Starovoitov " ::: __clobber_all);
44026733159SAlexei Starovoitov }
44126733159SAlexei Starovoitov
44226733159SAlexei Starovoitov static __naked __noinline __used
subprog_with_may_goto(void)44326733159SAlexei Starovoitov void subprog_with_may_goto(void)
44426733159SAlexei Starovoitov {
44526733159SAlexei Starovoitov asm volatile (" \
44626733159SAlexei Starovoitov l0_%=: .byte 0xe5; /* may_goto */ \
44726733159SAlexei Starovoitov .byte 0; /* regs */ \
44826733159SAlexei Starovoitov .short 1; /* off 1 */ \
44926733159SAlexei Starovoitov .long 0; /* imm */ \
45026733159SAlexei Starovoitov goto l0_%=; \
45126733159SAlexei Starovoitov r0 = 0; \
45226733159SAlexei Starovoitov exit; \
45326733159SAlexei Starovoitov " ::: __clobber_all);
45426733159SAlexei Starovoitov }
45526733159SAlexei Starovoitov
4560c8bbf99SAlexei Starovoitov #define ARR_SZ 1000000
4570c8bbf99SAlexei Starovoitov int zero;
4580c8bbf99SAlexei Starovoitov char arr[ARR_SZ];
4590c8bbf99SAlexei Starovoitov
4600c8bbf99SAlexei Starovoitov SEC("socket")
4610c8bbf99SAlexei Starovoitov __success __retval(0xd495cdc0)
cond_break1(const void * ctx)4620c8bbf99SAlexei Starovoitov int cond_break1(const void *ctx)
4630c8bbf99SAlexei Starovoitov {
4640c8bbf99SAlexei Starovoitov unsigned long i;
4650c8bbf99SAlexei Starovoitov unsigned int sum = 0;
4660c8bbf99SAlexei Starovoitov
467ba39486dSJose E. Marchesi for (i = zero; i < ARR_SZ && can_loop; i++)
4680c8bbf99SAlexei Starovoitov sum += i;
4690c8bbf99SAlexei Starovoitov for (i = zero; i < ARR_SZ; i++) {
4700c8bbf99SAlexei Starovoitov barrier_var(i);
4710c8bbf99SAlexei Starovoitov sum += i + arr[i];
4720c8bbf99SAlexei Starovoitov cond_break;
4730c8bbf99SAlexei Starovoitov }
4740c8bbf99SAlexei Starovoitov
4750c8bbf99SAlexei Starovoitov return sum;
4760c8bbf99SAlexei Starovoitov }
4770c8bbf99SAlexei Starovoitov
4780c8bbf99SAlexei Starovoitov SEC("socket")
4790c8bbf99SAlexei Starovoitov __success __retval(999000000)
cond_break2(const void * ctx)4800c8bbf99SAlexei Starovoitov int cond_break2(const void *ctx)
4810c8bbf99SAlexei Starovoitov {
4820c8bbf99SAlexei Starovoitov int i, j;
4830c8bbf99SAlexei Starovoitov int sum = 0;
4840c8bbf99SAlexei Starovoitov
485ba39486dSJose E. Marchesi for (i = zero; i < 1000 && can_loop; i++)
4860c8bbf99SAlexei Starovoitov for (j = zero; j < 1000; j++) {
4870c8bbf99SAlexei Starovoitov sum += i + j;
4880c8bbf99SAlexei Starovoitov cond_break;
4890c8bbf99SAlexei Starovoitov }
4900c8bbf99SAlexei Starovoitov return sum;
4910c8bbf99SAlexei Starovoitov }
4920c8bbf99SAlexei Starovoitov
loop(void)4930c8bbf99SAlexei Starovoitov static __noinline int loop(void)
4940c8bbf99SAlexei Starovoitov {
4950c8bbf99SAlexei Starovoitov int i, sum = 0;
4960c8bbf99SAlexei Starovoitov
497ba39486dSJose E. Marchesi for (i = zero; i <= 1000000 && can_loop; i++)
4980c8bbf99SAlexei Starovoitov sum += i;
4990c8bbf99SAlexei Starovoitov
5000c8bbf99SAlexei Starovoitov return sum;
5010c8bbf99SAlexei Starovoitov }
5020c8bbf99SAlexei Starovoitov
5030c8bbf99SAlexei Starovoitov SEC("socket")
5040c8bbf99SAlexei Starovoitov __success __retval(0x6a5a2920)
cond_break3(const void * ctx)5050c8bbf99SAlexei Starovoitov int cond_break3(const void *ctx)
5060c8bbf99SAlexei Starovoitov {
5070c8bbf99SAlexei Starovoitov return loop();
5080c8bbf99SAlexei Starovoitov }
5090c8bbf99SAlexei Starovoitov
5100c8bbf99SAlexei Starovoitov SEC("socket")
5110c8bbf99SAlexei Starovoitov __success __retval(1)
cond_break4(const void * ctx)5120c8bbf99SAlexei Starovoitov int cond_break4(const void *ctx)
5130c8bbf99SAlexei Starovoitov {
5140c8bbf99SAlexei Starovoitov int cnt = zero;
5150c8bbf99SAlexei Starovoitov
5160c8bbf99SAlexei Starovoitov for (;;) {
5170c8bbf99SAlexei Starovoitov /* should eventually break out of the loop */
5180c8bbf99SAlexei Starovoitov cond_break;
5190c8bbf99SAlexei Starovoitov cnt++;
5200c8bbf99SAlexei Starovoitov }
5210c8bbf99SAlexei Starovoitov /* if we looped a bit, it's a success */
5220c8bbf99SAlexei Starovoitov return cnt > 1 ? 1 : 0;
5230c8bbf99SAlexei Starovoitov }
5240c8bbf99SAlexei Starovoitov
static_subprog(void)5250c8bbf99SAlexei Starovoitov static __noinline int static_subprog(void)
5260c8bbf99SAlexei Starovoitov {
5270c8bbf99SAlexei Starovoitov int cnt = zero;
5280c8bbf99SAlexei Starovoitov
5290c8bbf99SAlexei Starovoitov for (;;) {
5300c8bbf99SAlexei Starovoitov cond_break;
5310c8bbf99SAlexei Starovoitov cnt++;
5320c8bbf99SAlexei Starovoitov }
5330c8bbf99SAlexei Starovoitov
5340c8bbf99SAlexei Starovoitov return cnt;
5350c8bbf99SAlexei Starovoitov }
5360c8bbf99SAlexei Starovoitov
5370c8bbf99SAlexei Starovoitov SEC("socket")
5380c8bbf99SAlexei Starovoitov __success __retval(1)
cond_break5(const void * ctx)5390c8bbf99SAlexei Starovoitov int cond_break5(const void *ctx)
5400c8bbf99SAlexei Starovoitov {
5410c8bbf99SAlexei Starovoitov int cnt1 = zero, cnt2;
5420c8bbf99SAlexei Starovoitov
5430c8bbf99SAlexei Starovoitov for (;;) {
5440c8bbf99SAlexei Starovoitov cond_break;
5450c8bbf99SAlexei Starovoitov cnt1++;
5460c8bbf99SAlexei Starovoitov }
5470c8bbf99SAlexei Starovoitov
5480c8bbf99SAlexei Starovoitov cnt2 = static_subprog();
5490c8bbf99SAlexei Starovoitov
5500c8bbf99SAlexei Starovoitov /* main and subprog have to loop a bit */
5510c8bbf99SAlexei Starovoitov return cnt1 > 1 && cnt2 > 1 ? 1 : 0;
5520c8bbf99SAlexei Starovoitov }
5530c8bbf99SAlexei Starovoitov
554*dedf56d7SAlexei Starovoitov #define ARR2_SZ 1000
555*dedf56d7SAlexei Starovoitov SEC(".data.arr2")
556*dedf56d7SAlexei Starovoitov char arr2[ARR2_SZ];
557*dedf56d7SAlexei Starovoitov
558*dedf56d7SAlexei Starovoitov SEC("socket")
__flag(BPF_F_TEST_STATE_FREQ)559*dedf56d7SAlexei Starovoitov __success __flag(BPF_F_TEST_STATE_FREQ)
560*dedf56d7SAlexei Starovoitov int loop_inside_iter(const void *ctx)
561*dedf56d7SAlexei Starovoitov {
562*dedf56d7SAlexei Starovoitov struct bpf_iter_num it;
563*dedf56d7SAlexei Starovoitov int *v, sum = 0;
564*dedf56d7SAlexei Starovoitov __u64 i = 0;
565*dedf56d7SAlexei Starovoitov
566*dedf56d7SAlexei Starovoitov bpf_iter_num_new(&it, 0, ARR2_SZ);
567*dedf56d7SAlexei Starovoitov while ((v = bpf_iter_num_next(&it))) {
568*dedf56d7SAlexei Starovoitov if (i < ARR2_SZ)
569*dedf56d7SAlexei Starovoitov sum += arr2[i++];
570*dedf56d7SAlexei Starovoitov }
571*dedf56d7SAlexei Starovoitov bpf_iter_num_destroy(&it);
572*dedf56d7SAlexei Starovoitov return sum;
573*dedf56d7SAlexei Starovoitov }
574*dedf56d7SAlexei Starovoitov
575*dedf56d7SAlexei Starovoitov SEC("socket")
__flag(BPF_F_TEST_STATE_FREQ)576*dedf56d7SAlexei Starovoitov __success __flag(BPF_F_TEST_STATE_FREQ)
577*dedf56d7SAlexei Starovoitov int loop_inside_iter_signed(const void *ctx)
578*dedf56d7SAlexei Starovoitov {
579*dedf56d7SAlexei Starovoitov struct bpf_iter_num it;
580*dedf56d7SAlexei Starovoitov int *v, sum = 0;
581*dedf56d7SAlexei Starovoitov long i = 0;
582*dedf56d7SAlexei Starovoitov
583*dedf56d7SAlexei Starovoitov bpf_iter_num_new(&it, 0, ARR2_SZ);
584*dedf56d7SAlexei Starovoitov while ((v = bpf_iter_num_next(&it))) {
585*dedf56d7SAlexei Starovoitov if (i < ARR2_SZ && i >= 0)
586*dedf56d7SAlexei Starovoitov sum += arr2[i++];
587*dedf56d7SAlexei Starovoitov }
588*dedf56d7SAlexei Starovoitov bpf_iter_num_destroy(&it);
589*dedf56d7SAlexei Starovoitov return sum;
590*dedf56d7SAlexei Starovoitov }
591*dedf56d7SAlexei Starovoitov
592*dedf56d7SAlexei Starovoitov volatile const int limit = ARR2_SZ;
593*dedf56d7SAlexei Starovoitov
594*dedf56d7SAlexei Starovoitov SEC("socket")
__flag(BPF_F_TEST_STATE_FREQ)595*dedf56d7SAlexei Starovoitov __success __flag(BPF_F_TEST_STATE_FREQ)
596*dedf56d7SAlexei Starovoitov int loop_inside_iter_volatile_limit(const void *ctx)
597*dedf56d7SAlexei Starovoitov {
598*dedf56d7SAlexei Starovoitov struct bpf_iter_num it;
599*dedf56d7SAlexei Starovoitov int *v, sum = 0;
600*dedf56d7SAlexei Starovoitov __u64 i = 0;
601*dedf56d7SAlexei Starovoitov
602*dedf56d7SAlexei Starovoitov bpf_iter_num_new(&it, 0, ARR2_SZ);
603*dedf56d7SAlexei Starovoitov while ((v = bpf_iter_num_next(&it))) {
604*dedf56d7SAlexei Starovoitov if (i < limit)
605*dedf56d7SAlexei Starovoitov sum += arr2[i++];
606*dedf56d7SAlexei Starovoitov }
607*dedf56d7SAlexei Starovoitov bpf_iter_num_destroy(&it);
608*dedf56d7SAlexei Starovoitov return sum;
609*dedf56d7SAlexei Starovoitov }
610*dedf56d7SAlexei Starovoitov
611*dedf56d7SAlexei Starovoitov #define ARR_LONG_SZ 1000
612*dedf56d7SAlexei Starovoitov
613*dedf56d7SAlexei Starovoitov SEC(".data.arr_long")
614*dedf56d7SAlexei Starovoitov long arr_long[ARR_LONG_SZ];
615*dedf56d7SAlexei Starovoitov
616*dedf56d7SAlexei Starovoitov SEC("socket")
617*dedf56d7SAlexei Starovoitov __success
test1(const void * ctx)618*dedf56d7SAlexei Starovoitov int test1(const void *ctx)
619*dedf56d7SAlexei Starovoitov {
620*dedf56d7SAlexei Starovoitov long i;
621*dedf56d7SAlexei Starovoitov
622*dedf56d7SAlexei Starovoitov for (i = 0; i < ARR_LONG_SZ && can_loop; i++)
623*dedf56d7SAlexei Starovoitov arr_long[i] = i;
624*dedf56d7SAlexei Starovoitov return 0;
625*dedf56d7SAlexei Starovoitov }
626*dedf56d7SAlexei Starovoitov
627*dedf56d7SAlexei Starovoitov SEC("socket")
628*dedf56d7SAlexei Starovoitov __success
test2(const void * ctx)629*dedf56d7SAlexei Starovoitov int test2(const void *ctx)
630*dedf56d7SAlexei Starovoitov {
631*dedf56d7SAlexei Starovoitov __u64 i;
632*dedf56d7SAlexei Starovoitov
633*dedf56d7SAlexei Starovoitov for (i = zero; i < ARR_LONG_SZ && can_loop; i++) {
634*dedf56d7SAlexei Starovoitov barrier_var(i);
635*dedf56d7SAlexei Starovoitov arr_long[i] = i;
636*dedf56d7SAlexei Starovoitov }
637*dedf56d7SAlexei Starovoitov return 0;
638*dedf56d7SAlexei Starovoitov }
639*dedf56d7SAlexei Starovoitov
640*dedf56d7SAlexei Starovoitov SEC(".data.arr_foo")
641*dedf56d7SAlexei Starovoitov struct {
642*dedf56d7SAlexei Starovoitov int a;
643*dedf56d7SAlexei Starovoitov int b;
644*dedf56d7SAlexei Starovoitov } arr_foo[ARR_LONG_SZ];
645*dedf56d7SAlexei Starovoitov
646*dedf56d7SAlexei Starovoitov SEC("socket")
647*dedf56d7SAlexei Starovoitov __success
test3(const void * ctx)648*dedf56d7SAlexei Starovoitov int test3(const void *ctx)
649*dedf56d7SAlexei Starovoitov {
650*dedf56d7SAlexei Starovoitov __u64 i;
651*dedf56d7SAlexei Starovoitov
652*dedf56d7SAlexei Starovoitov for (i = zero; i < ARR_LONG_SZ && can_loop; i++) {
653*dedf56d7SAlexei Starovoitov barrier_var(i);
654*dedf56d7SAlexei Starovoitov arr_foo[i].a = i;
655*dedf56d7SAlexei Starovoitov arr_foo[i].b = i;
656*dedf56d7SAlexei Starovoitov }
657*dedf56d7SAlexei Starovoitov return 0;
658*dedf56d7SAlexei Starovoitov }
659*dedf56d7SAlexei Starovoitov
660*dedf56d7SAlexei Starovoitov SEC("socket")
661*dedf56d7SAlexei Starovoitov __success
test4(const void * ctx)662*dedf56d7SAlexei Starovoitov int test4(const void *ctx)
663*dedf56d7SAlexei Starovoitov {
664*dedf56d7SAlexei Starovoitov long i;
665*dedf56d7SAlexei Starovoitov
666*dedf56d7SAlexei Starovoitov for (i = zero + ARR_LONG_SZ - 1; i < ARR_LONG_SZ && i >= 0 && can_loop; i--) {
667*dedf56d7SAlexei Starovoitov barrier_var(i);
668*dedf56d7SAlexei Starovoitov arr_foo[i].a = i;
669*dedf56d7SAlexei Starovoitov arr_foo[i].b = i;
670*dedf56d7SAlexei Starovoitov }
671*dedf56d7SAlexei Starovoitov return 0;
672*dedf56d7SAlexei Starovoitov }
673*dedf56d7SAlexei Starovoitov
674*dedf56d7SAlexei Starovoitov char buf[10] SEC(".data.buf");
675*dedf56d7SAlexei Starovoitov
676*dedf56d7SAlexei Starovoitov SEC("socket")
677*dedf56d7SAlexei Starovoitov __description("check add const")
678*dedf56d7SAlexei Starovoitov __success
check_add_const(void)679*dedf56d7SAlexei Starovoitov __naked void check_add_const(void)
680*dedf56d7SAlexei Starovoitov {
681*dedf56d7SAlexei Starovoitov /* typical LLVM generated loop with may_goto */
682*dedf56d7SAlexei Starovoitov asm volatile (" \
683*dedf56d7SAlexei Starovoitov call %[bpf_ktime_get_ns]; \
684*dedf56d7SAlexei Starovoitov if r0 > 9 goto l1_%=; \
685*dedf56d7SAlexei Starovoitov l0_%=: r1 = %[buf]; \
686*dedf56d7SAlexei Starovoitov r2 = r0; \
687*dedf56d7SAlexei Starovoitov r1 += r2; \
688*dedf56d7SAlexei Starovoitov r3 = *(u8 *)(r1 +0); \
689*dedf56d7SAlexei Starovoitov .byte 0xe5; /* may_goto */ \
690*dedf56d7SAlexei Starovoitov .byte 0; /* regs */ \
691*dedf56d7SAlexei Starovoitov .short 4; /* off of l1_%=: */ \
692*dedf56d7SAlexei Starovoitov .long 0; /* imm */ \
693*dedf56d7SAlexei Starovoitov r0 = r2; \
694*dedf56d7SAlexei Starovoitov r0 += 1; \
695*dedf56d7SAlexei Starovoitov if r2 < 9 goto l0_%=; \
696*dedf56d7SAlexei Starovoitov exit; \
697*dedf56d7SAlexei Starovoitov l1_%=: r0 = 0; \
698*dedf56d7SAlexei Starovoitov exit; \
699*dedf56d7SAlexei Starovoitov " :
700*dedf56d7SAlexei Starovoitov : __imm(bpf_ktime_get_ns),
701*dedf56d7SAlexei Starovoitov __imm_ptr(buf)
702*dedf56d7SAlexei Starovoitov : __clobber_common);
703*dedf56d7SAlexei Starovoitov }
704*dedf56d7SAlexei Starovoitov
705*dedf56d7SAlexei Starovoitov SEC("socket")
706*dedf56d7SAlexei Starovoitov __failure
707*dedf56d7SAlexei Starovoitov __msg("*(u8 *)(r7 +0) = r0")
708*dedf56d7SAlexei Starovoitov __msg("invalid access to map value, value_size=10 off=10 size=1")
check_add_const_3regs(void)709*dedf56d7SAlexei Starovoitov __naked void check_add_const_3regs(void)
710*dedf56d7SAlexei Starovoitov {
711*dedf56d7SAlexei Starovoitov asm volatile (
712*dedf56d7SAlexei Starovoitov "r6 = %[buf];"
713*dedf56d7SAlexei Starovoitov "r7 = %[buf];"
714*dedf56d7SAlexei Starovoitov "call %[bpf_ktime_get_ns];"
715*dedf56d7SAlexei Starovoitov "r1 = r0;" /* link r0.id == r1.id == r2.id */
716*dedf56d7SAlexei Starovoitov "r2 = r0;"
717*dedf56d7SAlexei Starovoitov "r1 += 1;" /* r1 == r0+1 */
718*dedf56d7SAlexei Starovoitov "r2 += 2;" /* r2 == r0+2 */
719*dedf56d7SAlexei Starovoitov "if r0 > 8 goto 1f;" /* r0 range [0, 8] */
720*dedf56d7SAlexei Starovoitov "r6 += r1;" /* r1 range [1, 9] */
721*dedf56d7SAlexei Starovoitov "r7 += r2;" /* r2 range [2, 10] */
722*dedf56d7SAlexei Starovoitov "*(u8 *)(r6 +0) = r0;" /* safe, within bounds */
723*dedf56d7SAlexei Starovoitov "*(u8 *)(r7 +0) = r0;" /* unsafe, out of bounds */
724*dedf56d7SAlexei Starovoitov "1: exit;"
725*dedf56d7SAlexei Starovoitov :
726*dedf56d7SAlexei Starovoitov : __imm(bpf_ktime_get_ns),
727*dedf56d7SAlexei Starovoitov __imm_ptr(buf)
728*dedf56d7SAlexei Starovoitov : __clobber_common);
729*dedf56d7SAlexei Starovoitov }
730*dedf56d7SAlexei Starovoitov
731*dedf56d7SAlexei Starovoitov SEC("socket")
732*dedf56d7SAlexei Starovoitov __failure
733*dedf56d7SAlexei Starovoitov __msg("*(u8 *)(r8 -1) = r0")
734*dedf56d7SAlexei Starovoitov __msg("invalid access to map value, value_size=10 off=10 size=1")
check_add_const_3regs_2if(void)735*dedf56d7SAlexei Starovoitov __naked void check_add_const_3regs_2if(void)
736*dedf56d7SAlexei Starovoitov {
737*dedf56d7SAlexei Starovoitov asm volatile (
738*dedf56d7SAlexei Starovoitov "r6 = %[buf];"
739*dedf56d7SAlexei Starovoitov "r7 = %[buf];"
740*dedf56d7SAlexei Starovoitov "r8 = %[buf];"
741*dedf56d7SAlexei Starovoitov "call %[bpf_ktime_get_ns];"
742*dedf56d7SAlexei Starovoitov "if r0 < 2 goto 1f;"
743*dedf56d7SAlexei Starovoitov "r1 = r0;" /* link r0.id == r1.id == r2.id */
744*dedf56d7SAlexei Starovoitov "r2 = r0;"
745*dedf56d7SAlexei Starovoitov "r1 += 1;" /* r1 == r0+1 */
746*dedf56d7SAlexei Starovoitov "r2 += 2;" /* r2 == r0+2 */
747*dedf56d7SAlexei Starovoitov "if r2 > 11 goto 1f;" /* r2 range [0, 11] -> r0 range [-2, 9]; r1 range [-1, 10] */
748*dedf56d7SAlexei Starovoitov "if r0 s< 0 goto 1f;" /* r0 range [0, 9] -> r1 range [1, 10]; r2 range [2, 11]; */
749*dedf56d7SAlexei Starovoitov "r6 += r0;" /* r0 range [0, 9] */
750*dedf56d7SAlexei Starovoitov "r7 += r1;" /* r1 range [1, 10] */
751*dedf56d7SAlexei Starovoitov "r8 += r2;" /* r2 range [2, 11] */
752*dedf56d7SAlexei Starovoitov "*(u8 *)(r6 +0) = r0;" /* safe, within bounds */
753*dedf56d7SAlexei Starovoitov "*(u8 *)(r7 -1) = r0;" /* safe */
754*dedf56d7SAlexei Starovoitov "*(u8 *)(r8 -1) = r0;" /* unsafe */
755*dedf56d7SAlexei Starovoitov "1: exit;"
756*dedf56d7SAlexei Starovoitov :
757*dedf56d7SAlexei Starovoitov : __imm(bpf_ktime_get_ns),
758*dedf56d7SAlexei Starovoitov __imm_ptr(buf)
759*dedf56d7SAlexei Starovoitov : __clobber_common);
760*dedf56d7SAlexei Starovoitov }
761*dedf56d7SAlexei Starovoitov
762*dedf56d7SAlexei Starovoitov SEC("socket")
763*dedf56d7SAlexei Starovoitov __failure
__flag(BPF_F_TEST_STATE_FREQ)764*dedf56d7SAlexei Starovoitov __flag(BPF_F_TEST_STATE_FREQ)
765*dedf56d7SAlexei Starovoitov __naked void check_add_const_regsafe_off(void)
766*dedf56d7SAlexei Starovoitov {
767*dedf56d7SAlexei Starovoitov asm volatile (
768*dedf56d7SAlexei Starovoitov "r8 = %[buf];"
769*dedf56d7SAlexei Starovoitov "call %[bpf_ktime_get_ns];"
770*dedf56d7SAlexei Starovoitov "r6 = r0;"
771*dedf56d7SAlexei Starovoitov "call %[bpf_ktime_get_ns];"
772*dedf56d7SAlexei Starovoitov "r7 = r0;"
773*dedf56d7SAlexei Starovoitov "call %[bpf_ktime_get_ns];"
774*dedf56d7SAlexei Starovoitov "r1 = r0;" /* same ids for r1 and r0 */
775*dedf56d7SAlexei Starovoitov "if r6 > r7 goto 1f;" /* this jump can't be predicted */
776*dedf56d7SAlexei Starovoitov "r1 += 1;" /* r1.off == +1 */
777*dedf56d7SAlexei Starovoitov "goto 2f;"
778*dedf56d7SAlexei Starovoitov "1: r1 += 100;" /* r1.off == +100 */
779*dedf56d7SAlexei Starovoitov "goto +0;" /* verify r1.off in regsafe() after this insn */
780*dedf56d7SAlexei Starovoitov "2: if r0 > 8 goto 3f;" /* r0 range [0,8], r1 range either [1,9] or [100,108]*/
781*dedf56d7SAlexei Starovoitov "r8 += r1;"
782*dedf56d7SAlexei Starovoitov "*(u8 *)(r8 +0) = r0;" /* potentially unsafe, buf size is 10 */
783*dedf56d7SAlexei Starovoitov "3: exit;"
784*dedf56d7SAlexei Starovoitov :
785*dedf56d7SAlexei Starovoitov : __imm(bpf_ktime_get_ns),
786*dedf56d7SAlexei Starovoitov __imm_ptr(buf)
787*dedf56d7SAlexei Starovoitov : __clobber_common);
788*dedf56d7SAlexei Starovoitov }
789*dedf56d7SAlexei Starovoitov
790958465e2SEduard Zingerman char _license[] SEC("license") = "GPL";
791