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