tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1{
2 "jset32: BPF_K",
3 .insns = {
4 BPF_DIRECT_PKT_R2,
5 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
6 /* reg, high bits shouldn't be tested */
7 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1),
8 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
9 BPF_EXIT_INSN(),
10
11 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1),
12 BPF_EXIT_INSN(),
13 BPF_MOV64_IMM(BPF_REG_0, 2),
14 BPF_EXIT_INSN(),
15 },
16 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
17 .result = ACCEPT,
18 .runs = 3,
19 .retvals = {
20 { .retval = 0,
21 .data64 = { 1ULL << 63, }
22 },
23 { .retval = 2,
24 .data64 = { 1, }
25 },
26 { .retval = 2,
27 .data64 = { 1ULL << 63 | 1, }
28 },
29 },
30 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
31},
32{
33 "jset32: BPF_X",
34 .insns = {
35 BPF_DIRECT_PKT_R2,
36 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
37 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
38 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
39 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
40 BPF_EXIT_INSN(),
41
42 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
43 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
44 BPF_EXIT_INSN(),
45 BPF_MOV64_IMM(BPF_REG_0, 2),
46 BPF_EXIT_INSN(),
47 },
48 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
49 .result = ACCEPT,
50 .runs = 3,
51 .retvals = {
52 { .retval = 0,
53 .data64 = { 1ULL << 63, }
54 },
55 { .retval = 2,
56 .data64 = { 1, }
57 },
58 { .retval = 2,
59 .data64 = { 1ULL << 63 | 1, }
60 },
61 },
62 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
63},
64{
65 "jset32: ignores upper bits",
66 .insns = {
67 BPF_MOV64_IMM(BPF_REG_0, 0),
68 BPF_LD_IMM64(BPF_REG_7, 0x8000000000000000),
69 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
70 BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
71 BPF_EXIT_INSN(),
72 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
73 BPF_MOV64_IMM(BPF_REG_0, 2),
74 BPF_EXIT_INSN(),
75 },
76 .result = ACCEPT,
77 .retval = 2,
78},
79{
80 "jset32: min/max deduction",
81 .insns = {
82 BPF_RAND_UEXT_R7,
83 BPF_MOV64_IMM(BPF_REG_0, 0),
84 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1),
85 BPF_EXIT_INSN(),
86 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1),
87 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */
88 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
89 BPF_EXIT_INSN(),
90 },
91 .result = ACCEPT,
92},
93{
94 "jeq32: BPF_K",
95 .insns = {
96 BPF_DIRECT_PKT_R2,
97 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
98 BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1),
99 BPF_EXIT_INSN(),
100 BPF_MOV64_IMM(BPF_REG_0, 2),
101 BPF_EXIT_INSN(),
102 },
103 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
104 .result = ACCEPT,
105 .runs = 2,
106 .retvals = {
107 { .retval = 0,
108 .data64 = { -2, }
109 },
110 { .retval = 2,
111 .data64 = { -1, }
112 },
113 },
114 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
115},
116{
117 "jeq32: BPF_X",
118 .insns = {
119 BPF_DIRECT_PKT_R2,
120 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
121 BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001),
122 BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1),
123 BPF_EXIT_INSN(),
124 BPF_MOV64_IMM(BPF_REG_0, 2),
125 BPF_EXIT_INSN(),
126 },
127 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
128 .result = ACCEPT,
129 .runs = 3,
130 .retvals = {
131 { .retval = 0,
132 .data64 = { 2, }
133 },
134 { .retval = 2,
135 .data64 = { 1, }
136 },
137 { .retval = 2,
138 .data64 = { 1ULL << 63 | 1, }
139 },
140 },
141 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
142},
143{
144 "jeq32: min/max deduction",
145 .insns = {
146 BPF_RAND_UEXT_R7,
147 BPF_MOV64_IMM(BPF_REG_0, 0),
148 BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1),
149 BPF_EXIT_INSN(),
150 BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1),
151 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */
152 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
153 BPF_EXIT_INSN(),
154 },
155 .result = ACCEPT,
156},
157{
158 "jne32: BPF_K",
159 .insns = {
160 BPF_DIRECT_PKT_R2,
161 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
162 BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1),
163 BPF_EXIT_INSN(),
164 BPF_MOV64_IMM(BPF_REG_0, 2),
165 BPF_EXIT_INSN(),
166 },
167 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
168 .result = ACCEPT,
169 .runs = 2,
170 .retvals = {
171 { .retval = 2,
172 .data64 = { 1, }
173 },
174 { .retval = 0,
175 .data64 = { -1, }
176 },
177 },
178 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
179},
180{
181 "jne32: BPF_X",
182 .insns = {
183 BPF_DIRECT_PKT_R2,
184 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
185 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
186 BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1),
187 BPF_EXIT_INSN(),
188 BPF_MOV64_IMM(BPF_REG_0, 2),
189 BPF_EXIT_INSN(),
190 },
191 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
192 .result = ACCEPT,
193 .runs = 3,
194 .retvals = {
195 { .retval = 0,
196 .data64 = { 1, }
197 },
198 { .retval = 2,
199 .data64 = { 2, }
200 },
201 { .retval = 2,
202 .data64 = { 1ULL << 63 | 2, }
203 },
204 },
205 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
206},
207{
208 "jne32: min/max deduction",
209 .insns = {
210 BPF_RAND_UEXT_R7,
211 BPF_MOV64_IMM(BPF_REG_0, 0),
212 BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
213 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
214 BPF_EXIT_INSN(),
215 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */
216 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
217 BPF_EXIT_INSN(),
218 },
219 .result = ACCEPT,
220},
221{
222 "jge32: BPF_K",
223 .insns = {
224 BPF_DIRECT_PKT_R2,
225 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
226 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1),
227 BPF_EXIT_INSN(),
228 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
229 BPF_EXIT_INSN(),
230 },
231 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
232 .result = ACCEPT,
233 .runs = 3,
234 .retvals = {
235 { .retval = 2,
236 .data64 = { UINT_MAX, }
237 },
238 { .retval = 2,
239 .data64 = { UINT_MAX - 1, }
240 },
241 { .retval = 0,
242 .data64 = { 0, }
243 },
244 },
245 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
246},
247{
248 "jge32: BPF_X",
249 .insns = {
250 BPF_DIRECT_PKT_R2,
251 BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32),
252 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
253 BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
254 BPF_EXIT_INSN(),
255 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
256 BPF_EXIT_INSN(),
257 },
258 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
259 .result = ACCEPT,
260 .runs = 3,
261 .retvals = {
262 { .retval = 2,
263 .data64 = { UINT_MAX, }
264 },
265 { .retval = 0,
266 .data64 = { INT_MAX, }
267 },
268 { .retval = 0,
269 .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
270 },
271 },
272 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
273},
274{
275 "jge32: min/max deduction",
276 .insns = {
277 BPF_RAND_UEXT_R7,
278 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
279 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
280 BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
281 BPF_EXIT_INSN(),
282 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1),
283 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
284 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
285 BPF_EXIT_INSN(),
286 },
287 .result = ACCEPT,
288 .retval = 2,
289 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
290},
291{
292 "jgt32: BPF_K",
293 .insns = {
294 BPF_DIRECT_PKT_R2,
295 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
296 BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1),
297 BPF_EXIT_INSN(),
298 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
299 BPF_EXIT_INSN(),
300 },
301 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
302 .result = ACCEPT,
303 .runs = 3,
304 .retvals = {
305 { .retval = 2,
306 .data64 = { UINT_MAX, }
307 },
308 { .retval = 0,
309 .data64 = { UINT_MAX - 1, }
310 },
311 { .retval = 0,
312 .data64 = { 0, }
313 },
314 },
315 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
316},
317{
318 "jgt32: BPF_X",
319 .insns = {
320 BPF_DIRECT_PKT_R2,
321 BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32),
322 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
323 BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
324 BPF_EXIT_INSN(),
325 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
326 BPF_EXIT_INSN(),
327 },
328 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
329 .result = ACCEPT,
330 .runs = 3,
331 .retvals = {
332 { .retval = 2,
333 .data64 = { UINT_MAX, }
334 },
335 { .retval = 0,
336 .data64 = { UINT_MAX - 1, }
337 },
338 { .retval = 0,
339 .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
340 },
341 },
342 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
343},
344{
345 "jgt32: min/max deduction",
346 .insns = {
347 BPF_RAND_UEXT_R7,
348 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
349 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
350 BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
351 BPF_EXIT_INSN(),
352 BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1),
353 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
354 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
355 BPF_EXIT_INSN(),
356 },
357 .result = ACCEPT,
358 .retval = 2,
359 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
360},
361{
362 "jle32: BPF_K",
363 .insns = {
364 BPF_DIRECT_PKT_R2,
365 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
366 BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1),
367 BPF_EXIT_INSN(),
368 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
369 BPF_EXIT_INSN(),
370 },
371 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
372 .result = ACCEPT,
373 .runs = 3,
374 .retvals = {
375 { .retval = 2,
376 .data64 = { INT_MAX - 1, }
377 },
378 { .retval = 0,
379 .data64 = { UINT_MAX, }
380 },
381 { .retval = 2,
382 .data64 = { INT_MAX, }
383 },
384 },
385 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
386},
387{
388 "jle32: BPF_X",
389 .insns = {
390 BPF_DIRECT_PKT_R2,
391 BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32),
392 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
393 BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
394 BPF_EXIT_INSN(),
395 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
396 BPF_EXIT_INSN(),
397 },
398 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
399 .result = ACCEPT,
400 .runs = 3,
401 .retvals = {
402 { .retval = 0,
403 .data64 = { INT_MAX | 1ULL << 32, }
404 },
405 { .retval = 2,
406 .data64 = { INT_MAX - 2, }
407 },
408 { .retval = 0,
409 .data64 = { UINT_MAX, }
410 },
411 },
412 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
413},
414{
415 "jle32: min/max deduction",
416 .insns = {
417 BPF_RAND_UEXT_R7,
418 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
419 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
420 BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
421 BPF_EXIT_INSN(),
422 BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1),
423 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
424 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
425 BPF_EXIT_INSN(),
426 },
427 .result = ACCEPT,
428 .retval = 2,
429 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
430},
431{
432 "jlt32: BPF_K",
433 .insns = {
434 BPF_DIRECT_PKT_R2,
435 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
436 BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1),
437 BPF_EXIT_INSN(),
438 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
439 BPF_EXIT_INSN(),
440 },
441 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
442 .result = ACCEPT,
443 .runs = 3,
444 .retvals = {
445 { .retval = 0,
446 .data64 = { INT_MAX, }
447 },
448 { .retval = 0,
449 .data64 = { UINT_MAX, }
450 },
451 { .retval = 2,
452 .data64 = { INT_MAX - 1, }
453 },
454 },
455 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
456},
457{
458 "jlt32: BPF_X",
459 .insns = {
460 BPF_DIRECT_PKT_R2,
461 BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32),
462 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
463 BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
464 BPF_EXIT_INSN(),
465 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
466 BPF_EXIT_INSN(),
467 },
468 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
469 .result = ACCEPT,
470 .runs = 3,
471 .retvals = {
472 { .retval = 0,
473 .data64 = { INT_MAX | 1ULL << 32, }
474 },
475 { .retval = 0,
476 .data64 = { UINT_MAX, }
477 },
478 { .retval = 2,
479 .data64 = { (INT_MAX - 1) | 3ULL << 32, }
480 },
481 },
482 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
483},
484{
485 "jlt32: min/max deduction",
486 .insns = {
487 BPF_RAND_UEXT_R7,
488 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
489 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
490 BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
491 BPF_EXIT_INSN(),
492 BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1),
493 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
494 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
495 BPF_EXIT_INSN(),
496 },
497 .result = ACCEPT,
498 .retval = 2,
499 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
500},
501{
502 "jsge32: BPF_K",
503 .insns = {
504 BPF_DIRECT_PKT_R2,
505 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
506 BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1),
507 BPF_EXIT_INSN(),
508 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
509 BPF_EXIT_INSN(),
510 },
511 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
512 .result = ACCEPT,
513 .runs = 3,
514 .retvals = {
515 { .retval = 2,
516 .data64 = { 0, }
517 },
518 { .retval = 2,
519 .data64 = { -1, }
520 },
521 { .retval = 0,
522 .data64 = { -2, }
523 },
524 },
525 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
526},
527{
528 "jsge32: BPF_X",
529 .insns = {
530 BPF_DIRECT_PKT_R2,
531 BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32),
532 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
533 BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
534 BPF_EXIT_INSN(),
535 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
536 BPF_EXIT_INSN(),
537 },
538 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
539 .result = ACCEPT,
540 .runs = 3,
541 .retvals = {
542 { .retval = 2,
543 .data64 = { -1, }
544 },
545 { .retval = 2,
546 .data64 = { 0x7fffffff | 1ULL << 32, }
547 },
548 { .retval = 0,
549 .data64 = { -2, }
550 },
551 },
552 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
553},
554{
555 "jsge32: min/max deduction",
556 .insns = {
557 BPF_RAND_UEXT_R7,
558 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
559 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
560 BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
561 BPF_EXIT_INSN(),
562 BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1),
563 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
564 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
565 BPF_EXIT_INSN(),
566 },
567 .result = ACCEPT,
568 .retval = 2,
569 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
570},
571{
572 "jsgt32: BPF_K",
573 .insns = {
574 BPF_DIRECT_PKT_R2,
575 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
576 BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1),
577 BPF_EXIT_INSN(),
578 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
579 BPF_EXIT_INSN(),
580 },
581 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
582 .result = ACCEPT,
583 .runs = 3,
584 .retvals = {
585 { .retval = 0,
586 .data64 = { (__u32)-2, }
587 },
588 { .retval = 0,
589 .data64 = { -1, }
590 },
591 { .retval = 2,
592 .data64 = { 1, }
593 },
594 },
595 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
596},
597{
598 "jsgt32: BPF_X",
599 .insns = {
600 BPF_DIRECT_PKT_R2,
601 BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
602 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
603 BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
604 BPF_EXIT_INSN(),
605 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
606 BPF_EXIT_INSN(),
607 },
608 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
609 .result = ACCEPT,
610 .runs = 3,
611 .retvals = {
612 { .retval = 0,
613 .data64 = { 0x7ffffffe, }
614 },
615 { .retval = 0,
616 .data64 = { 0x1ffffffffULL, }
617 },
618 { .retval = 2,
619 .data64 = { 0x7fffffff, }
620 },
621 },
622 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
623},
624{
625 "jsgt32: min/max deduction",
626 .insns = {
627 BPF_RAND_SEXT_R7,
628 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
629 BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32),
630 BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
631 BPF_EXIT_INSN(),
632 BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1),
633 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
634 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
635 BPF_EXIT_INSN(),
636 },
637 .result = ACCEPT,
638 .retval = 2,
639 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
640},
641{
642 "jsle32: BPF_K",
643 .insns = {
644 BPF_DIRECT_PKT_R2,
645 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
646 BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1),
647 BPF_EXIT_INSN(),
648 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
649 BPF_EXIT_INSN(),
650 },
651 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
652 .result = ACCEPT,
653 .runs = 3,
654 .retvals = {
655 { .retval = 2,
656 .data64 = { (__u32)-2, }
657 },
658 { .retval = 2,
659 .data64 = { -1, }
660 },
661 { .retval = 0,
662 .data64 = { 1, }
663 },
664 },
665 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
666},
667{
668 "jsle32: BPF_X",
669 .insns = {
670 BPF_DIRECT_PKT_R2,
671 BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
672 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
673 BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
674 BPF_EXIT_INSN(),
675 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
676 BPF_EXIT_INSN(),
677 },
678 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
679 .result = ACCEPT,
680 .runs = 3,
681 .retvals = {
682 { .retval = 2,
683 .data64 = { 0x7ffffffe, }
684 },
685 { .retval = 2,
686 .data64 = { (__u32)-1, }
687 },
688 { .retval = 0,
689 .data64 = { 0x7fffffff | 2ULL << 32, }
690 },
691 },
692 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
693},
694{
695 "jsle32: min/max deduction",
696 .insns = {
697 BPF_RAND_UEXT_R7,
698 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
699 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
700 BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
701 BPF_EXIT_INSN(),
702 BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1),
703 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
704 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
705 BPF_EXIT_INSN(),
706 },
707 .result = ACCEPT,
708 .retval = 2,
709 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
710},
711{
712 "jslt32: BPF_K",
713 .insns = {
714 BPF_DIRECT_PKT_R2,
715 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
716 BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
717 BPF_EXIT_INSN(),
718 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
719 BPF_EXIT_INSN(),
720 },
721 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
722 .result = ACCEPT,
723 .runs = 3,
724 .retvals = {
725 { .retval = 2,
726 .data64 = { (__u32)-2, }
727 },
728 { .retval = 0,
729 .data64 = { -1, }
730 },
731 { .retval = 0,
732 .data64 = { 1, }
733 },
734 },
735 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
736},
737{
738 "jslt32: BPF_X",
739 .insns = {
740 BPF_DIRECT_PKT_R2,
741 BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32),
742 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
743 BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
744 BPF_EXIT_INSN(),
745 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
746 BPF_EXIT_INSN(),
747 },
748 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
749 .result = ACCEPT,
750 .runs = 3,
751 .retvals = {
752 { .retval = 2,
753 .data64 = { 0x7ffffffe, }
754 },
755 { .retval = 2,
756 .data64 = { 0xffffffff, }
757 },
758 { .retval = 0,
759 .data64 = { 0x7fffffff | 2ULL << 32, }
760 },
761 },
762 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
763},
764{
765 "jslt32: min/max deduction",
766 .insns = {
767 BPF_RAND_SEXT_R7,
768 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
769 BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32),
770 BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
771 BPF_EXIT_INSN(),
772 BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
773 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */
774 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
775 BPF_EXIT_INSN(),
776 },
777 .result = ACCEPT,
778 .retval = 2,
779 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
780},
781{
782 "jgt32: range bound deduction, reg op imm",
783 .insns = {
784 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
785 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
786 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
787 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
788 BPF_LD_MAP_FD(BPF_REG_1, 0),
789 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
790 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
791 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
792 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
793 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
794 BPF_JMP32_IMM(BPF_JGT, BPF_REG_0, 1, 5),
795 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
796 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
797 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
798 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
799 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
800 BPF_MOV32_IMM(BPF_REG_0, 0),
801 BPF_EXIT_INSN(),
802 },
803 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
804 .fixup_map_hash_48b = { 4 },
805 .result = ACCEPT,
806 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
807},
808{
809 "jgt32: range bound deduction, reg1 op reg2, reg1 unknown",
810 .insns = {
811 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
812 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
813 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
814 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
815 BPF_LD_MAP_FD(BPF_REG_1, 0),
816 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
817 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
818 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
819 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
820 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
821 BPF_MOV32_IMM(BPF_REG_2, 1),
822 BPF_JMP32_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 5),
823 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
824 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
825 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
826 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
827 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
828 BPF_MOV32_IMM(BPF_REG_0, 0),
829 BPF_EXIT_INSN(),
830 },
831 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
832 .fixup_map_hash_48b = { 4 },
833 .result = ACCEPT,
834 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
835},
836{
837 "jle32: range bound deduction, reg1 op reg2, reg2 unknown",
838 .insns = {
839 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
840 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
841 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
842 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
843 BPF_LD_MAP_FD(BPF_REG_1, 0),
844 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
845 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
846 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
847 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
848 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
849 BPF_MOV32_IMM(BPF_REG_2, 1),
850 BPF_JMP32_REG(BPF_JLE, BPF_REG_2, BPF_REG_0, 5),
851 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
852 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
853 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
854 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
855 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
856 BPF_MOV32_IMM(BPF_REG_0, 0),
857 BPF_EXIT_INSN(),
858 },
859 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
860 .fixup_map_hash_48b = { 4 },
861 .result = ACCEPT,
862 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
863},
864{
865 "jeq32/jne32: bounds checking",
866 .insns = {
867 BPF_MOV64_IMM(BPF_REG_6, 563),
868 BPF_MOV64_IMM(BPF_REG_2, 0),
869 BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
870 BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
871 BPF_ALU32_REG(BPF_OR, BPF_REG_2, BPF_REG_6),
872 BPF_JMP32_IMM(BPF_JNE, BPF_REG_2, 8, 5),
873 BPF_JMP_IMM(BPF_JSGE, BPF_REG_2, 500, 2),
874 BPF_MOV64_IMM(BPF_REG_0, 2),
875 BPF_EXIT_INSN(),
876 BPF_MOV64_REG(BPF_REG_0, BPF_REG_4),
877 BPF_EXIT_INSN(),
878 BPF_MOV64_IMM(BPF_REG_0, 1),
879 BPF_EXIT_INSN(),
880 },
881 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
882 .result = ACCEPT,
883 .retval = 1,
884},