Loading...
Note: File does not exist in v5.4.
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
8SEC("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); \
21l0_%=: 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
29SEC("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); \
42l0_%=: 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
50SEC("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); \
62l0_%=: 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
70SEC("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); \
83l0_%=: 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
91SEC("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_%=; \
103l0_%=: 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
112SEC("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); \
124l0_%=: 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
132SEC("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); \
145l0_%=: 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
153SEC("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_%=; \
165l0_%=: r0 = *(u32*)(r1 - 5); \
166l1_%=: 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
174SEC("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_%=; \
187l0_%=: r0 = *(u64*)(r1 - 6); \
188l1_%=: 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
196SEC("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); \
209l0_%=: 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
217SEC("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_%=; \
229l0_%=: r0 = *(u64*)(r1 - 7); \
230l1_%=: 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
238SEC("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_%=; \
250l0_%=: r0 = *(u64*)(r1 - 8); \
251l1_%=: 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
259SEC("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_%=; \
271l0_%=: r0 = *(u32*)(r1 - 5); \
272l1_%=: 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
280SEC("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_%=; \
293l0_%=: r0 = *(u64*)(r1 - 6); \
294l1_%=: 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
302SEC("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); \
315l0_%=: 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
323SEC("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_%=; \
335l0_%=: r0 = *(u64*)(r1 - 7); \
336l1_%=: 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
344SEC("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_%=; \
356l0_%=: r0 = *(u64*)(r1 - 8); \
357l1_%=: 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
365SEC("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); \
377l0_%=: 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
385SEC("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); \
398l0_%=: 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
406SEC("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_%=; \
418l0_%=: 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
427SEC("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); \
439l0_%=: 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
447SEC("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); \
460l0_%=: 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
468SEC("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); \
480l0_%=: 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
488SEC("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); \
501l0_%=: 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
509SEC("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_%=; \
521l0_%=: 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
530SEC("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); \
542l0_%=: 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
550SEC("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); \
562l0_%=: 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
570SEC("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_%=; \
582l0_%=: r0 = *(u64*)(r1 - 8); \
583l1_%=: 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
591SEC("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_%=; \
604l0_%=: r0 = *(u64*)(r1 - 4); \
605l1_%=: 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
613SEC("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); \
626l0_%=: 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
634SEC("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_%=; \
646l0_%=: r0 = *(u64*)(r1 - 9); \
647l1_%=: 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
655SEC("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_%=; \
668l0_%=: r0 = *(u64*)(r1 - 7); \
669l1_%=: 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
677SEC("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_%=; \
689l0_%=: r0 = *(u64*)(r1 - 8); \
690l1_%=: 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
698SEC("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_%=; \
711l0_%=: r0 = *(u64*)(r1 - 4); \
712l1_%=: 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
720SEC("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); \
733l0_%=: 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
741SEC("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_%=; \
753l0_%=: r0 = *(u64*)(r1 - 9); \
754l1_%=: 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
762SEC("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_%=; \
775l0_%=: r0 = *(u64*)(r1 - 7); \
776l1_%=: 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
784SEC("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); \
796l0_%=: 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
804SEC("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); \
817l0_%=: 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
825SEC("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_%=; \
837l0_%=: 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
846SEC("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); \
858l0_%=: 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
866SEC("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); \
878l0_%=: 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
886SEC("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); \
898l0_%=: 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
906SEC("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); \
919l0_%=: 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
927SEC("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_%=; \
939l0_%=: 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
948SEC("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); \
960l0_%=: 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
968SEC("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); \
981l0_%=: 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
989SEC("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_%=; \
1001l0_%=: r0 = *(u32*)(r1 - 5); \
1002l1_%=: 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
1010SEC("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_%=; \
1023l0_%=: r0 = *(u64*)(r1 - 6); \
1024l1_%=: 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
1032SEC("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); \
1045l0_%=: 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
1053SEC("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_%=; \
1065l0_%=: r0 = *(u64*)(r1 - 7); \
1066l1_%=: 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
1074SEC("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_%=; \
1086l0_%=: r0 = *(u64*)(r1 - 8); \
1087l1_%=: 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
1095SEC("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_%=; \
1107l0_%=: r0 = *(u32*)(r1 - 5); \
1108l1_%=: 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
1116SEC("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_%=; \
1129l0_%=: r0 = *(u64*)(r1 - 6); \
1130l1_%=: 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
1138SEC("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); \
1151l0_%=: 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
1159SEC("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_%=; \
1171l0_%=: r0 = *(u64*)(r1 - 7); \
1172l1_%=: 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
1180SEC("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_%=; \
1192l0_%=: r0 = *(u64*)(r1 - 8); \
1193l1_%=: 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
1201SEC("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); \
1213l0_%=: 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
1221SEC("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); \
1234l0_%=: 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
1242SEC("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_%=; \
1254l0_%=: 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
1263SEC("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); \
1275l0_%=: 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
1283SEC("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); \
1296l0_%=: 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
1304SEC("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); \
1316l0_%=: 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
1324SEC("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); \
1337l0_%=: 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
1345SEC("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_%=; \
1357l0_%=: 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
1366SEC("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); \
1378l0_%=: 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
1386SEC("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); \
1398l0_%=: 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
1406SEC("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_%=; \
1418l0_%=: r0 = *(u64*)(r1 - 8); \
1419l1_%=: 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
1427SEC("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_%=; \
1440l0_%=: r0 = *(u64*)(r1 - 4); \
1441l1_%=: 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
1449SEC("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); \
1462l0_%=: 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
1470SEC("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_%=; \
1482l0_%=: r0 = *(u64*)(r1 - 9); \
1483l1_%=: 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
1491SEC("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_%=; \
1504l0_%=: r0 = *(u64*)(r1 - 7); \
1505l1_%=: 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
1513SEC("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_%=; \
1525l0_%=: r0 = *(u64*)(r1 - 8); \
1526l1_%=: 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
1534SEC("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_%=; \
1547l0_%=: r0 = *(u64*)(r1 - 4); \
1548l1_%=: 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
1556SEC("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); \
1569l0_%=: 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
1577SEC("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_%=; \
1589l0_%=: r0 = *(u64*)(r1 - 9); \
1590l1_%=: 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
1598SEC("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_%=; \
1611l0_%=: r0 = *(u64*)(r1 - 7); \
1612l1_%=: 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
1620SEC("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); \
1632l0_%=: 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
1640SEC("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); \
1653l0_%=: 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
1661SEC("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_%=; \
1673l0_%=: 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
1682SEC("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); \
1694l0_%=: 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
1702SEC("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); \
1714l0_%=: 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
1722char _license[] SEC("license") = "GPL";