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