1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Converted from tools/testing/selftests/bpf/verifier/xdp_direct_packet_access.c */ |
3 | |
4 | #include <linux/bpf.h> |
5 | #include <bpf/bpf_helpers.h> |
6 | #include "bpf_misc.h" |
7 | |
8 | SEC("xdp" ) |
9 | __description("XDP pkt read, pkt_end mangling, bad access 1" ) |
10 | __failure __msg("R3 pointer arithmetic on pkt_end" ) |
11 | __naked void end_mangling_bad_access_1(void) |
12 | { |
13 | asm volatile (" \ |
14 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
15 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
16 | r1 = r2; \ |
17 | r1 += 8; \ |
18 | r3 += 8; \ |
19 | if r1 > r3 goto l0_%=; \ |
20 | r0 = *(u64*)(r1 - 8); \ |
21 | l0_%=: r0 = 0; \ |
22 | exit; \ |
23 | " : |
24 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
25 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
26 | : __clobber_all); |
27 | } |
28 | |
29 | SEC("xdp" ) |
30 | __description("XDP pkt read, pkt_end mangling, bad access 2" ) |
31 | __failure __msg("R3 pointer arithmetic on pkt_end" ) |
32 | __naked void end_mangling_bad_access_2(void) |
33 | { |
34 | asm volatile (" \ |
35 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
36 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
37 | r1 = r2; \ |
38 | r1 += 8; \ |
39 | r3 -= 8; \ |
40 | if r1 > r3 goto l0_%=; \ |
41 | r0 = *(u64*)(r1 - 8); \ |
42 | l0_%=: r0 = 0; \ |
43 | exit; \ |
44 | " : |
45 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
46 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
47 | : __clobber_all); |
48 | } |
49 | |
50 | SEC("xdp" ) |
51 | __description("XDP pkt read, pkt_data' > pkt_end, corner case, good access" ) |
52 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
53 | __naked void end_corner_case_good_access_1(void) |
54 | { |
55 | asm volatile (" \ |
56 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
57 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
58 | r1 = r2; \ |
59 | r1 += 8; \ |
60 | if r1 > r3 goto l0_%=; \ |
61 | r0 = *(u64*)(r1 - 8); \ |
62 | l0_%=: r0 = 0; \ |
63 | exit; \ |
64 | " : |
65 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
66 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
67 | : __clobber_all); |
68 | } |
69 | |
70 | SEC("xdp" ) |
71 | __description("XDP pkt read, pkt_data' > pkt_end, bad access 1" ) |
72 | __failure __msg("R1 offset is outside of the packet" ) |
73 | __flag(BPF_F_ANY_ALIGNMENT) |
74 | __naked void pkt_end_bad_access_1_1(void) |
75 | { |
76 | asm volatile (" \ |
77 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
78 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
79 | r1 = r2; \ |
80 | r1 += 8; \ |
81 | if r1 > r3 goto l0_%=; \ |
82 | r0 = *(u64*)(r1 - 4); \ |
83 | l0_%=: r0 = 0; \ |
84 | exit; \ |
85 | " : |
86 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
87 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
88 | : __clobber_all); |
89 | } |
90 | |
91 | SEC("xdp" ) |
92 | __description("XDP pkt read, pkt_data' > pkt_end, bad access 2" ) |
93 | __failure __msg("R1 offset is outside of the packet" ) |
94 | __flag(BPF_F_ANY_ALIGNMENT) |
95 | __naked void pkt_end_bad_access_2_1(void) |
96 | { |
97 | asm volatile (" \ |
98 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
99 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
100 | r1 = r2; \ |
101 | r1 += 8; \ |
102 | if r1 > r3 goto l0_%=; \ |
103 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
104 | r0 = 0; \ |
105 | exit; \ |
106 | " : |
107 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
108 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
109 | : __clobber_all); |
110 | } |
111 | |
112 | SEC("xdp" ) |
113 | __description("XDP pkt read, pkt_data' > pkt_end, corner case +1, good access" ) |
114 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
115 | __naked void corner_case_1_good_access_1(void) |
116 | { |
117 | asm volatile (" \ |
118 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
119 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
120 | r1 = r2; \ |
121 | r1 += 9; \ |
122 | if r1 > r3 goto l0_%=; \ |
123 | r0 = *(u64*)(r1 - 9); \ |
124 | l0_%=: r0 = 0; \ |
125 | exit; \ |
126 | " : |
127 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
128 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
129 | : __clobber_all); |
130 | } |
131 | |
132 | SEC("xdp" ) |
133 | __description("XDP pkt read, pkt_data' > pkt_end, corner case -1, bad access" ) |
134 | __failure __msg("R1 offset is outside of the packet" ) |
135 | __flag(BPF_F_ANY_ALIGNMENT) |
136 | __naked void corner_case_1_bad_access_1(void) |
137 | { |
138 | asm volatile (" \ |
139 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
140 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
141 | r1 = r2; \ |
142 | r1 += 7; \ |
143 | if r1 > r3 goto l0_%=; \ |
144 | r0 = *(u64*)(r1 - 7); \ |
145 | l0_%=: r0 = 0; \ |
146 | exit; \ |
147 | " : |
148 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
149 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
150 | : __clobber_all); |
151 | } |
152 | |
153 | SEC("xdp" ) |
154 | __description("XDP pkt read, pkt_end > pkt_data', good access" ) |
155 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
156 | __naked void end_pkt_data_good_access_1(void) |
157 | { |
158 | asm volatile (" \ |
159 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
160 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
161 | r1 = r2; \ |
162 | r1 += 8; \ |
163 | if r3 > r1 goto l0_%=; \ |
164 | goto l1_%=; \ |
165 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
166 | l1_%=: r0 = 0; \ |
167 | exit; \ |
168 | " : |
169 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
170 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
171 | : __clobber_all); |
172 | } |
173 | |
174 | SEC("xdp" ) |
175 | __description("XDP pkt read, pkt_end > pkt_data', corner case -1, bad access" ) |
176 | __failure __msg("R1 offset is outside of the packet" ) |
177 | __flag(BPF_F_ANY_ALIGNMENT) |
178 | __naked void corner_case_1_bad_access_2(void) |
179 | { |
180 | asm volatile (" \ |
181 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
182 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
183 | r1 = r2; \ |
184 | r1 += 6; \ |
185 | if r3 > r1 goto l0_%=; \ |
186 | goto l1_%=; \ |
187 | l0_%=: r0 = *(u64*)(r1 - 6); \ |
188 | l1_%=: r0 = 0; \ |
189 | exit; \ |
190 | " : |
191 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
192 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
193 | : __clobber_all); |
194 | } |
195 | |
196 | SEC("xdp" ) |
197 | __description("XDP pkt read, pkt_end > pkt_data', bad access 2" ) |
198 | __failure __msg("R1 offset is outside of the packet" ) |
199 | __flag(BPF_F_ANY_ALIGNMENT) |
200 | __naked void pkt_data_bad_access_2_1(void) |
201 | { |
202 | asm volatile (" \ |
203 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
204 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
205 | r1 = r2; \ |
206 | r1 += 8; \ |
207 | if r3 > r1 goto l0_%=; \ |
208 | r0 = *(u64*)(r1 - 8); \ |
209 | l0_%=: r0 = 0; \ |
210 | exit; \ |
211 | " : |
212 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
213 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
214 | : __clobber_all); |
215 | } |
216 | |
217 | SEC("xdp" ) |
218 | __description("XDP pkt read, pkt_end > pkt_data', corner case, good access" ) |
219 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
220 | __naked void data_corner_case_good_access_1(void) |
221 | { |
222 | asm volatile (" \ |
223 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
224 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
225 | r1 = r2; \ |
226 | r1 += 7; \ |
227 | if r3 > r1 goto l0_%=; \ |
228 | goto l1_%=; \ |
229 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
230 | l1_%=: r0 = 0; \ |
231 | exit; \ |
232 | " : |
233 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
234 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
235 | : __clobber_all); |
236 | } |
237 | |
238 | SEC("xdp" ) |
239 | __description("XDP pkt read, pkt_end > pkt_data', corner case +1, good access" ) |
240 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
241 | __naked void corner_case_1_good_access_2(void) |
242 | { |
243 | asm volatile (" \ |
244 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
245 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
246 | r1 = r2; \ |
247 | r1 += 8; \ |
248 | if r3 > r1 goto l0_%=; \ |
249 | goto l1_%=; \ |
250 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
251 | l1_%=: r0 = 0; \ |
252 | exit; \ |
253 | " : |
254 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
255 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
256 | : __clobber_all); |
257 | } |
258 | |
259 | SEC("xdp" ) |
260 | __description("XDP pkt read, pkt_data' < pkt_end, good access" ) |
261 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
262 | __naked void data_pkt_end_good_access_1(void) |
263 | { |
264 | asm volatile (" \ |
265 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
266 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
267 | r1 = r2; \ |
268 | r1 += 8; \ |
269 | if r1 < r3 goto l0_%=; \ |
270 | goto l1_%=; \ |
271 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
272 | l1_%=: r0 = 0; \ |
273 | exit; \ |
274 | " : |
275 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
276 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
277 | : __clobber_all); |
278 | } |
279 | |
280 | SEC("xdp" ) |
281 | __description("XDP pkt read, pkt_data' < pkt_end, corner case -1, bad access" ) |
282 | __failure __msg("R1 offset is outside of the packet" ) |
283 | __flag(BPF_F_ANY_ALIGNMENT) |
284 | __naked void corner_case_1_bad_access_3(void) |
285 | { |
286 | asm volatile (" \ |
287 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
288 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
289 | r1 = r2; \ |
290 | r1 += 6; \ |
291 | if r1 < r3 goto l0_%=; \ |
292 | goto l1_%=; \ |
293 | l0_%=: r0 = *(u64*)(r1 - 6); \ |
294 | l1_%=: r0 = 0; \ |
295 | exit; \ |
296 | " : |
297 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
298 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
299 | : __clobber_all); |
300 | } |
301 | |
302 | SEC("xdp" ) |
303 | __description("XDP pkt read, pkt_data' < pkt_end, bad access 2" ) |
304 | __failure __msg("R1 offset is outside of the packet" ) |
305 | __flag(BPF_F_ANY_ALIGNMENT) |
306 | __naked void pkt_end_bad_access_2_2(void) |
307 | { |
308 | asm volatile (" \ |
309 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
310 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
311 | r1 = r2; \ |
312 | r1 += 8; \ |
313 | if r1 < r3 goto l0_%=; \ |
314 | r0 = *(u64*)(r1 - 8); \ |
315 | l0_%=: r0 = 0; \ |
316 | exit; \ |
317 | " : |
318 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
319 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
320 | : __clobber_all); |
321 | } |
322 | |
323 | SEC("xdp" ) |
324 | __description("XDP pkt read, pkt_data' < pkt_end, corner case, good access" ) |
325 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
326 | __naked void end_corner_case_good_access_2(void) |
327 | { |
328 | asm volatile (" \ |
329 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
330 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
331 | r1 = r2; \ |
332 | r1 += 7; \ |
333 | if r1 < r3 goto l0_%=; \ |
334 | goto l1_%=; \ |
335 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
336 | l1_%=: r0 = 0; \ |
337 | exit; \ |
338 | " : |
339 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
340 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
341 | : __clobber_all); |
342 | } |
343 | |
344 | SEC("xdp" ) |
345 | __description("XDP pkt read, pkt_data' < pkt_end, corner case +1, good access" ) |
346 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
347 | __naked void corner_case_1_good_access_3(void) |
348 | { |
349 | asm volatile (" \ |
350 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
351 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
352 | r1 = r2; \ |
353 | r1 += 8; \ |
354 | if r1 < r3 goto l0_%=; \ |
355 | goto l1_%=; \ |
356 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
357 | l1_%=: r0 = 0; \ |
358 | exit; \ |
359 | " : |
360 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
361 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
362 | : __clobber_all); |
363 | } |
364 | |
365 | SEC("xdp" ) |
366 | __description("XDP pkt read, pkt_end < pkt_data', corner case, good access" ) |
367 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
368 | __naked void data_corner_case_good_access_2(void) |
369 | { |
370 | asm volatile (" \ |
371 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
372 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
373 | r1 = r2; \ |
374 | r1 += 8; \ |
375 | if r3 < r1 goto l0_%=; \ |
376 | r0 = *(u64*)(r1 - 8); \ |
377 | l0_%=: r0 = 0; \ |
378 | exit; \ |
379 | " : |
380 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
381 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
382 | : __clobber_all); |
383 | } |
384 | |
385 | SEC("xdp" ) |
386 | __description("XDP pkt read, pkt_end < pkt_data', bad access 1" ) |
387 | __failure __msg("R1 offset is outside of the packet" ) |
388 | __flag(BPF_F_ANY_ALIGNMENT) |
389 | __naked void pkt_data_bad_access_1_1(void) |
390 | { |
391 | asm volatile (" \ |
392 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
393 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
394 | r1 = r2; \ |
395 | r1 += 8; \ |
396 | if r3 < r1 goto l0_%=; \ |
397 | r0 = *(u64*)(r1 - 4); \ |
398 | l0_%=: r0 = 0; \ |
399 | exit; \ |
400 | " : |
401 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
402 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
403 | : __clobber_all); |
404 | } |
405 | |
406 | SEC("xdp" ) |
407 | __description("XDP pkt read, pkt_end < pkt_data', bad access 2" ) |
408 | __failure __msg("R1 offset is outside of the packet" ) |
409 | __flag(BPF_F_ANY_ALIGNMENT) |
410 | __naked void pkt_data_bad_access_2_2(void) |
411 | { |
412 | asm volatile (" \ |
413 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
414 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
415 | r1 = r2; \ |
416 | r1 += 8; \ |
417 | if r3 < r1 goto l0_%=; \ |
418 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
419 | r0 = 0; \ |
420 | exit; \ |
421 | " : |
422 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
423 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
424 | : __clobber_all); |
425 | } |
426 | |
427 | SEC("xdp" ) |
428 | __description("XDP pkt read, pkt_end < pkt_data', corner case +1, good access" ) |
429 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
430 | __naked void corner_case_1_good_access_4(void) |
431 | { |
432 | asm volatile (" \ |
433 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
434 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
435 | r1 = r2; \ |
436 | r1 += 9; \ |
437 | if r3 < r1 goto l0_%=; \ |
438 | r0 = *(u64*)(r1 - 9); \ |
439 | l0_%=: r0 = 0; \ |
440 | exit; \ |
441 | " : |
442 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
443 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
444 | : __clobber_all); |
445 | } |
446 | |
447 | SEC("xdp" ) |
448 | __description("XDP pkt read, pkt_end < pkt_data', corner case -1, bad access" ) |
449 | __failure __msg("R1 offset is outside of the packet" ) |
450 | __flag(BPF_F_ANY_ALIGNMENT) |
451 | __naked void corner_case_1_bad_access_4(void) |
452 | { |
453 | asm volatile (" \ |
454 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
455 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
456 | r1 = r2; \ |
457 | r1 += 7; \ |
458 | if r3 < r1 goto l0_%=; \ |
459 | r0 = *(u64*)(r1 - 7); \ |
460 | l0_%=: r0 = 0; \ |
461 | exit; \ |
462 | " : |
463 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
464 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
465 | : __clobber_all); |
466 | } |
467 | |
468 | SEC("xdp" ) |
469 | __description("XDP pkt read, pkt_data' >= pkt_end, good access" ) |
470 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
471 | __naked void data_pkt_end_good_access_2(void) |
472 | { |
473 | asm volatile (" \ |
474 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
475 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
476 | r1 = r2; \ |
477 | r1 += 8; \ |
478 | if r1 >= r3 goto l0_%=; \ |
479 | r0 = *(u32*)(r1 - 5); \ |
480 | l0_%=: r0 = 0; \ |
481 | exit; \ |
482 | " : |
483 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
484 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
485 | : __clobber_all); |
486 | } |
487 | |
488 | SEC("xdp" ) |
489 | __description("XDP pkt read, pkt_data' >= pkt_end, corner case -1, bad access" ) |
490 | __failure __msg("R1 offset is outside of the packet" ) |
491 | __flag(BPF_F_ANY_ALIGNMENT) |
492 | __naked void corner_case_1_bad_access_5(void) |
493 | { |
494 | asm volatile (" \ |
495 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
496 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
497 | r1 = r2; \ |
498 | r1 += 6; \ |
499 | if r1 >= r3 goto l0_%=; \ |
500 | r0 = *(u64*)(r1 - 6); \ |
501 | l0_%=: r0 = 0; \ |
502 | exit; \ |
503 | " : |
504 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
505 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
506 | : __clobber_all); |
507 | } |
508 | |
509 | SEC("xdp" ) |
510 | __description("XDP pkt read, pkt_data' >= pkt_end, bad access 2" ) |
511 | __failure __msg("R1 offset is outside of the packet" ) |
512 | __flag(BPF_F_ANY_ALIGNMENT) |
513 | __naked void pkt_end_bad_access_2_3(void) |
514 | { |
515 | asm volatile (" \ |
516 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
517 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
518 | r1 = r2; \ |
519 | r1 += 8; \ |
520 | if r1 >= r3 goto l0_%=; \ |
521 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
522 | r0 = 0; \ |
523 | exit; \ |
524 | " : |
525 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
526 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
527 | : __clobber_all); |
528 | } |
529 | |
530 | SEC("xdp" ) |
531 | __description("XDP pkt read, pkt_data' >= pkt_end, corner case, good access" ) |
532 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
533 | __naked void end_corner_case_good_access_3(void) |
534 | { |
535 | asm volatile (" \ |
536 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
537 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
538 | r1 = r2; \ |
539 | r1 += 7; \ |
540 | if r1 >= r3 goto l0_%=; \ |
541 | r0 = *(u64*)(r1 - 7); \ |
542 | l0_%=: r0 = 0; \ |
543 | exit; \ |
544 | " : |
545 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
546 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
547 | : __clobber_all); |
548 | } |
549 | |
550 | SEC("xdp" ) |
551 | __description("XDP pkt read, pkt_data' >= pkt_end, corner case +1, good access" ) |
552 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
553 | __naked void corner_case_1_good_access_5(void) |
554 | { |
555 | asm volatile (" \ |
556 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
557 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
558 | r1 = r2; \ |
559 | r1 += 8; \ |
560 | if r1 >= r3 goto l0_%=; \ |
561 | r0 = *(u64*)(r1 - 8); \ |
562 | l0_%=: r0 = 0; \ |
563 | exit; \ |
564 | " : |
565 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
566 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
567 | : __clobber_all); |
568 | } |
569 | |
570 | SEC("xdp" ) |
571 | __description("XDP pkt read, pkt_end >= pkt_data', corner case, good access" ) |
572 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
573 | __naked void data_corner_case_good_access_3(void) |
574 | { |
575 | asm volatile (" \ |
576 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
577 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
578 | r1 = r2; \ |
579 | r1 += 8; \ |
580 | if r3 >= r1 goto l0_%=; \ |
581 | goto l1_%=; \ |
582 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
583 | l1_%=: r0 = 0; \ |
584 | exit; \ |
585 | " : |
586 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
587 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
588 | : __clobber_all); |
589 | } |
590 | |
591 | SEC("xdp" ) |
592 | __description("XDP pkt read, pkt_end >= pkt_data', bad access 1" ) |
593 | __failure __msg("R1 offset is outside of the packet" ) |
594 | __flag(BPF_F_ANY_ALIGNMENT) |
595 | __naked void pkt_data_bad_access_1_2(void) |
596 | { |
597 | asm volatile (" \ |
598 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
599 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
600 | r1 = r2; \ |
601 | r1 += 8; \ |
602 | if r3 >= r1 goto l0_%=; \ |
603 | goto l1_%=; \ |
604 | l0_%=: r0 = *(u64*)(r1 - 4); \ |
605 | l1_%=: r0 = 0; \ |
606 | exit; \ |
607 | " : |
608 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
609 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
610 | : __clobber_all); |
611 | } |
612 | |
613 | SEC("xdp" ) |
614 | __description("XDP pkt read, pkt_end >= pkt_data', bad access 2" ) |
615 | __failure __msg("R1 offset is outside of the packet" ) |
616 | __flag(BPF_F_ANY_ALIGNMENT) |
617 | __naked void pkt_data_bad_access_2_3(void) |
618 | { |
619 | asm volatile (" \ |
620 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
621 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
622 | r1 = r2; \ |
623 | r1 += 8; \ |
624 | if r3 >= r1 goto l0_%=; \ |
625 | r0 = *(u64*)(r1 - 8); \ |
626 | l0_%=: r0 = 0; \ |
627 | exit; \ |
628 | " : |
629 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
630 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
631 | : __clobber_all); |
632 | } |
633 | |
634 | SEC("xdp" ) |
635 | __description("XDP pkt read, pkt_end >= pkt_data', corner case +1, good access" ) |
636 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
637 | __naked void corner_case_1_good_access_6(void) |
638 | { |
639 | asm volatile (" \ |
640 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
641 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
642 | r1 = r2; \ |
643 | r1 += 9; \ |
644 | if r3 >= r1 goto l0_%=; \ |
645 | goto l1_%=; \ |
646 | l0_%=: r0 = *(u64*)(r1 - 9); \ |
647 | l1_%=: r0 = 0; \ |
648 | exit; \ |
649 | " : |
650 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
651 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
652 | : __clobber_all); |
653 | } |
654 | |
655 | SEC("xdp" ) |
656 | __description("XDP pkt read, pkt_end >= pkt_data', corner case -1, bad access" ) |
657 | __failure __msg("R1 offset is outside of the packet" ) |
658 | __flag(BPF_F_ANY_ALIGNMENT) |
659 | __naked void corner_case_1_bad_access_6(void) |
660 | { |
661 | asm volatile (" \ |
662 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
663 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
664 | r1 = r2; \ |
665 | r1 += 7; \ |
666 | if r3 >= r1 goto l0_%=; \ |
667 | goto l1_%=; \ |
668 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
669 | l1_%=: r0 = 0; \ |
670 | exit; \ |
671 | " : |
672 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
673 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
674 | : __clobber_all); |
675 | } |
676 | |
677 | SEC("xdp" ) |
678 | __description("XDP pkt read, pkt_data' <= pkt_end, corner case, good access" ) |
679 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
680 | __naked void end_corner_case_good_access_4(void) |
681 | { |
682 | asm volatile (" \ |
683 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
684 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
685 | r1 = r2; \ |
686 | r1 += 8; \ |
687 | if r1 <= r3 goto l0_%=; \ |
688 | goto l1_%=; \ |
689 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
690 | l1_%=: r0 = 0; \ |
691 | exit; \ |
692 | " : |
693 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
694 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
695 | : __clobber_all); |
696 | } |
697 | |
698 | SEC("xdp" ) |
699 | __description("XDP pkt read, pkt_data' <= pkt_end, bad access 1" ) |
700 | __failure __msg("R1 offset is outside of the packet" ) |
701 | __flag(BPF_F_ANY_ALIGNMENT) |
702 | __naked void pkt_end_bad_access_1_2(void) |
703 | { |
704 | asm volatile (" \ |
705 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
706 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
707 | r1 = r2; \ |
708 | r1 += 8; \ |
709 | if r1 <= r3 goto l0_%=; \ |
710 | goto l1_%=; \ |
711 | l0_%=: r0 = *(u64*)(r1 - 4); \ |
712 | l1_%=: r0 = 0; \ |
713 | exit; \ |
714 | " : |
715 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
716 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
717 | : __clobber_all); |
718 | } |
719 | |
720 | SEC("xdp" ) |
721 | __description("XDP pkt read, pkt_data' <= pkt_end, bad access 2" ) |
722 | __failure __msg("R1 offset is outside of the packet" ) |
723 | __flag(BPF_F_ANY_ALIGNMENT) |
724 | __naked void pkt_end_bad_access_2_4(void) |
725 | { |
726 | asm volatile (" \ |
727 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
728 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
729 | r1 = r2; \ |
730 | r1 += 8; \ |
731 | if r1 <= r3 goto l0_%=; \ |
732 | r0 = *(u64*)(r1 - 8); \ |
733 | l0_%=: r0 = 0; \ |
734 | exit; \ |
735 | " : |
736 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
737 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
738 | : __clobber_all); |
739 | } |
740 | |
741 | SEC("xdp" ) |
742 | __description("XDP pkt read, pkt_data' <= pkt_end, corner case +1, good access" ) |
743 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
744 | __naked void corner_case_1_good_access_7(void) |
745 | { |
746 | asm volatile (" \ |
747 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
748 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
749 | r1 = r2; \ |
750 | r1 += 9; \ |
751 | if r1 <= r3 goto l0_%=; \ |
752 | goto l1_%=; \ |
753 | l0_%=: r0 = *(u64*)(r1 - 9); \ |
754 | l1_%=: r0 = 0; \ |
755 | exit; \ |
756 | " : |
757 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
758 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
759 | : __clobber_all); |
760 | } |
761 | |
762 | SEC("xdp" ) |
763 | __description("XDP pkt read, pkt_data' <= pkt_end, corner case -1, bad access" ) |
764 | __failure __msg("R1 offset is outside of the packet" ) |
765 | __flag(BPF_F_ANY_ALIGNMENT) |
766 | __naked void corner_case_1_bad_access_7(void) |
767 | { |
768 | asm volatile (" \ |
769 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
770 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
771 | r1 = r2; \ |
772 | r1 += 7; \ |
773 | if r1 <= r3 goto l0_%=; \ |
774 | goto l1_%=; \ |
775 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
776 | l1_%=: r0 = 0; \ |
777 | exit; \ |
778 | " : |
779 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
780 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
781 | : __clobber_all); |
782 | } |
783 | |
784 | SEC("xdp" ) |
785 | __description("XDP pkt read, pkt_end <= pkt_data', good access" ) |
786 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
787 | __naked void end_pkt_data_good_access_2(void) |
788 | { |
789 | asm volatile (" \ |
790 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
791 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
792 | r1 = r2; \ |
793 | r1 += 8; \ |
794 | if r3 <= r1 goto l0_%=; \ |
795 | r0 = *(u32*)(r1 - 5); \ |
796 | l0_%=: r0 = 0; \ |
797 | exit; \ |
798 | " : |
799 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
800 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
801 | : __clobber_all); |
802 | } |
803 | |
804 | SEC("xdp" ) |
805 | __description("XDP pkt read, pkt_end <= pkt_data', corner case -1, bad access" ) |
806 | __failure __msg("R1 offset is outside of the packet" ) |
807 | __flag(BPF_F_ANY_ALIGNMENT) |
808 | __naked void corner_case_1_bad_access_8(void) |
809 | { |
810 | asm volatile (" \ |
811 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
812 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
813 | r1 = r2; \ |
814 | r1 += 6; \ |
815 | if r3 <= r1 goto l0_%=; \ |
816 | r0 = *(u64*)(r1 - 6); \ |
817 | l0_%=: r0 = 0; \ |
818 | exit; \ |
819 | " : |
820 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
821 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
822 | : __clobber_all); |
823 | } |
824 | |
825 | SEC("xdp" ) |
826 | __description("XDP pkt read, pkt_end <= pkt_data', bad access 2" ) |
827 | __failure __msg("R1 offset is outside of the packet" ) |
828 | __flag(BPF_F_ANY_ALIGNMENT) |
829 | __naked void pkt_data_bad_access_2_4(void) |
830 | { |
831 | asm volatile (" \ |
832 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
833 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
834 | r1 = r2; \ |
835 | r1 += 8; \ |
836 | if r3 <= r1 goto l0_%=; \ |
837 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
838 | r0 = 0; \ |
839 | exit; \ |
840 | " : |
841 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
842 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
843 | : __clobber_all); |
844 | } |
845 | |
846 | SEC("xdp" ) |
847 | __description("XDP pkt read, pkt_end <= pkt_data', corner case, good access" ) |
848 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
849 | __naked void data_corner_case_good_access_4(void) |
850 | { |
851 | asm volatile (" \ |
852 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
853 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
854 | r1 = r2; \ |
855 | r1 += 7; \ |
856 | if r3 <= r1 goto l0_%=; \ |
857 | r0 = *(u64*)(r1 - 7); \ |
858 | l0_%=: r0 = 0; \ |
859 | exit; \ |
860 | " : |
861 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
862 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
863 | : __clobber_all); |
864 | } |
865 | |
866 | SEC("xdp" ) |
867 | __description("XDP pkt read, pkt_end <= pkt_data', corner case +1, good access" ) |
868 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
869 | __naked void corner_case_1_good_access_8(void) |
870 | { |
871 | asm volatile (" \ |
872 | r2 = *(u32*)(r1 + %[xdp_md_data]); \ |
873 | r3 = *(u32*)(r1 + %[xdp_md_data_end]); \ |
874 | r1 = r2; \ |
875 | r1 += 8; \ |
876 | if r3 <= r1 goto l0_%=; \ |
877 | r0 = *(u64*)(r1 - 8); \ |
878 | l0_%=: r0 = 0; \ |
879 | exit; \ |
880 | " : |
881 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
882 | __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)) |
883 | : __clobber_all); |
884 | } |
885 | |
886 | SEC("xdp" ) |
887 | __description("XDP pkt read, pkt_meta' > pkt_data, corner case, good access" ) |
888 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
889 | __naked void data_corner_case_good_access_5(void) |
890 | { |
891 | asm volatile (" \ |
892 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
893 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
894 | r1 = r2; \ |
895 | r1 += 8; \ |
896 | if r1 > r3 goto l0_%=; \ |
897 | r0 = *(u64*)(r1 - 8); \ |
898 | l0_%=: r0 = 0; \ |
899 | exit; \ |
900 | " : |
901 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
902 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
903 | : __clobber_all); |
904 | } |
905 | |
906 | SEC("xdp" ) |
907 | __description("XDP pkt read, pkt_meta' > pkt_data, bad access 1" ) |
908 | __failure __msg("R1 offset is outside of the packet" ) |
909 | __flag(BPF_F_ANY_ALIGNMENT) |
910 | __naked void pkt_data_bad_access_1_3(void) |
911 | { |
912 | asm volatile (" \ |
913 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
914 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
915 | r1 = r2; \ |
916 | r1 += 8; \ |
917 | if r1 > r3 goto l0_%=; \ |
918 | r0 = *(u64*)(r1 - 4); \ |
919 | l0_%=: r0 = 0; \ |
920 | exit; \ |
921 | " : |
922 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
923 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
924 | : __clobber_all); |
925 | } |
926 | |
927 | SEC("xdp" ) |
928 | __description("XDP pkt read, pkt_meta' > pkt_data, bad access 2" ) |
929 | __failure __msg("R1 offset is outside of the packet" ) |
930 | __flag(BPF_F_ANY_ALIGNMENT) |
931 | __naked void pkt_data_bad_access_2_5(void) |
932 | { |
933 | asm volatile (" \ |
934 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
935 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
936 | r1 = r2; \ |
937 | r1 += 8; \ |
938 | if r1 > r3 goto l0_%=; \ |
939 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
940 | r0 = 0; \ |
941 | exit; \ |
942 | " : |
943 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
944 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
945 | : __clobber_all); |
946 | } |
947 | |
948 | SEC("xdp" ) |
949 | __description("XDP pkt read, pkt_meta' > pkt_data, corner case +1, good access" ) |
950 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
951 | __naked void corner_case_1_good_access_9(void) |
952 | { |
953 | asm volatile (" \ |
954 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
955 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
956 | r1 = r2; \ |
957 | r1 += 9; \ |
958 | if r1 > r3 goto l0_%=; \ |
959 | r0 = *(u64*)(r1 - 9); \ |
960 | l0_%=: r0 = 0; \ |
961 | exit; \ |
962 | " : |
963 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
964 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
965 | : __clobber_all); |
966 | } |
967 | |
968 | SEC("xdp" ) |
969 | __description("XDP pkt read, pkt_meta' > pkt_data, corner case -1, bad access" ) |
970 | __failure __msg("R1 offset is outside of the packet" ) |
971 | __flag(BPF_F_ANY_ALIGNMENT) |
972 | __naked void corner_case_1_bad_access_9(void) |
973 | { |
974 | asm volatile (" \ |
975 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
976 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
977 | r1 = r2; \ |
978 | r1 += 7; \ |
979 | if r1 > r3 goto l0_%=; \ |
980 | r0 = *(u64*)(r1 - 7); \ |
981 | l0_%=: r0 = 0; \ |
982 | exit; \ |
983 | " : |
984 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
985 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
986 | : __clobber_all); |
987 | } |
988 | |
989 | SEC("xdp" ) |
990 | __description("XDP pkt read, pkt_data > pkt_meta', good access" ) |
991 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
992 | __naked void data_pkt_meta_good_access_1(void) |
993 | { |
994 | asm volatile (" \ |
995 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
996 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
997 | r1 = r2; \ |
998 | r1 += 8; \ |
999 | if r3 > r1 goto l0_%=; \ |
1000 | goto l1_%=; \ |
1001 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
1002 | l1_%=: r0 = 0; \ |
1003 | exit; \ |
1004 | " : |
1005 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1006 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1007 | : __clobber_all); |
1008 | } |
1009 | |
1010 | SEC("xdp" ) |
1011 | __description("XDP pkt read, pkt_data > pkt_meta', corner case -1, bad access" ) |
1012 | __failure __msg("R1 offset is outside of the packet" ) |
1013 | __flag(BPF_F_ANY_ALIGNMENT) |
1014 | __naked void corner_case_1_bad_access_10(void) |
1015 | { |
1016 | asm volatile (" \ |
1017 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1018 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1019 | r1 = r2; \ |
1020 | r1 += 6; \ |
1021 | if r3 > r1 goto l0_%=; \ |
1022 | goto l1_%=; \ |
1023 | l0_%=: r0 = *(u64*)(r1 - 6); \ |
1024 | l1_%=: r0 = 0; \ |
1025 | exit; \ |
1026 | " : |
1027 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1028 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1029 | : __clobber_all); |
1030 | } |
1031 | |
1032 | SEC("xdp" ) |
1033 | __description("XDP pkt read, pkt_data > pkt_meta', bad access 2" ) |
1034 | __failure __msg("R1 offset is outside of the packet" ) |
1035 | __flag(BPF_F_ANY_ALIGNMENT) |
1036 | __naked void pkt_meta_bad_access_2_1(void) |
1037 | { |
1038 | asm volatile (" \ |
1039 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1040 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1041 | r1 = r2; \ |
1042 | r1 += 8; \ |
1043 | if r3 > r1 goto l0_%=; \ |
1044 | r0 = *(u64*)(r1 - 8); \ |
1045 | l0_%=: r0 = 0; \ |
1046 | exit; \ |
1047 | " : |
1048 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1049 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1050 | : __clobber_all); |
1051 | } |
1052 | |
1053 | SEC("xdp" ) |
1054 | __description("XDP pkt read, pkt_data > pkt_meta', corner case, good access" ) |
1055 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1056 | __naked void meta_corner_case_good_access_1(void) |
1057 | { |
1058 | asm volatile (" \ |
1059 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1060 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1061 | r1 = r2; \ |
1062 | r1 += 7; \ |
1063 | if r3 > r1 goto l0_%=; \ |
1064 | goto l1_%=; \ |
1065 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
1066 | l1_%=: r0 = 0; \ |
1067 | exit; \ |
1068 | " : |
1069 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1070 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1071 | : __clobber_all); |
1072 | } |
1073 | |
1074 | SEC("xdp" ) |
1075 | __description("XDP pkt read, pkt_data > pkt_meta', corner case +1, good access" ) |
1076 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1077 | __naked void corner_case_1_good_access_10(void) |
1078 | { |
1079 | asm volatile (" \ |
1080 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1081 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1082 | r1 = r2; \ |
1083 | r1 += 8; \ |
1084 | if r3 > r1 goto l0_%=; \ |
1085 | goto l1_%=; \ |
1086 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
1087 | l1_%=: r0 = 0; \ |
1088 | exit; \ |
1089 | " : |
1090 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1091 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1092 | : __clobber_all); |
1093 | } |
1094 | |
1095 | SEC("xdp" ) |
1096 | __description("XDP pkt read, pkt_meta' < pkt_data, good access" ) |
1097 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1098 | __naked void meta_pkt_data_good_access_1(void) |
1099 | { |
1100 | asm volatile (" \ |
1101 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1102 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1103 | r1 = r2; \ |
1104 | r1 += 8; \ |
1105 | if r1 < r3 goto l0_%=; \ |
1106 | goto l1_%=; \ |
1107 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
1108 | l1_%=: r0 = 0; \ |
1109 | exit; \ |
1110 | " : |
1111 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1112 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1113 | : __clobber_all); |
1114 | } |
1115 | |
1116 | SEC("xdp" ) |
1117 | __description("XDP pkt read, pkt_meta' < pkt_data, corner case -1, bad access" ) |
1118 | __failure __msg("R1 offset is outside of the packet" ) |
1119 | __flag(BPF_F_ANY_ALIGNMENT) |
1120 | __naked void corner_case_1_bad_access_11(void) |
1121 | { |
1122 | asm volatile (" \ |
1123 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1124 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1125 | r1 = r2; \ |
1126 | r1 += 6; \ |
1127 | if r1 < r3 goto l0_%=; \ |
1128 | goto l1_%=; \ |
1129 | l0_%=: r0 = *(u64*)(r1 - 6); \ |
1130 | l1_%=: r0 = 0; \ |
1131 | exit; \ |
1132 | " : |
1133 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1134 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1135 | : __clobber_all); |
1136 | } |
1137 | |
1138 | SEC("xdp" ) |
1139 | __description("XDP pkt read, pkt_meta' < pkt_data, bad access 2" ) |
1140 | __failure __msg("R1 offset is outside of the packet" ) |
1141 | __flag(BPF_F_ANY_ALIGNMENT) |
1142 | __naked void pkt_data_bad_access_2_6(void) |
1143 | { |
1144 | asm volatile (" \ |
1145 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1146 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1147 | r1 = r2; \ |
1148 | r1 += 8; \ |
1149 | if r1 < r3 goto l0_%=; \ |
1150 | r0 = *(u64*)(r1 - 8); \ |
1151 | l0_%=: r0 = 0; \ |
1152 | exit; \ |
1153 | " : |
1154 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1155 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1156 | : __clobber_all); |
1157 | } |
1158 | |
1159 | SEC("xdp" ) |
1160 | __description("XDP pkt read, pkt_meta' < pkt_data, corner case, good access" ) |
1161 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1162 | __naked void data_corner_case_good_access_6(void) |
1163 | { |
1164 | asm volatile (" \ |
1165 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1166 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1167 | r1 = r2; \ |
1168 | r1 += 7; \ |
1169 | if r1 < r3 goto l0_%=; \ |
1170 | goto l1_%=; \ |
1171 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
1172 | l1_%=: r0 = 0; \ |
1173 | exit; \ |
1174 | " : |
1175 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1176 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1177 | : __clobber_all); |
1178 | } |
1179 | |
1180 | SEC("xdp" ) |
1181 | __description("XDP pkt read, pkt_meta' < pkt_data, corner case +1, good access" ) |
1182 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1183 | __naked void corner_case_1_good_access_11(void) |
1184 | { |
1185 | asm volatile (" \ |
1186 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1187 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1188 | r1 = r2; \ |
1189 | r1 += 8; \ |
1190 | if r1 < r3 goto l0_%=; \ |
1191 | goto l1_%=; \ |
1192 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
1193 | l1_%=: r0 = 0; \ |
1194 | exit; \ |
1195 | " : |
1196 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1197 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1198 | : __clobber_all); |
1199 | } |
1200 | |
1201 | SEC("xdp" ) |
1202 | __description("XDP pkt read, pkt_data < pkt_meta', corner case, good access" ) |
1203 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1204 | __naked void meta_corner_case_good_access_2(void) |
1205 | { |
1206 | asm volatile (" \ |
1207 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1208 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1209 | r1 = r2; \ |
1210 | r1 += 8; \ |
1211 | if r3 < r1 goto l0_%=; \ |
1212 | r0 = *(u64*)(r1 - 8); \ |
1213 | l0_%=: r0 = 0; \ |
1214 | exit; \ |
1215 | " : |
1216 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1217 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1218 | : __clobber_all); |
1219 | } |
1220 | |
1221 | SEC("xdp" ) |
1222 | __description("XDP pkt read, pkt_data < pkt_meta', bad access 1" ) |
1223 | __failure __msg("R1 offset is outside of the packet" ) |
1224 | __flag(BPF_F_ANY_ALIGNMENT) |
1225 | __naked void pkt_meta_bad_access_1_1(void) |
1226 | { |
1227 | asm volatile (" \ |
1228 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1229 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1230 | r1 = r2; \ |
1231 | r1 += 8; \ |
1232 | if r3 < r1 goto l0_%=; \ |
1233 | r0 = *(u64*)(r1 - 4); \ |
1234 | l0_%=: r0 = 0; \ |
1235 | exit; \ |
1236 | " : |
1237 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1238 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1239 | : __clobber_all); |
1240 | } |
1241 | |
1242 | SEC("xdp" ) |
1243 | __description("XDP pkt read, pkt_data < pkt_meta', bad access 2" ) |
1244 | __failure __msg("R1 offset is outside of the packet" ) |
1245 | __flag(BPF_F_ANY_ALIGNMENT) |
1246 | __naked void pkt_meta_bad_access_2_2(void) |
1247 | { |
1248 | asm volatile (" \ |
1249 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1250 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1251 | r1 = r2; \ |
1252 | r1 += 8; \ |
1253 | if r3 < r1 goto l0_%=; \ |
1254 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
1255 | r0 = 0; \ |
1256 | exit; \ |
1257 | " : |
1258 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1259 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1260 | : __clobber_all); |
1261 | } |
1262 | |
1263 | SEC("xdp" ) |
1264 | __description("XDP pkt read, pkt_data < pkt_meta', corner case +1, good access" ) |
1265 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1266 | __naked void corner_case_1_good_access_12(void) |
1267 | { |
1268 | asm volatile (" \ |
1269 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1270 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1271 | r1 = r2; \ |
1272 | r1 += 9; \ |
1273 | if r3 < r1 goto l0_%=; \ |
1274 | r0 = *(u64*)(r1 - 9); \ |
1275 | l0_%=: r0 = 0; \ |
1276 | exit; \ |
1277 | " : |
1278 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1279 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1280 | : __clobber_all); |
1281 | } |
1282 | |
1283 | SEC("xdp" ) |
1284 | __description("XDP pkt read, pkt_data < pkt_meta', corner case -1, bad access" ) |
1285 | __failure __msg("R1 offset is outside of the packet" ) |
1286 | __flag(BPF_F_ANY_ALIGNMENT) |
1287 | __naked void corner_case_1_bad_access_12(void) |
1288 | { |
1289 | asm volatile (" \ |
1290 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1291 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1292 | r1 = r2; \ |
1293 | r1 += 7; \ |
1294 | if r3 < r1 goto l0_%=; \ |
1295 | r0 = *(u64*)(r1 - 7); \ |
1296 | l0_%=: r0 = 0; \ |
1297 | exit; \ |
1298 | " : |
1299 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1300 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1301 | : __clobber_all); |
1302 | } |
1303 | |
1304 | SEC("xdp" ) |
1305 | __description("XDP pkt read, pkt_meta' >= pkt_data, good access" ) |
1306 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1307 | __naked void meta_pkt_data_good_access_2(void) |
1308 | { |
1309 | asm volatile (" \ |
1310 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1311 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1312 | r1 = r2; \ |
1313 | r1 += 8; \ |
1314 | if r1 >= r3 goto l0_%=; \ |
1315 | r0 = *(u32*)(r1 - 5); \ |
1316 | l0_%=: r0 = 0; \ |
1317 | exit; \ |
1318 | " : |
1319 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1320 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1321 | : __clobber_all); |
1322 | } |
1323 | |
1324 | SEC("xdp" ) |
1325 | __description("XDP pkt read, pkt_meta' >= pkt_data, corner case -1, bad access" ) |
1326 | __failure __msg("R1 offset is outside of the packet" ) |
1327 | __flag(BPF_F_ANY_ALIGNMENT) |
1328 | __naked void corner_case_1_bad_access_13(void) |
1329 | { |
1330 | asm volatile (" \ |
1331 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1332 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1333 | r1 = r2; \ |
1334 | r1 += 6; \ |
1335 | if r1 >= r3 goto l0_%=; \ |
1336 | r0 = *(u64*)(r1 - 6); \ |
1337 | l0_%=: r0 = 0; \ |
1338 | exit; \ |
1339 | " : |
1340 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1341 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1342 | : __clobber_all); |
1343 | } |
1344 | |
1345 | SEC("xdp" ) |
1346 | __description("XDP pkt read, pkt_meta' >= pkt_data, bad access 2" ) |
1347 | __failure __msg("R1 offset is outside of the packet" ) |
1348 | __flag(BPF_F_ANY_ALIGNMENT) |
1349 | __naked void pkt_data_bad_access_2_7(void) |
1350 | { |
1351 | asm volatile (" \ |
1352 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1353 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1354 | r1 = r2; \ |
1355 | r1 += 8; \ |
1356 | if r1 >= r3 goto l0_%=; \ |
1357 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
1358 | r0 = 0; \ |
1359 | exit; \ |
1360 | " : |
1361 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1362 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1363 | : __clobber_all); |
1364 | } |
1365 | |
1366 | SEC("xdp" ) |
1367 | __description("XDP pkt read, pkt_meta' >= pkt_data, corner case, good access" ) |
1368 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1369 | __naked void data_corner_case_good_access_7(void) |
1370 | { |
1371 | asm volatile (" \ |
1372 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1373 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1374 | r1 = r2; \ |
1375 | r1 += 7; \ |
1376 | if r1 >= r3 goto l0_%=; \ |
1377 | r0 = *(u64*)(r1 - 7); \ |
1378 | l0_%=: r0 = 0; \ |
1379 | exit; \ |
1380 | " : |
1381 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1382 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1383 | : __clobber_all); |
1384 | } |
1385 | |
1386 | SEC("xdp" ) |
1387 | __description("XDP pkt read, pkt_meta' >= pkt_data, corner case +1, good access" ) |
1388 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1389 | __naked void corner_case_1_good_access_13(void) |
1390 | { |
1391 | asm volatile (" \ |
1392 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1393 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1394 | r1 = r2; \ |
1395 | r1 += 8; \ |
1396 | if r1 >= r3 goto l0_%=; \ |
1397 | r0 = *(u64*)(r1 - 8); \ |
1398 | l0_%=: r0 = 0; \ |
1399 | exit; \ |
1400 | " : |
1401 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1402 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1403 | : __clobber_all); |
1404 | } |
1405 | |
1406 | SEC("xdp" ) |
1407 | __description("XDP pkt read, pkt_data >= pkt_meta', corner case, good access" ) |
1408 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1409 | __naked void meta_corner_case_good_access_3(void) |
1410 | { |
1411 | asm volatile (" \ |
1412 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1413 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1414 | r1 = r2; \ |
1415 | r1 += 8; \ |
1416 | if r3 >= r1 goto l0_%=; \ |
1417 | goto l1_%=; \ |
1418 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
1419 | l1_%=: r0 = 0; \ |
1420 | exit; \ |
1421 | " : |
1422 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1423 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1424 | : __clobber_all); |
1425 | } |
1426 | |
1427 | SEC("xdp" ) |
1428 | __description("XDP pkt read, pkt_data >= pkt_meta', bad access 1" ) |
1429 | __failure __msg("R1 offset is outside of the packet" ) |
1430 | __flag(BPF_F_ANY_ALIGNMENT) |
1431 | __naked void pkt_meta_bad_access_1_2(void) |
1432 | { |
1433 | asm volatile (" \ |
1434 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1435 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1436 | r1 = r2; \ |
1437 | r1 += 8; \ |
1438 | if r3 >= r1 goto l0_%=; \ |
1439 | goto l1_%=; \ |
1440 | l0_%=: r0 = *(u64*)(r1 - 4); \ |
1441 | l1_%=: r0 = 0; \ |
1442 | exit; \ |
1443 | " : |
1444 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1445 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1446 | : __clobber_all); |
1447 | } |
1448 | |
1449 | SEC("xdp" ) |
1450 | __description("XDP pkt read, pkt_data >= pkt_meta', bad access 2" ) |
1451 | __failure __msg("R1 offset is outside of the packet" ) |
1452 | __flag(BPF_F_ANY_ALIGNMENT) |
1453 | __naked void pkt_meta_bad_access_2_3(void) |
1454 | { |
1455 | asm volatile (" \ |
1456 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1457 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1458 | r1 = r2; \ |
1459 | r1 += 8; \ |
1460 | if r3 >= r1 goto l0_%=; \ |
1461 | r0 = *(u64*)(r1 - 8); \ |
1462 | l0_%=: r0 = 0; \ |
1463 | exit; \ |
1464 | " : |
1465 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1466 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1467 | : __clobber_all); |
1468 | } |
1469 | |
1470 | SEC("xdp" ) |
1471 | __description("XDP pkt read, pkt_data >= pkt_meta', corner case +1, good access" ) |
1472 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1473 | __naked void corner_case_1_good_access_14(void) |
1474 | { |
1475 | asm volatile (" \ |
1476 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1477 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1478 | r1 = r2; \ |
1479 | r1 += 9; \ |
1480 | if r3 >= r1 goto l0_%=; \ |
1481 | goto l1_%=; \ |
1482 | l0_%=: r0 = *(u64*)(r1 - 9); \ |
1483 | l1_%=: r0 = 0; \ |
1484 | exit; \ |
1485 | " : |
1486 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1487 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1488 | : __clobber_all); |
1489 | } |
1490 | |
1491 | SEC("xdp" ) |
1492 | __description("XDP pkt read, pkt_data >= pkt_meta', corner case -1, bad access" ) |
1493 | __failure __msg("R1 offset is outside of the packet" ) |
1494 | __flag(BPF_F_ANY_ALIGNMENT) |
1495 | __naked void corner_case_1_bad_access_14(void) |
1496 | { |
1497 | asm volatile (" \ |
1498 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1499 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1500 | r1 = r2; \ |
1501 | r1 += 7; \ |
1502 | if r3 >= r1 goto l0_%=; \ |
1503 | goto l1_%=; \ |
1504 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
1505 | l1_%=: r0 = 0; \ |
1506 | exit; \ |
1507 | " : |
1508 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1509 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1510 | : __clobber_all); |
1511 | } |
1512 | |
1513 | SEC("xdp" ) |
1514 | __description("XDP pkt read, pkt_meta' <= pkt_data, corner case, good access" ) |
1515 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1516 | __naked void data_corner_case_good_access_8(void) |
1517 | { |
1518 | asm volatile (" \ |
1519 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1520 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1521 | r1 = r2; \ |
1522 | r1 += 8; \ |
1523 | if r1 <= r3 goto l0_%=; \ |
1524 | goto l1_%=; \ |
1525 | l0_%=: r0 = *(u64*)(r1 - 8); \ |
1526 | l1_%=: r0 = 0; \ |
1527 | exit; \ |
1528 | " : |
1529 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1530 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1531 | : __clobber_all); |
1532 | } |
1533 | |
1534 | SEC("xdp" ) |
1535 | __description("XDP pkt read, pkt_meta' <= pkt_data, bad access 1" ) |
1536 | __failure __msg("R1 offset is outside of the packet" ) |
1537 | __flag(BPF_F_ANY_ALIGNMENT) |
1538 | __naked void pkt_data_bad_access_1_4(void) |
1539 | { |
1540 | asm volatile (" \ |
1541 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1542 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1543 | r1 = r2; \ |
1544 | r1 += 8; \ |
1545 | if r1 <= r3 goto l0_%=; \ |
1546 | goto l1_%=; \ |
1547 | l0_%=: r0 = *(u64*)(r1 - 4); \ |
1548 | l1_%=: r0 = 0; \ |
1549 | exit; \ |
1550 | " : |
1551 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1552 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1553 | : __clobber_all); |
1554 | } |
1555 | |
1556 | SEC("xdp" ) |
1557 | __description("XDP pkt read, pkt_meta' <= pkt_data, bad access 2" ) |
1558 | __failure __msg("R1 offset is outside of the packet" ) |
1559 | __flag(BPF_F_ANY_ALIGNMENT) |
1560 | __naked void pkt_data_bad_access_2_8(void) |
1561 | { |
1562 | asm volatile (" \ |
1563 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1564 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1565 | r1 = r2; \ |
1566 | r1 += 8; \ |
1567 | if r1 <= r3 goto l0_%=; \ |
1568 | r0 = *(u64*)(r1 - 8); \ |
1569 | l0_%=: r0 = 0; \ |
1570 | exit; \ |
1571 | " : |
1572 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1573 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1574 | : __clobber_all); |
1575 | } |
1576 | |
1577 | SEC("xdp" ) |
1578 | __description("XDP pkt read, pkt_meta' <= pkt_data, corner case +1, good access" ) |
1579 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1580 | __naked void corner_case_1_good_access_15(void) |
1581 | { |
1582 | asm volatile (" \ |
1583 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1584 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1585 | r1 = r2; \ |
1586 | r1 += 9; \ |
1587 | if r1 <= r3 goto l0_%=; \ |
1588 | goto l1_%=; \ |
1589 | l0_%=: r0 = *(u64*)(r1 - 9); \ |
1590 | l1_%=: r0 = 0; \ |
1591 | exit; \ |
1592 | " : |
1593 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1594 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1595 | : __clobber_all); |
1596 | } |
1597 | |
1598 | SEC("xdp" ) |
1599 | __description("XDP pkt read, pkt_meta' <= pkt_data, corner case -1, bad access" ) |
1600 | __failure __msg("R1 offset is outside of the packet" ) |
1601 | __flag(BPF_F_ANY_ALIGNMENT) |
1602 | __naked void corner_case_1_bad_access_15(void) |
1603 | { |
1604 | asm volatile (" \ |
1605 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1606 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1607 | r1 = r2; \ |
1608 | r1 += 7; \ |
1609 | if r1 <= r3 goto l0_%=; \ |
1610 | goto l1_%=; \ |
1611 | l0_%=: r0 = *(u64*)(r1 - 7); \ |
1612 | l1_%=: r0 = 0; \ |
1613 | exit; \ |
1614 | " : |
1615 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1616 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1617 | : __clobber_all); |
1618 | } |
1619 | |
1620 | SEC("xdp" ) |
1621 | __description("XDP pkt read, pkt_data <= pkt_meta', good access" ) |
1622 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1623 | __naked void data_pkt_meta_good_access_2(void) |
1624 | { |
1625 | asm volatile (" \ |
1626 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1627 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1628 | r1 = r2; \ |
1629 | r1 += 8; \ |
1630 | if r3 <= r1 goto l0_%=; \ |
1631 | r0 = *(u32*)(r1 - 5); \ |
1632 | l0_%=: r0 = 0; \ |
1633 | exit; \ |
1634 | " : |
1635 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1636 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1637 | : __clobber_all); |
1638 | } |
1639 | |
1640 | SEC("xdp" ) |
1641 | __description("XDP pkt read, pkt_data <= pkt_meta', corner case -1, bad access" ) |
1642 | __failure __msg("R1 offset is outside of the packet" ) |
1643 | __flag(BPF_F_ANY_ALIGNMENT) |
1644 | __naked void corner_case_1_bad_access_16(void) |
1645 | { |
1646 | asm volatile (" \ |
1647 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1648 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1649 | r1 = r2; \ |
1650 | r1 += 6; \ |
1651 | if r3 <= r1 goto l0_%=; \ |
1652 | r0 = *(u64*)(r1 - 6); \ |
1653 | l0_%=: r0 = 0; \ |
1654 | exit; \ |
1655 | " : |
1656 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1657 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1658 | : __clobber_all); |
1659 | } |
1660 | |
1661 | SEC("xdp" ) |
1662 | __description("XDP pkt read, pkt_data <= pkt_meta', bad access 2" ) |
1663 | __failure __msg("R1 offset is outside of the packet" ) |
1664 | __flag(BPF_F_ANY_ALIGNMENT) |
1665 | __naked void pkt_meta_bad_access_2_4(void) |
1666 | { |
1667 | asm volatile (" \ |
1668 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1669 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1670 | r1 = r2; \ |
1671 | r1 += 8; \ |
1672 | if r3 <= r1 goto l0_%=; \ |
1673 | l0_%=: r0 = *(u32*)(r1 - 5); \ |
1674 | r0 = 0; \ |
1675 | exit; \ |
1676 | " : |
1677 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1678 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1679 | : __clobber_all); |
1680 | } |
1681 | |
1682 | SEC("xdp" ) |
1683 | __description("XDP pkt read, pkt_data <= pkt_meta', corner case, good access" ) |
1684 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1685 | __naked void meta_corner_case_good_access_4(void) |
1686 | { |
1687 | asm volatile (" \ |
1688 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1689 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1690 | r1 = r2; \ |
1691 | r1 += 7; \ |
1692 | if r3 <= r1 goto l0_%=; \ |
1693 | r0 = *(u64*)(r1 - 7); \ |
1694 | l0_%=: r0 = 0; \ |
1695 | exit; \ |
1696 | " : |
1697 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1698 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1699 | : __clobber_all); |
1700 | } |
1701 | |
1702 | SEC("xdp" ) |
1703 | __description("XDP pkt read, pkt_data <= pkt_meta', corner case +1, good access" ) |
1704 | __success __retval(0) __flag(BPF_F_ANY_ALIGNMENT) |
1705 | __naked void corner_case_1_good_access_16(void) |
1706 | { |
1707 | asm volatile (" \ |
1708 | r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \ |
1709 | r3 = *(u32*)(r1 + %[xdp_md_data]); \ |
1710 | r1 = r2; \ |
1711 | r1 += 8; \ |
1712 | if r3 <= r1 goto l0_%=; \ |
1713 | r0 = *(u64*)(r1 - 8); \ |
1714 | l0_%=: r0 = 0; \ |
1715 | exit; \ |
1716 | " : |
1717 | : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)), |
1718 | __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta)) |
1719 | : __clobber_all); |
1720 | } |
1721 | |
1722 | char _license[] SEC("license" ) = "GPL" ; |
1723 | |