2 * Testsuite for BPF interpreter and BPF JIT compiler
4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/filter.h>
21 #include <linux/bpf.h>
22 #include <linux/skbuff.h>
23 #include <linux/netdevice.h>
24 #include <linux/if_vlan.h>
25 #include <linux/random.h>
26 #include <linux/highmem.h>
27 #include <linux/sched.h>
29 /* General test specific settings */
30 #define MAX_SUBTESTS 3
31 #define MAX_TESTRUNS 1000
34 #define MAX_K 0xffffFFFF
36 /* Few constants used to init test 'skb' */
38 #define SKB_MARK 0x1234aaaa
39 #define SKB_HASH 0x1234aaab
40 #define SKB_QUEUE_MAP 123
41 #define SKB_VLAN_TCI 0xffff
42 #define SKB_DEV_IFINDEX 577
43 #define SKB_DEV_TYPE 588
45 /* Redefine REGs to make tests less verbose */
56 #define R10 BPF_REG_10
58 /* Flags that can be passed to test cases */
59 #define FLAG_NO_DATA BIT(0)
60 #define FLAG_EXPECTED_FAIL BIT(1)
61 #define FLAG_SKB_FRAG BIT(2)
64 CLASSIC
= BIT(6), /* Old BPF instructions only. */
65 INTERNAL
= BIT(7), /* Extended instruction set. */
68 #define TEST_TYPE_MASK (CLASSIC | INTERNAL)
73 struct sock_filter insns
[MAX_INSNS
];
74 struct bpf_insn insns_int
[MAX_INSNS
];
86 int (*fill_helper
)(struct bpf_test
*self
);
87 int expected_errcode
; /* used when FLAG_EXPECTED_FAIL is set in the aux */
88 __u8 frag_data
[MAX_DATA
];
89 int stack_depth
; /* for eBPF only, since tests don't call verifier */
92 /* Large test cases need separate allocation and fill handler. */
94 static int bpf_fill_maxinsns1(struct bpf_test
*self
)
96 unsigned int len
= BPF_MAXINSNS
;
97 struct sock_filter
*insn
;
101 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
105 for (i
= 0; i
< len
; i
++, k
--)
106 insn
[i
] = __BPF_STMT(BPF_RET
| BPF_K
, k
);
108 self
->u
.ptr
.insns
= insn
;
109 self
->u
.ptr
.len
= len
;
114 static int bpf_fill_maxinsns2(struct bpf_test
*self
)
116 unsigned int len
= BPF_MAXINSNS
;
117 struct sock_filter
*insn
;
120 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
124 for (i
= 0; i
< len
; i
++)
125 insn
[i
] = __BPF_STMT(BPF_RET
| BPF_K
, 0xfefefefe);
127 self
->u
.ptr
.insns
= insn
;
128 self
->u
.ptr
.len
= len
;
133 static int bpf_fill_maxinsns3(struct bpf_test
*self
)
135 unsigned int len
= BPF_MAXINSNS
;
136 struct sock_filter
*insn
;
137 struct rnd_state rnd
;
140 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
144 prandom_seed_state(&rnd
, 3141592653589793238ULL);
146 for (i
= 0; i
< len
- 1; i
++) {
147 __u32 k
= prandom_u32_state(&rnd
);
149 insn
[i
] = __BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, k
);
152 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_A
, 0);
154 self
->u
.ptr
.insns
= insn
;
155 self
->u
.ptr
.len
= len
;
160 static int bpf_fill_maxinsns4(struct bpf_test
*self
)
162 unsigned int len
= BPF_MAXINSNS
+ 1;
163 struct sock_filter
*insn
;
166 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
170 for (i
= 0; i
< len
; i
++)
171 insn
[i
] = __BPF_STMT(BPF_RET
| BPF_K
, 0xfefefefe);
173 self
->u
.ptr
.insns
= insn
;
174 self
->u
.ptr
.len
= len
;
179 static int bpf_fill_maxinsns5(struct bpf_test
*self
)
181 unsigned int len
= BPF_MAXINSNS
;
182 struct sock_filter
*insn
;
185 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
189 insn
[0] = __BPF_JUMP(BPF_JMP
| BPF_JA
, len
- 2, 0, 0);
191 for (i
= 1; i
< len
- 1; i
++)
192 insn
[i
] = __BPF_STMT(BPF_RET
| BPF_K
, 0xfefefefe);
194 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_K
, 0xabababab);
196 self
->u
.ptr
.insns
= insn
;
197 self
->u
.ptr
.len
= len
;
202 static int bpf_fill_maxinsns6(struct bpf_test
*self
)
204 unsigned int len
= BPF_MAXINSNS
;
205 struct sock_filter
*insn
;
208 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
212 for (i
= 0; i
< len
- 1; i
++)
213 insn
[i
] = __BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
, SKF_AD_OFF
+
214 SKF_AD_VLAN_TAG_PRESENT
);
216 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_A
, 0);
218 self
->u
.ptr
.insns
= insn
;
219 self
->u
.ptr
.len
= len
;
224 static int bpf_fill_maxinsns7(struct bpf_test
*self
)
226 unsigned int len
= BPF_MAXINSNS
;
227 struct sock_filter
*insn
;
230 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
234 for (i
= 0; i
< len
- 4; i
++)
235 insn
[i
] = __BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
, SKF_AD_OFF
+
238 insn
[len
- 4] = __BPF_STMT(BPF_MISC
| BPF_TAX
, 0);
239 insn
[len
- 3] = __BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
, SKF_AD_OFF
+
241 insn
[len
- 2] = __BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_X
, 0);
242 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_A
, 0);
244 self
->u
.ptr
.insns
= insn
;
245 self
->u
.ptr
.len
= len
;
250 static int bpf_fill_maxinsns8(struct bpf_test
*self
)
252 unsigned int len
= BPF_MAXINSNS
;
253 struct sock_filter
*insn
;
254 int i
, jmp_off
= len
- 3;
256 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
260 insn
[0] = __BPF_STMT(BPF_LD
| BPF_IMM
, 0xffffffff);
262 for (i
= 1; i
< len
- 1; i
++)
263 insn
[i
] = __BPF_JUMP(BPF_JMP
| BPF_JGT
, 0xffffffff, jmp_off
--, 0);
265 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_A
, 0);
267 self
->u
.ptr
.insns
= insn
;
268 self
->u
.ptr
.len
= len
;
273 static int bpf_fill_maxinsns9(struct bpf_test
*self
)
275 unsigned int len
= BPF_MAXINSNS
;
276 struct bpf_insn
*insn
;
279 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
283 insn
[0] = BPF_JMP_IMM(BPF_JA
, 0, 0, len
- 2);
284 insn
[1] = BPF_ALU32_IMM(BPF_MOV
, R0
, 0xcbababab);
285 insn
[2] = BPF_EXIT_INSN();
287 for (i
= 3; i
< len
- 2; i
++)
288 insn
[i
] = BPF_ALU32_IMM(BPF_MOV
, R0
, 0xfefefefe);
290 insn
[len
- 2] = BPF_EXIT_INSN();
291 insn
[len
- 1] = BPF_JMP_IMM(BPF_JA
, 0, 0, -(len
- 1));
293 self
->u
.ptr
.insns
= insn
;
294 self
->u
.ptr
.len
= len
;
299 static int bpf_fill_maxinsns10(struct bpf_test
*self
)
301 unsigned int len
= BPF_MAXINSNS
, hlen
= len
- 2;
302 struct bpf_insn
*insn
;
305 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
309 for (i
= 0; i
< hlen
/ 2; i
++)
310 insn
[i
] = BPF_JMP_IMM(BPF_JA
, 0, 0, hlen
- 2 - 2 * i
);
311 for (i
= hlen
- 1; i
> hlen
/ 2; i
--)
312 insn
[i
] = BPF_JMP_IMM(BPF_JA
, 0, 0, hlen
- 1 - 2 * i
);
314 insn
[hlen
/ 2] = BPF_JMP_IMM(BPF_JA
, 0, 0, hlen
/ 2 - 1);
315 insn
[hlen
] = BPF_ALU32_IMM(BPF_MOV
, R0
, 0xabababac);
316 insn
[hlen
+ 1] = BPF_EXIT_INSN();
318 self
->u
.ptr
.insns
= insn
;
319 self
->u
.ptr
.len
= len
;
324 static int __bpf_fill_ja(struct bpf_test
*self
, unsigned int len
,
327 struct sock_filter
*insn
;
331 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
335 rlen
= (len
% plen
) - 1;
337 for (i
= 0; i
+ plen
< len
; i
+= plen
)
338 for (j
= 0; j
< plen
; j
++)
339 insn
[i
+ j
] = __BPF_JUMP(BPF_JMP
| BPF_JA
,
341 for (j
= 0; j
< rlen
; j
++)
342 insn
[i
+ j
] = __BPF_JUMP(BPF_JMP
| BPF_JA
, rlen
- 1 - j
,
345 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_K
, 0xababcbac);
347 self
->u
.ptr
.insns
= insn
;
348 self
->u
.ptr
.len
= len
;
353 static int bpf_fill_maxinsns11(struct bpf_test
*self
)
355 /* Hits 70 passes on x86_64, so cannot get JITed there. */
356 return __bpf_fill_ja(self
, BPF_MAXINSNS
, 68);
359 static int bpf_fill_ja(struct bpf_test
*self
)
361 /* Hits exactly 11 passes on x86_64 JIT. */
362 return __bpf_fill_ja(self
, 12, 9);
365 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test
*self
)
367 unsigned int len
= BPF_MAXINSNS
;
368 struct sock_filter
*insn
;
371 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
375 for (i
= 0; i
< len
- 1; i
+= 2) {
376 insn
[i
] = __BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 0);
377 insn
[i
+ 1] = __BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
378 SKF_AD_OFF
+ SKF_AD_CPU
);
381 insn
[len
- 1] = __BPF_STMT(BPF_RET
| BPF_K
, 0xbee);
383 self
->u
.ptr
.insns
= insn
;
384 self
->u
.ptr
.len
= len
;
389 static int __bpf_fill_stxdw(struct bpf_test
*self
, int size
)
391 unsigned int len
= BPF_MAXINSNS
;
392 struct bpf_insn
*insn
;
395 insn
= kmalloc_array(len
, sizeof(*insn
), GFP_KERNEL
);
399 insn
[0] = BPF_ALU32_IMM(BPF_MOV
, R0
, 1);
400 insn
[1] = BPF_ST_MEM(size
, R10
, -40, 42);
402 for (i
= 2; i
< len
- 2; i
++)
403 insn
[i
] = BPF_STX_XADD(size
, R10
, R0
, -40);
405 insn
[len
- 2] = BPF_LDX_MEM(size
, R0
, R10
, -40);
406 insn
[len
- 1] = BPF_EXIT_INSN();
408 self
->u
.ptr
.insns
= insn
;
409 self
->u
.ptr
.len
= len
;
410 self
->stack_depth
= 40;
415 static int bpf_fill_stxw(struct bpf_test
*self
)
417 return __bpf_fill_stxdw(self
, BPF_W
);
420 static int bpf_fill_stxdw(struct bpf_test
*self
)
422 return __bpf_fill_stxdw(self
, BPF_DW
);
425 static struct bpf_test tests
[] = {
429 BPF_STMT(BPF_LD
| BPF_IMM
, 1),
430 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
431 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
432 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
433 BPF_STMT(BPF_ALU
| BPF_NEG
, 0), /* A == -3 */
434 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
435 BPF_STMT(BPF_LD
| BPF_LEN
, 0),
436 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
437 BPF_STMT(BPF_MISC
| BPF_TAX
, 0), /* X == len - 3 */
438 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 1),
439 BPF_STMT(BPF_RET
| BPF_A
, 0)
442 { 10, 20, 30, 40, 50 },
443 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
448 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
449 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
450 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
451 BPF_STMT(BPF_RET
| BPF_A
, 0) /* A == len * 2 */
454 { 10, 20, 30, 40, 50 },
455 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
460 BPF_STMT(BPF_LD
| BPF_IMM
, 1),
461 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 2),
462 BPF_STMT(BPF_LDX
| BPF_IMM
, 3),
463 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_X
, 0),
464 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 0xffffffff),
465 BPF_STMT(BPF_ALU
| BPF_MUL
| BPF_K
, 3),
466 BPF_STMT(BPF_RET
| BPF_A
, 0)
468 CLASSIC
| FLAG_NO_DATA
,
470 { { 0, 0xfffffffd } }
475 BPF_STMT(BPF_LD
| BPF_IMM
, 8),
476 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_K
, 2),
477 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
478 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffffffff),
479 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_X
, 0),
480 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
481 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffffffff),
482 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_K
, 0x70000000),
483 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
484 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffffffff),
485 BPF_STMT(BPF_ALU
| BPF_MOD
| BPF_X
, 0),
486 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
487 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffffffff),
488 BPF_STMT(BPF_ALU
| BPF_MOD
| BPF_K
, 0x70000000),
489 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
490 BPF_STMT(BPF_RET
| BPF_A
, 0)
492 CLASSIC
| FLAG_NO_DATA
,
494 { { 0, 0x20000000 } }
499 BPF_STMT(BPF_LD
| BPF_IMM
, 0xff),
500 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0xf0),
501 BPF_STMT(BPF_ALU
| BPF_LSH
| BPF_K
, 27),
502 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
503 BPF_STMT(BPF_LD
| BPF_IMM
, 0xf),
504 BPF_STMT(BPF_ALU
| BPF_OR
| BPF_K
, 0xf0),
505 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
506 BPF_STMT(BPF_RET
| BPF_A
, 0)
508 CLASSIC
| FLAG_NO_DATA
,
510 { { 0, 0x800000ff }, { 1, 0x800000ff } },
515 BPF_STMT(BPF_LD
| BPF_IMM
, 0), /* ld #0 */
516 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0, 1, 0),
517 BPF_STMT(BPF_RET
| BPF_K
, 0),
518 BPF_STMT(BPF_RET
| BPF_K
, 1),
527 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
528 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, MAX_K
),
529 BPF_STMT(BPF_RET
| BPF_K
, 1)
533 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
538 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
, 1000),
539 BPF_STMT(BPF_RET
| BPF_K
, 1)
543 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
548 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, SKF_LL_OFF
),
549 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
550 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, SKF_LL_OFF
+ 1),
551 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
552 BPF_STMT(BPF_RET
| BPF_A
, 0)
556 { { 1, 0 }, { 2, 3 } },
561 BPF_STMT(BPF_LD
| BPF_IMM
, SKF_LL_OFF
- 1),
562 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
563 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
564 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
565 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 0),
566 BPF_STMT(BPF_RET
| BPF_A
, 0)
570 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
575 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, SKF_NET_OFF
),
576 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
577 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, SKF_NET_OFF
+ 1),
578 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
579 BPF_STMT(BPF_RET
| BPF_A
, 0)
582 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
583 { { 15, 0 }, { 16, 3 } },
588 BPF_STMT(BPF_LD
| BPF_IMM
, SKF_NET_OFF
- 15),
589 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
590 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
591 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
592 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 0),
593 BPF_STMT(BPF_RET
| BPF_A
, 0)
596 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
597 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
602 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
603 SKF_AD_OFF
+ SKF_AD_PKTTYPE
),
604 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, SKB_TYPE
, 1, 0),
605 BPF_STMT(BPF_RET
| BPF_K
, 1),
606 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
607 SKF_AD_OFF
+ SKF_AD_PKTTYPE
),
608 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, SKB_TYPE
, 1, 0),
609 BPF_STMT(BPF_RET
| BPF_K
, 1),
610 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
611 SKF_AD_OFF
+ SKF_AD_PKTTYPE
),
612 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, SKB_TYPE
, 1, 0),
613 BPF_STMT(BPF_RET
| BPF_K
, 1),
614 BPF_STMT(BPF_RET
| BPF_A
, 0)
618 { { 1, 3 }, { 10, 3 } },
623 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
624 SKF_AD_OFF
+ SKF_AD_MARK
),
625 BPF_STMT(BPF_RET
| BPF_A
, 0)
629 { { 1, SKB_MARK
}, { 10, SKB_MARK
} },
634 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
635 SKF_AD_OFF
+ SKF_AD_RXHASH
),
636 BPF_STMT(BPF_RET
| BPF_A
, 0)
640 { { 1, SKB_HASH
}, { 10, SKB_HASH
} },
645 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
646 SKF_AD_OFF
+ SKF_AD_QUEUE
),
647 BPF_STMT(BPF_RET
| BPF_A
, 0)
651 { { 1, SKB_QUEUE_MAP
}, { 10, SKB_QUEUE_MAP
} },
656 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 1),
657 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 20, 1, 0),
658 BPF_STMT(BPF_RET
| BPF_K
, 0),
659 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
660 SKF_AD_OFF
+ SKF_AD_PROTOCOL
),
661 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
662 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
663 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 30, 1, 0),
664 BPF_STMT(BPF_RET
| BPF_K
, 0),
665 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
666 BPF_STMT(BPF_RET
| BPF_A
, 0)
670 { { 10, ETH_P_IP
}, { 100, ETH_P_IP
} },
675 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
676 SKF_AD_OFF
+ SKF_AD_VLAN_TAG
),
677 BPF_STMT(BPF_RET
| BPF_A
, 0)
682 { 1, SKB_VLAN_TCI
& ~VLAN_TAG_PRESENT
},
683 { 10, SKB_VLAN_TCI
& ~VLAN_TAG_PRESENT
}
687 "LD_VLAN_TAG_PRESENT",
689 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
690 SKF_AD_OFF
+ SKF_AD_VLAN_TAG_PRESENT
),
691 BPF_STMT(BPF_RET
| BPF_A
, 0)
696 { 1, !!(SKB_VLAN_TCI
& VLAN_TAG_PRESENT
) },
697 { 10, !!(SKB_VLAN_TCI
& VLAN_TAG_PRESENT
) }
703 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
704 SKF_AD_OFF
+ SKF_AD_IFINDEX
),
705 BPF_STMT(BPF_RET
| BPF_A
, 0)
709 { { 1, SKB_DEV_IFINDEX
}, { 10, SKB_DEV_IFINDEX
} },
714 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
715 SKF_AD_OFF
+ SKF_AD_HATYPE
),
716 BPF_STMT(BPF_RET
| BPF_A
, 0)
720 { { 1, SKB_DEV_TYPE
}, { 10, SKB_DEV_TYPE
} },
725 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
726 SKF_AD_OFF
+ SKF_AD_CPU
),
727 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
728 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
729 SKF_AD_OFF
+ SKF_AD_CPU
),
730 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_X
, 0),
731 BPF_STMT(BPF_RET
| BPF_A
, 0)
735 { { 1, 0 }, { 10, 0 } },
740 BPF_STMT(BPF_LDX
| BPF_IMM
, 2),
741 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
742 BPF_STMT(BPF_LDX
| BPF_IMM
, 3),
743 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
744 SKF_AD_OFF
+ SKF_AD_NLATTR
),
745 BPF_STMT(BPF_RET
| BPF_A
, 0)
749 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
751 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
753 { { 4, 0 }, { 20, 6 } },
758 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
759 BPF_STMT(BPF_LDX
| BPF_IMM
, 3),
760 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
761 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
762 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
763 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
764 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
765 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
766 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
767 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
768 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
769 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
770 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
771 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
772 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
773 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
774 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
775 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
776 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
777 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
778 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
779 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
780 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
781 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
782 SKF_AD_OFF
+ SKF_AD_NLATTR_NEST
),
783 BPF_STMT(BPF_RET
| BPF_A
, 0)
787 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
789 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
791 { { 4, 0 }, { 20, 10 } },
796 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
797 SKF_AD_OFF
+ SKF_AD_PAY_OFFSET
),
798 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
799 SKF_AD_OFF
+ SKF_AD_PAY_OFFSET
),
800 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
801 SKF_AD_OFF
+ SKF_AD_PAY_OFFSET
),
802 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
803 SKF_AD_OFF
+ SKF_AD_PAY_OFFSET
),
804 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
805 SKF_AD_OFF
+ SKF_AD_PAY_OFFSET
),
806 BPF_STMT(BPF_RET
| BPF_A
, 0)
809 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
810 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
811 * id 9737, seq 1, length 64
813 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
814 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
816 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
817 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
818 { { 30, 0 }, { 100, 42 } },
823 BPF_STMT(BPF_LD
| BPF_IMM
, 10),
824 BPF_STMT(BPF_LDX
| BPF_IMM
, 300),
825 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
826 SKF_AD_OFF
+ SKF_AD_ALU_XOR_X
),
827 BPF_STMT(BPF_RET
| BPF_A
, 0)
831 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
836 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
837 BPF_STMT(BPF_LD
| BPF_IMM
, 2),
838 BPF_STMT(BPF_ALU
| BPF_RSH
, 1),
839 BPF_STMT(BPF_ALU
| BPF_XOR
| BPF_X
, 0),
840 BPF_STMT(BPF_ST
, 1), /* M1 = 1 ^ len */
841 BPF_STMT(BPF_ALU
| BPF_XOR
| BPF_K
, 0x80000000),
842 BPF_STMT(BPF_ST
, 2), /* M2 = 1 ^ len ^ 0x80000000 */
843 BPF_STMT(BPF_STX
, 15), /* M3 = len */
844 BPF_STMT(BPF_LDX
| BPF_MEM
, 1),
845 BPF_STMT(BPF_LD
| BPF_MEM
, 2),
846 BPF_STMT(BPF_ALU
| BPF_XOR
| BPF_X
, 0),
847 BPF_STMT(BPF_LDX
| BPF_MEM
, 15),
848 BPF_STMT(BPF_ALU
| BPF_XOR
| BPF_X
, 0),
849 BPF_STMT(BPF_RET
| BPF_A
, 0)
853 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
858 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
859 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
860 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_X
, 0, 0, 1),
861 BPF_STMT(BPF_RET
| BPF_K
, 1),
862 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
866 { { 1, 0 }, { 3, 1 }, { 4, MAX_K
} },
871 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
872 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
873 BPF_JUMP(BPF_JMP
| BPF_JGT
| BPF_X
, 0, 0, 1),
874 BPF_STMT(BPF_RET
| BPF_K
, 1),
875 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
879 { { 2, 0 }, { 3, 1 }, { 4, MAX_K
} },
882 "JGE (jt 0), test 1",
884 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
885 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
886 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_X
, 0, 0, 1),
887 BPF_STMT(BPF_RET
| BPF_K
, 1),
888 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
892 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
895 "JGE (jt 0), test 2",
897 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
898 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
899 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_X
, 0, 0, 1),
900 BPF_STMT(BPF_RET
| BPF_K
, 1),
901 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
905 { { 4, 1 }, { 5, 1 }, { 6, MAX_K
} },
910 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
911 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, MAX_K
),
912 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_K
, 1, 1, 0),
913 BPF_STMT(BPF_RET
| BPF_K
, 10),
914 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_K
, 2, 1, 0),
915 BPF_STMT(BPF_RET
| BPF_K
, 20),
916 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_K
, 3, 1, 0),
917 BPF_STMT(BPF_RET
| BPF_K
, 30),
918 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_K
, 4, 1, 0),
919 BPF_STMT(BPF_RET
| BPF_K
, 40),
920 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
924 { { 1, 20 }, { 3, 40 }, { 5, MAX_K
} },
929 BPF_JUMP(BPF_JMP
| BPF_JA
, 0, 0, 0),
930 BPF_JUMP(BPF_JMP
| BPF_JA
, 1, 1, 1),
931 BPF_JUMP(BPF_JMP
| BPF_JA
, 0, 0, 0),
932 BPF_JUMP(BPF_JMP
| BPF_JA
, 0, 0, 0),
933 BPF_STMT(BPF_LDX
| BPF_LEN
, 0),
934 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
935 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_K
, 4),
936 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
937 BPF_STMT(BPF_LD
| BPF_W
| BPF_IND
, 0),
938 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 1, 0, 1),
939 BPF_STMT(BPF_RET
| BPF_K
, 10),
940 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0x80000000, 0, 1),
941 BPF_STMT(BPF_RET
| BPF_K
, 20),
942 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0xffffff, 1, 0),
943 BPF_STMT(BPF_RET
| BPF_K
, 30),
944 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0xffffff, 1, 0),
945 BPF_STMT(BPF_RET
| BPF_K
, 30),
946 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0xffffff, 1, 0),
947 BPF_STMT(BPF_RET
| BPF_K
, 30),
948 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0xffffff, 1, 0),
949 BPF_STMT(BPF_RET
| BPF_K
, 30),
950 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0xffffff, 1, 0),
951 BPF_STMT(BPF_RET
| BPF_K
, 30),
952 BPF_STMT(BPF_RET
| BPF_K
, MAX_K
)
955 { 0, 0xAA, 0x55, 1 },
956 { { 4, 10 }, { 5, 20 }, { 6, MAX_K
} },
961 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 12),
962 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x86dd, 0, 8), /* IPv6 */
963 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 20),
964 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x84, 2, 0),
965 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x6, 1, 0),
966 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x11, 0, 17),
967 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 54),
968 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 14, 0),
969 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 56),
970 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 12, 13),
971 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x0800, 0, 12), /* IPv4 */
972 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 23),
973 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x84, 2, 0),
974 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x6, 1, 0),
975 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x11, 0, 8),
976 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 20),
977 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0x1fff, 6, 0),
978 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 14),
979 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, 14),
980 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 2, 0),
981 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, 16),
982 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 0, 1),
983 BPF_STMT(BPF_RET
| BPF_K
, 0xffff),
984 BPF_STMT(BPF_RET
| BPF_K
, 0),
987 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
988 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
989 * seq 1305692979:1305693027, ack 3650467037, win 65535,
990 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
992 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
993 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
995 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
996 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
997 0x0a, 0x01, 0x01, 0x95, /* ip src */
998 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1000 0x00, 0x16 /* dst port */ },
1001 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1006 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
1007 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
1008 * (len > 115 or len < 30000000000)' -d
1010 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 12),
1011 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x86dd, 30, 0),
1012 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x800, 0, 29),
1013 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 23),
1014 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x6, 0, 27),
1015 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 20),
1016 BPF_JUMP(BPF_JMP
| BPF_JSET
| BPF_K
, 0x1fff, 25, 0),
1017 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 14),
1018 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, 14),
1019 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 2, 0),
1020 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, 16),
1021 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 22, 0, 20),
1022 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 16),
1023 BPF_STMT(BPF_ST
, 1),
1024 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 14),
1025 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0xf),
1026 BPF_STMT(BPF_ALU
| BPF_LSH
| BPF_K
, 2),
1027 BPF_STMT(BPF_MISC
| BPF_TAX
, 0x5), /* libpcap emits K on TAX */
1028 BPF_STMT(BPF_LD
| BPF_MEM
, 1),
1029 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_X
, 0),
1030 BPF_STMT(BPF_ST
, 5),
1031 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 14),
1032 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 26),
1033 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0xf0),
1034 BPF_STMT(BPF_ALU
| BPF_RSH
| BPF_K
, 2),
1035 BPF_STMT(BPF_MISC
| BPF_TAX
, 0x9), /* libpcap emits K on TAX */
1036 BPF_STMT(BPF_LD
| BPF_MEM
, 5),
1037 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_X
, 0, 4, 0),
1038 BPF_STMT(BPF_LD
| BPF_LEN
, 0),
1039 BPF_JUMP(BPF_JMP
| BPF_JGT
| BPF_K
, 0x73, 1, 0),
1040 BPF_JUMP(BPF_JMP
| BPF_JGE
| BPF_K
, 0xfc23ac00, 1, 0),
1041 BPF_STMT(BPF_RET
| BPF_K
, 0xffff),
1042 BPF_STMT(BPF_RET
| BPF_K
, 0),
1045 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1046 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1048 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1049 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1050 0x0a, 0x01, 0x01, 0x95, /* ip src */
1051 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1053 0x00, 0x16 /* dst port */ },
1054 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1059 /* check that unitialized X and A contain zeros */
1060 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
1061 BPF_STMT(BPF_RET
| BPF_A
, 0)
1070 BPF_ALU64_IMM(BPF_MOV
, R1
, 1),
1071 BPF_ALU64_IMM(BPF_ADD
, R1
, 2),
1072 BPF_ALU64_IMM(BPF_MOV
, R2
, 3),
1073 BPF_ALU64_REG(BPF_SUB
, R1
, R2
),
1074 BPF_ALU64_IMM(BPF_ADD
, R1
, -1),
1075 BPF_ALU64_IMM(BPF_MUL
, R1
, 3),
1076 BPF_ALU64_REG(BPF_MOV
, R0
, R1
),
1081 { { 0, 0xfffffffd } }
1086 BPF_ALU64_IMM(BPF_MOV
, R0
, -1),
1087 BPF_ALU64_IMM(BPF_MOV
, R1
, -1),
1088 BPF_ALU64_IMM(BPF_MOV
, R2
, 3),
1089 BPF_ALU64_REG(BPF_MUL
, R1
, R2
),
1090 BPF_JMP_IMM(BPF_JEQ
, R1
, 0xfffffffd, 1),
1092 BPF_ALU64_IMM(BPF_MOV
, R0
, 1),
1102 BPF_ALU32_IMM(BPF_MOV
, R0
, -1),
1103 BPF_ALU32_IMM(BPF_MOV
, R1
, -1),
1104 BPF_ALU32_IMM(BPF_MOV
, R2
, 3),
1105 BPF_ALU64_REG(BPF_MUL
, R1
, R2
),
1106 BPF_ALU64_IMM(BPF_RSH
, R1
, 8),
1107 BPF_JMP_IMM(BPF_JEQ
, R1
, 0x2ffffff, 1),
1109 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
1119 BPF_ALU32_IMM(BPF_MOV
, R0
, -1),
1120 BPF_ALU64_IMM(BPF_MOV
, R1
, -1),
1121 BPF_ALU32_IMM(BPF_MOV
, R2
, 3),
1122 BPF_ALU32_REG(BPF_MUL
, R1
, R2
),
1123 BPF_ALU64_IMM(BPF_RSH
, R1
, 8),
1124 BPF_JMP_IMM(BPF_JEQ
, R1
, 0xffffff, 1),
1126 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
1134 /* Have to test all register combinations, since
1135 * JITing of different registers will produce
1136 * different asm code.
1140 BPF_ALU64_IMM(BPF_MOV
, R0
, 0),
1141 BPF_ALU64_IMM(BPF_MOV
, R1
, 1),
1142 BPF_ALU64_IMM(BPF_MOV
, R2
, 2),
1143 BPF_ALU64_IMM(BPF_MOV
, R3
, 3),
1144 BPF_ALU64_IMM(BPF_MOV
, R4
, 4),
1145 BPF_ALU64_IMM(BPF_MOV
, R5
, 5),
1146 BPF_ALU64_IMM(BPF_MOV
, R6
, 6),
1147 BPF_ALU64_IMM(BPF_MOV
, R7
, 7),
1148 BPF_ALU64_IMM(BPF_MOV
, R8
, 8),
1149 BPF_ALU64_IMM(BPF_MOV
, R9
, 9),
1150 BPF_ALU64_IMM(BPF_ADD
, R0
, 20),
1151 BPF_ALU64_IMM(BPF_ADD
, R1
, 20),
1152 BPF_ALU64_IMM(BPF_ADD
, R2
, 20),
1153 BPF_ALU64_IMM(BPF_ADD
, R3
, 20),
1154 BPF_ALU64_IMM(BPF_ADD
, R4
, 20),
1155 BPF_ALU64_IMM(BPF_ADD
, R5
, 20),
1156 BPF_ALU64_IMM(BPF_ADD
, R6
, 20),
1157 BPF_ALU64_IMM(BPF_ADD
, R7
, 20),
1158 BPF_ALU64_IMM(BPF_ADD
, R8
, 20),
1159 BPF_ALU64_IMM(BPF_ADD
, R9
, 20),
1160 BPF_ALU64_IMM(BPF_SUB
, R0
, 10),
1161 BPF_ALU64_IMM(BPF_SUB
, R1
, 10),
1162 BPF_ALU64_IMM(BPF_SUB
, R2
, 10),
1163 BPF_ALU64_IMM(BPF_SUB
, R3
, 10),
1164 BPF_ALU64_IMM(BPF_SUB
, R4
, 10),
1165 BPF_ALU64_IMM(BPF_SUB
, R5
, 10),
1166 BPF_ALU64_IMM(BPF_SUB
, R6
, 10),
1167 BPF_ALU64_IMM(BPF_SUB
, R7
, 10),
1168 BPF_ALU64_IMM(BPF_SUB
, R8
, 10),
1169 BPF_ALU64_IMM(BPF_SUB
, R9
, 10),
1170 BPF_ALU64_REG(BPF_ADD
, R0
, R0
),
1171 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
1172 BPF_ALU64_REG(BPF_ADD
, R0
, R2
),
1173 BPF_ALU64_REG(BPF_ADD
, R0
, R3
),
1174 BPF_ALU64_REG(BPF_ADD
, R0
, R4
),
1175 BPF_ALU64_REG(BPF_ADD
, R0
, R5
),
1176 BPF_ALU64_REG(BPF_ADD
, R0
, R6
),
1177 BPF_ALU64_REG(BPF_ADD
, R0
, R7
),
1178 BPF_ALU64_REG(BPF_ADD
, R0
, R8
),
1179 BPF_ALU64_REG(BPF_ADD
, R0
, R9
), /* R0 == 155 */
1180 BPF_JMP_IMM(BPF_JEQ
, R0
, 155, 1),
1182 BPF_ALU64_REG(BPF_ADD
, R1
, R0
),
1183 BPF_ALU64_REG(BPF_ADD
, R1
, R1
),
1184 BPF_ALU64_REG(BPF_ADD
, R1
, R2
),
1185 BPF_ALU64_REG(BPF_ADD
, R1
, R3
),
1186 BPF_ALU64_REG(BPF_ADD
, R1
, R4
),
1187 BPF_ALU64_REG(BPF_ADD
, R1
, R5
),
1188 BPF_ALU64_REG(BPF_ADD
, R1
, R6
),
1189 BPF_ALU64_REG(BPF_ADD
, R1
, R7
),
1190 BPF_ALU64_REG(BPF_ADD
, R1
, R8
),
1191 BPF_ALU64_REG(BPF_ADD
, R1
, R9
), /* R1 == 456 */
1192 BPF_JMP_IMM(BPF_JEQ
, R1
, 456, 1),
1194 BPF_ALU64_REG(BPF_ADD
, R2
, R0
),
1195 BPF_ALU64_REG(BPF_ADD
, R2
, R1
),
1196 BPF_ALU64_REG(BPF_ADD
, R2
, R2
),
1197 BPF_ALU64_REG(BPF_ADD
, R2
, R3
),
1198 BPF_ALU64_REG(BPF_ADD
, R2
, R4
),
1199 BPF_ALU64_REG(BPF_ADD
, R2
, R5
),
1200 BPF_ALU64_REG(BPF_ADD
, R2
, R6
),
1201 BPF_ALU64_REG(BPF_ADD
, R2
, R7
),
1202 BPF_ALU64_REG(BPF_ADD
, R2
, R8
),
1203 BPF_ALU64_REG(BPF_ADD
, R2
, R9
), /* R2 == 1358 */
1204 BPF_JMP_IMM(BPF_JEQ
, R2
, 1358, 1),
1206 BPF_ALU64_REG(BPF_ADD
, R3
, R0
),
1207 BPF_ALU64_REG(BPF_ADD
, R3
, R1
),
1208 BPF_ALU64_REG(BPF_ADD
, R3
, R2
),
1209 BPF_ALU64_REG(BPF_ADD
, R3
, R3
),
1210 BPF_ALU64_REG(BPF_ADD
, R3
, R4
),
1211 BPF_ALU64_REG(BPF_ADD
, R3
, R5
),
1212 BPF_ALU64_REG(BPF_ADD
, R3
, R6
),
1213 BPF_ALU64_REG(BPF_ADD
, R3
, R7
),
1214 BPF_ALU64_REG(BPF_ADD
, R3
, R8
),
1215 BPF_ALU64_REG(BPF_ADD
, R3
, R9
), /* R3 == 4063 */
1216 BPF_JMP_IMM(BPF_JEQ
, R3
, 4063, 1),
1218 BPF_ALU64_REG(BPF_ADD
, R4
, R0
),
1219 BPF_ALU64_REG(BPF_ADD
, R4
, R1
),
1220 BPF_ALU64_REG(BPF_ADD
, R4
, R2
),
1221 BPF_ALU64_REG(BPF_ADD
, R4
, R3
),
1222 BPF_ALU64_REG(BPF_ADD
, R4
, R4
),
1223 BPF_ALU64_REG(BPF_ADD
, R4
, R5
),
1224 BPF_ALU64_REG(BPF_ADD
, R4
, R6
),
1225 BPF_ALU64_REG(BPF_ADD
, R4
, R7
),
1226 BPF_ALU64_REG(BPF_ADD
, R4
, R8
),
1227 BPF_ALU64_REG(BPF_ADD
, R4
, R9
), /* R4 == 12177 */
1228 BPF_JMP_IMM(BPF_JEQ
, R4
, 12177, 1),
1230 BPF_ALU64_REG(BPF_ADD
, R5
, R0
),
1231 BPF_ALU64_REG(BPF_ADD
, R5
, R1
),
1232 BPF_ALU64_REG(BPF_ADD
, R5
, R2
),
1233 BPF_ALU64_REG(BPF_ADD
, R5
, R3
),
1234 BPF_ALU64_REG(BPF_ADD
, R5
, R4
),
1235 BPF_ALU64_REG(BPF_ADD
, R5
, R5
),
1236 BPF_ALU64_REG(BPF_ADD
, R5
, R6
),
1237 BPF_ALU64_REG(BPF_ADD
, R5
, R7
),
1238 BPF_ALU64_REG(BPF_ADD
, R5
, R8
),
1239 BPF_ALU64_REG(BPF_ADD
, R5
, R9
), /* R5 == 36518 */
1240 BPF_JMP_IMM(BPF_JEQ
, R5
, 36518, 1),
1242 BPF_ALU64_REG(BPF_ADD
, R6
, R0
),
1243 BPF_ALU64_REG(BPF_ADD
, R6
, R1
),
1244 BPF_ALU64_REG(BPF_ADD
, R6
, R2
),
1245 BPF_ALU64_REG(BPF_ADD
, R6
, R3
),
1246 BPF_ALU64_REG(BPF_ADD
, R6
, R4
),
1247 BPF_ALU64_REG(BPF_ADD
, R6
, R5
),
1248 BPF_ALU64_REG(BPF_ADD
, R6
, R6
),
1249 BPF_ALU64_REG(BPF_ADD
, R6
, R7
),
1250 BPF_ALU64_REG(BPF_ADD
, R6
, R8
),
1251 BPF_ALU64_REG(BPF_ADD
, R6
, R9
), /* R6 == 109540 */
1252 BPF_JMP_IMM(BPF_JEQ
, R6
, 109540, 1),
1254 BPF_ALU64_REG(BPF_ADD
, R7
, R0
),
1255 BPF_ALU64_REG(BPF_ADD
, R7
, R1
),
1256 BPF_ALU64_REG(BPF_ADD
, R7
, R2
),
1257 BPF_ALU64_REG(BPF_ADD
, R7
, R3
),
1258 BPF_ALU64_REG(BPF_ADD
, R7
, R4
),
1259 BPF_ALU64_REG(BPF_ADD
, R7
, R5
),
1260 BPF_ALU64_REG(BPF_ADD
, R7
, R6
),
1261 BPF_ALU64_REG(BPF_ADD
, R7
, R7
),
1262 BPF_ALU64_REG(BPF_ADD
, R7
, R8
),
1263 BPF_ALU64_REG(BPF_ADD
, R7
, R9
), /* R7 == 328605 */
1264 BPF_JMP_IMM(BPF_JEQ
, R7
, 328605, 1),
1266 BPF_ALU64_REG(BPF_ADD
, R8
, R0
),
1267 BPF_ALU64_REG(BPF_ADD
, R8
, R1
),
1268 BPF_ALU64_REG(BPF_ADD
, R8
, R2
),
1269 BPF_ALU64_REG(BPF_ADD
, R8
, R3
),
1270 BPF_ALU64_REG(BPF_ADD
, R8
, R4
),
1271 BPF_ALU64_REG(BPF_ADD
, R8
, R5
),
1272 BPF_ALU64_REG(BPF_ADD
, R8
, R6
),
1273 BPF_ALU64_REG(BPF_ADD
, R8
, R7
),
1274 BPF_ALU64_REG(BPF_ADD
, R8
, R8
),
1275 BPF_ALU64_REG(BPF_ADD
, R8
, R9
), /* R8 == 985799 */
1276 BPF_JMP_IMM(BPF_JEQ
, R8
, 985799, 1),
1278 BPF_ALU64_REG(BPF_ADD
, R9
, R0
),
1279 BPF_ALU64_REG(BPF_ADD
, R9
, R1
),
1280 BPF_ALU64_REG(BPF_ADD
, R9
, R2
),
1281 BPF_ALU64_REG(BPF_ADD
, R9
, R3
),
1282 BPF_ALU64_REG(BPF_ADD
, R9
, R4
),
1283 BPF_ALU64_REG(BPF_ADD
, R9
, R5
),
1284 BPF_ALU64_REG(BPF_ADD
, R9
, R6
),
1285 BPF_ALU64_REG(BPF_ADD
, R9
, R7
),
1286 BPF_ALU64_REG(BPF_ADD
, R9
, R8
),
1287 BPF_ALU64_REG(BPF_ADD
, R9
, R9
), /* R9 == 2957380 */
1288 BPF_ALU64_REG(BPF_MOV
, R0
, R9
),
1298 BPF_ALU32_IMM(BPF_MOV
, R0
, 20),
1299 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
1300 BPF_ALU32_IMM(BPF_MOV
, R2
, 2),
1301 BPF_ALU32_IMM(BPF_MOV
, R3
, 3),
1302 BPF_ALU32_IMM(BPF_MOV
, R4
, 4),
1303 BPF_ALU32_IMM(BPF_MOV
, R5
, 5),
1304 BPF_ALU32_IMM(BPF_MOV
, R6
, 6),
1305 BPF_ALU32_IMM(BPF_MOV
, R7
, 7),
1306 BPF_ALU32_IMM(BPF_MOV
, R8
, 8),
1307 BPF_ALU32_IMM(BPF_MOV
, R9
, 9),
1308 BPF_ALU64_IMM(BPF_ADD
, R1
, 10),
1309 BPF_ALU64_IMM(BPF_ADD
, R2
, 10),
1310 BPF_ALU64_IMM(BPF_ADD
, R3
, 10),
1311 BPF_ALU64_IMM(BPF_ADD
, R4
, 10),
1312 BPF_ALU64_IMM(BPF_ADD
, R5
, 10),
1313 BPF_ALU64_IMM(BPF_ADD
, R6
, 10),
1314 BPF_ALU64_IMM(BPF_ADD
, R7
, 10),
1315 BPF_ALU64_IMM(BPF_ADD
, R8
, 10),
1316 BPF_ALU64_IMM(BPF_ADD
, R9
, 10),
1317 BPF_ALU32_REG(BPF_ADD
, R0
, R1
),
1318 BPF_ALU32_REG(BPF_ADD
, R0
, R2
),
1319 BPF_ALU32_REG(BPF_ADD
, R0
, R3
),
1320 BPF_ALU32_REG(BPF_ADD
, R0
, R4
),
1321 BPF_ALU32_REG(BPF_ADD
, R0
, R5
),
1322 BPF_ALU32_REG(BPF_ADD
, R0
, R6
),
1323 BPF_ALU32_REG(BPF_ADD
, R0
, R7
),
1324 BPF_ALU32_REG(BPF_ADD
, R0
, R8
),
1325 BPF_ALU32_REG(BPF_ADD
, R0
, R9
), /* R0 == 155 */
1326 BPF_JMP_IMM(BPF_JEQ
, R0
, 155, 1),
1328 BPF_ALU32_REG(BPF_ADD
, R1
, R0
),
1329 BPF_ALU32_REG(BPF_ADD
, R1
, R1
),
1330 BPF_ALU32_REG(BPF_ADD
, R1
, R2
),
1331 BPF_ALU32_REG(BPF_ADD
, R1
, R3
),
1332 BPF_ALU32_REG(BPF_ADD
, R1
, R4
),
1333 BPF_ALU32_REG(BPF_ADD
, R1
, R5
),
1334 BPF_ALU32_REG(BPF_ADD
, R1
, R6
),
1335 BPF_ALU32_REG(BPF_ADD
, R1
, R7
),
1336 BPF_ALU32_REG(BPF_ADD
, R1
, R8
),
1337 BPF_ALU32_REG(BPF_ADD
, R1
, R9
), /* R1 == 456 */
1338 BPF_JMP_IMM(BPF_JEQ
, R1
, 456, 1),
1340 BPF_ALU32_REG(BPF_ADD
, R2
, R0
),
1341 BPF_ALU32_REG(BPF_ADD
, R2
, R1
),
1342 BPF_ALU32_REG(BPF_ADD
, R2
, R2
),
1343 BPF_ALU32_REG(BPF_ADD
, R2
, R3
),
1344 BPF_ALU32_REG(BPF_ADD
, R2
, R4
),
1345 BPF_ALU32_REG(BPF_ADD
, R2
, R5
),
1346 BPF_ALU32_REG(BPF_ADD
, R2
, R6
),
1347 BPF_ALU32_REG(BPF_ADD
, R2
, R7
),
1348 BPF_ALU32_REG(BPF_ADD
, R2
, R8
),
1349 BPF_ALU32_REG(BPF_ADD
, R2
, R9
), /* R2 == 1358 */
1350 BPF_JMP_IMM(BPF_JEQ
, R2
, 1358, 1),
1352 BPF_ALU32_REG(BPF_ADD
, R3
, R0
),
1353 BPF_ALU32_REG(BPF_ADD
, R3
, R1
),
1354 BPF_ALU32_REG(BPF_ADD
, R3
, R2
),
1355 BPF_ALU32_REG(BPF_ADD
, R3
, R3
),
1356 BPF_ALU32_REG(BPF_ADD
, R3
, R4
),
1357 BPF_ALU32_REG(BPF_ADD
, R3
, R5
),
1358 BPF_ALU32_REG(BPF_ADD
, R3
, R6
),
1359 BPF_ALU32_REG(BPF_ADD
, R3
, R7
),
1360 BPF_ALU32_REG(BPF_ADD
, R3
, R8
),
1361 BPF_ALU32_REG(BPF_ADD
, R3
, R9
), /* R3 == 4063 */
1362 BPF_JMP_IMM(BPF_JEQ
, R3
, 4063, 1),
1364 BPF_ALU32_REG(BPF_ADD
, R4
, R0
),
1365 BPF_ALU32_REG(BPF_ADD
, R4
, R1
),
1366 BPF_ALU32_REG(BPF_ADD
, R4
, R2
),
1367 BPF_ALU32_REG(BPF_ADD
, R4
, R3
),
1368 BPF_ALU32_REG(BPF_ADD
, R4
, R4
),
1369 BPF_ALU32_REG(BPF_ADD
, R4
, R5
),
1370 BPF_ALU32_REG(BPF_ADD
, R4
, R6
),
1371 BPF_ALU32_REG(BPF_ADD
, R4
, R7
),
1372 BPF_ALU32_REG(BPF_ADD
, R4
, R8
),
1373 BPF_ALU32_REG(BPF_ADD
, R4
, R9
), /* R4 == 12177 */
1374 BPF_JMP_IMM(BPF_JEQ
, R4
, 12177, 1),
1376 BPF_ALU32_REG(BPF_ADD
, R5
, R0
),
1377 BPF_ALU32_REG(BPF_ADD
, R5
, R1
),
1378 BPF_ALU32_REG(BPF_ADD
, R5
, R2
),
1379 BPF_ALU32_REG(BPF_ADD
, R5
, R3
),
1380 BPF_ALU32_REG(BPF_ADD
, R5
, R4
),
1381 BPF_ALU32_REG(BPF_ADD
, R5
, R5
),
1382 BPF_ALU32_REG(BPF_ADD
, R5
, R6
),
1383 BPF_ALU32_REG(BPF_ADD
, R5
, R7
),
1384 BPF_ALU32_REG(BPF_ADD
, R5
, R8
),
1385 BPF_ALU32_REG(BPF_ADD
, R5
, R9
), /* R5 == 36518 */
1386 BPF_JMP_IMM(BPF_JEQ
, R5
, 36518, 1),
1388 BPF_ALU32_REG(BPF_ADD
, R6
, R0
),
1389 BPF_ALU32_REG(BPF_ADD
, R6
, R1
),
1390 BPF_ALU32_REG(BPF_ADD
, R6
, R2
),
1391 BPF_ALU32_REG(BPF_ADD
, R6
, R3
),
1392 BPF_ALU32_REG(BPF_ADD
, R6
, R4
),
1393 BPF_ALU32_REG(BPF_ADD
, R6
, R5
),
1394 BPF_ALU32_REG(BPF_ADD
, R6
, R6
),
1395 BPF_ALU32_REG(BPF_ADD
, R6
, R7
),
1396 BPF_ALU32_REG(BPF_ADD
, R6
, R8
),
1397 BPF_ALU32_REG(BPF_ADD
, R6
, R9
), /* R6 == 109540 */
1398 BPF_JMP_IMM(BPF_JEQ
, R6
, 109540, 1),
1400 BPF_ALU32_REG(BPF_ADD
, R7
, R0
),
1401 BPF_ALU32_REG(BPF_ADD
, R7
, R1
),
1402 BPF_ALU32_REG(BPF_ADD
, R7
, R2
),
1403 BPF_ALU32_REG(BPF_ADD
, R7
, R3
),
1404 BPF_ALU32_REG(BPF_ADD
, R7
, R4
),
1405 BPF_ALU32_REG(BPF_ADD
, R7
, R5
),
1406 BPF_ALU32_REG(BPF_ADD
, R7
, R6
),
1407 BPF_ALU32_REG(BPF_ADD
, R7
, R7
),
1408 BPF_ALU32_REG(BPF_ADD
, R7
, R8
),
1409 BPF_ALU32_REG(BPF_ADD
, R7
, R9
), /* R7 == 328605 */
1410 BPF_JMP_IMM(BPF_JEQ
, R7
, 328605, 1),
1412 BPF_ALU32_REG(BPF_ADD
, R8
, R0
),
1413 BPF_ALU32_REG(BPF_ADD
, R8
, R1
),
1414 BPF_ALU32_REG(BPF_ADD
, R8
, R2
),
1415 BPF_ALU32_REG(BPF_ADD
, R8
, R3
),
1416 BPF_ALU32_REG(BPF_ADD
, R8
, R4
),
1417 BPF_ALU32_REG(BPF_ADD
, R8
, R5
),
1418 BPF_ALU32_REG(BPF_ADD
, R8
, R6
),
1419 BPF_ALU32_REG(BPF_ADD
, R8
, R7
),
1420 BPF_ALU32_REG(BPF_ADD
, R8
, R8
),
1421 BPF_ALU32_REG(BPF_ADD
, R8
, R9
), /* R8 == 985799 */
1422 BPF_JMP_IMM(BPF_JEQ
, R8
, 985799, 1),
1424 BPF_ALU32_REG(BPF_ADD
, R9
, R0
),
1425 BPF_ALU32_REG(BPF_ADD
, R9
, R1
),
1426 BPF_ALU32_REG(BPF_ADD
, R9
, R2
),
1427 BPF_ALU32_REG(BPF_ADD
, R9
, R3
),
1428 BPF_ALU32_REG(BPF_ADD
, R9
, R4
),
1429 BPF_ALU32_REG(BPF_ADD
, R9
, R5
),
1430 BPF_ALU32_REG(BPF_ADD
, R9
, R6
),
1431 BPF_ALU32_REG(BPF_ADD
, R9
, R7
),
1432 BPF_ALU32_REG(BPF_ADD
, R9
, R8
),
1433 BPF_ALU32_REG(BPF_ADD
, R9
, R9
), /* R9 == 2957380 */
1434 BPF_ALU32_REG(BPF_MOV
, R0
, R9
),
1441 { /* Mainly checking JIT here. */
1444 BPF_ALU64_IMM(BPF_MOV
, R0
, 0),
1445 BPF_ALU64_IMM(BPF_MOV
, R1
, 1),
1446 BPF_ALU64_IMM(BPF_MOV
, R2
, 2),
1447 BPF_ALU64_IMM(BPF_MOV
, R3
, 3),
1448 BPF_ALU64_IMM(BPF_MOV
, R4
, 4),
1449 BPF_ALU64_IMM(BPF_MOV
, R5
, 5),
1450 BPF_ALU64_IMM(BPF_MOV
, R6
, 6),
1451 BPF_ALU64_IMM(BPF_MOV
, R7
, 7),
1452 BPF_ALU64_IMM(BPF_MOV
, R8
, 8),
1453 BPF_ALU64_IMM(BPF_MOV
, R9
, 9),
1454 BPF_ALU64_REG(BPF_SUB
, R0
, R0
),
1455 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
1456 BPF_ALU64_REG(BPF_SUB
, R0
, R2
),
1457 BPF_ALU64_REG(BPF_SUB
, R0
, R3
),
1458 BPF_ALU64_REG(BPF_SUB
, R0
, R4
),
1459 BPF_ALU64_REG(BPF_SUB
, R0
, R5
),
1460 BPF_ALU64_REG(BPF_SUB
, R0
, R6
),
1461 BPF_ALU64_REG(BPF_SUB
, R0
, R7
),
1462 BPF_ALU64_REG(BPF_SUB
, R0
, R8
),
1463 BPF_ALU64_REG(BPF_SUB
, R0
, R9
),
1464 BPF_ALU64_IMM(BPF_SUB
, R0
, 10),
1465 BPF_JMP_IMM(BPF_JEQ
, R0
, -55, 1),
1467 BPF_ALU64_REG(BPF_SUB
, R1
, R0
),
1468 BPF_ALU64_REG(BPF_SUB
, R1
, R2
),
1469 BPF_ALU64_REG(BPF_SUB
, R1
, R3
),
1470 BPF_ALU64_REG(BPF_SUB
, R1
, R4
),
1471 BPF_ALU64_REG(BPF_SUB
, R1
, R5
),
1472 BPF_ALU64_REG(BPF_SUB
, R1
, R6
),
1473 BPF_ALU64_REG(BPF_SUB
, R1
, R7
),
1474 BPF_ALU64_REG(BPF_SUB
, R1
, R8
),
1475 BPF_ALU64_REG(BPF_SUB
, R1
, R9
),
1476 BPF_ALU64_IMM(BPF_SUB
, R1
, 10),
1477 BPF_ALU64_REG(BPF_SUB
, R2
, R0
),
1478 BPF_ALU64_REG(BPF_SUB
, R2
, R1
),
1479 BPF_ALU64_REG(BPF_SUB
, R2
, R3
),
1480 BPF_ALU64_REG(BPF_SUB
, R2
, R4
),
1481 BPF_ALU64_REG(BPF_SUB
, R2
, R5
),
1482 BPF_ALU64_REG(BPF_SUB
, R2
, R6
),
1483 BPF_ALU64_REG(BPF_SUB
, R2
, R7
),
1484 BPF_ALU64_REG(BPF_SUB
, R2
, R8
),
1485 BPF_ALU64_REG(BPF_SUB
, R2
, R9
),
1486 BPF_ALU64_IMM(BPF_SUB
, R2
, 10),
1487 BPF_ALU64_REG(BPF_SUB
, R3
, R0
),
1488 BPF_ALU64_REG(BPF_SUB
, R3
, R1
),
1489 BPF_ALU64_REG(BPF_SUB
, R3
, R2
),
1490 BPF_ALU64_REG(BPF_SUB
, R3
, R4
),
1491 BPF_ALU64_REG(BPF_SUB
, R3
, R5
),
1492 BPF_ALU64_REG(BPF_SUB
, R3
, R6
),
1493 BPF_ALU64_REG(BPF_SUB
, R3
, R7
),
1494 BPF_ALU64_REG(BPF_SUB
, R3
, R8
),
1495 BPF_ALU64_REG(BPF_SUB
, R3
, R9
),
1496 BPF_ALU64_IMM(BPF_SUB
, R3
, 10),
1497 BPF_ALU64_REG(BPF_SUB
, R4
, R0
),
1498 BPF_ALU64_REG(BPF_SUB
, R4
, R1
),
1499 BPF_ALU64_REG(BPF_SUB
, R4
, R2
),
1500 BPF_ALU64_REG(BPF_SUB
, R4
, R3
),
1501 BPF_ALU64_REG(BPF_SUB
, R4
, R5
),
1502 BPF_ALU64_REG(BPF_SUB
, R4
, R6
),
1503 BPF_ALU64_REG(BPF_SUB
, R4
, R7
),
1504 BPF_ALU64_REG(BPF_SUB
, R4
, R8
),
1505 BPF_ALU64_REG(BPF_SUB
, R4
, R9
),
1506 BPF_ALU64_IMM(BPF_SUB
, R4
, 10),
1507 BPF_ALU64_REG(BPF_SUB
, R5
, R0
),
1508 BPF_ALU64_REG(BPF_SUB
, R5
, R1
),
1509 BPF_ALU64_REG(BPF_SUB
, R5
, R2
),
1510 BPF_ALU64_REG(BPF_SUB
, R5
, R3
),
1511 BPF_ALU64_REG(BPF_SUB
, R5
, R4
),
1512 BPF_ALU64_REG(BPF_SUB
, R5
, R6
),
1513 BPF_ALU64_REG(BPF_SUB
, R5
, R7
),
1514 BPF_ALU64_REG(BPF_SUB
, R5
, R8
),
1515 BPF_ALU64_REG(BPF_SUB
, R5
, R9
),
1516 BPF_ALU64_IMM(BPF_SUB
, R5
, 10),
1517 BPF_ALU64_REG(BPF_SUB
, R6
, R0
),
1518 BPF_ALU64_REG(BPF_SUB
, R6
, R1
),
1519 BPF_ALU64_REG(BPF_SUB
, R6
, R2
),
1520 BPF_ALU64_REG(BPF_SUB
, R6
, R3
),
1521 BPF_ALU64_REG(BPF_SUB
, R6
, R4
),
1522 BPF_ALU64_REG(BPF_SUB
, R6
, R5
),
1523 BPF_ALU64_REG(BPF_SUB
, R6
, R7
),
1524 BPF_ALU64_REG(BPF_SUB
, R6
, R8
),
1525 BPF_ALU64_REG(BPF_SUB
, R6
, R9
),
1526 BPF_ALU64_IMM(BPF_SUB
, R6
, 10),
1527 BPF_ALU64_REG(BPF_SUB
, R7
, R0
),
1528 BPF_ALU64_REG(BPF_SUB
, R7
, R1
),
1529 BPF_ALU64_REG(BPF_SUB
, R7
, R2
),
1530 BPF_ALU64_REG(BPF_SUB
, R7
, R3
),
1531 BPF_ALU64_REG(BPF_SUB
, R7
, R4
),
1532 BPF_ALU64_REG(BPF_SUB
, R7
, R5
),
1533 BPF_ALU64_REG(BPF_SUB
, R7
, R6
),
1534 BPF_ALU64_REG(BPF_SUB
, R7
, R8
),
1535 BPF_ALU64_REG(BPF_SUB
, R7
, R9
),
1536 BPF_ALU64_IMM(BPF_SUB
, R7
, 10),
1537 BPF_ALU64_REG(BPF_SUB
, R8
, R0
),
1538 BPF_ALU64_REG(BPF_SUB
, R8
, R1
),
1539 BPF_ALU64_REG(BPF_SUB
, R8
, R2
),
1540 BPF_ALU64_REG(BPF_SUB
, R8
, R3
),
1541 BPF_ALU64_REG(BPF_SUB
, R8
, R4
),
1542 BPF_ALU64_REG(BPF_SUB
, R8
, R5
),
1543 BPF_ALU64_REG(BPF_SUB
, R8
, R6
),
1544 BPF_ALU64_REG(BPF_SUB
, R8
, R7
),
1545 BPF_ALU64_REG(BPF_SUB
, R8
, R9
),
1546 BPF_ALU64_IMM(BPF_SUB
, R8
, 10),
1547 BPF_ALU64_REG(BPF_SUB
, R9
, R0
),
1548 BPF_ALU64_REG(BPF_SUB
, R9
, R1
),
1549 BPF_ALU64_REG(BPF_SUB
, R9
, R2
),
1550 BPF_ALU64_REG(BPF_SUB
, R9
, R3
),
1551 BPF_ALU64_REG(BPF_SUB
, R9
, R4
),
1552 BPF_ALU64_REG(BPF_SUB
, R9
, R5
),
1553 BPF_ALU64_REG(BPF_SUB
, R9
, R6
),
1554 BPF_ALU64_REG(BPF_SUB
, R9
, R7
),
1555 BPF_ALU64_REG(BPF_SUB
, R9
, R8
),
1556 BPF_ALU64_IMM(BPF_SUB
, R9
, 10),
1557 BPF_ALU64_IMM(BPF_SUB
, R0
, 10),
1558 BPF_ALU64_IMM(BPF_NEG
, R0
, 0),
1559 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
1560 BPF_ALU64_REG(BPF_SUB
, R0
, R2
),
1561 BPF_ALU64_REG(BPF_SUB
, R0
, R3
),
1562 BPF_ALU64_REG(BPF_SUB
, R0
, R4
),
1563 BPF_ALU64_REG(BPF_SUB
, R0
, R5
),
1564 BPF_ALU64_REG(BPF_SUB
, R0
, R6
),
1565 BPF_ALU64_REG(BPF_SUB
, R0
, R7
),
1566 BPF_ALU64_REG(BPF_SUB
, R0
, R8
),
1567 BPF_ALU64_REG(BPF_SUB
, R0
, R9
),
1574 { /* Mainly checking JIT here. */
1577 BPF_ALU64_REG(BPF_SUB
, R0
, R0
),
1578 BPF_ALU64_REG(BPF_XOR
, R1
, R1
),
1579 BPF_JMP_REG(BPF_JEQ
, R0
, R1
, 1),
1581 BPF_ALU64_IMM(BPF_MOV
, R0
, 10),
1582 BPF_ALU64_IMM(BPF_MOV
, R1
, -1),
1583 BPF_ALU64_REG(BPF_SUB
, R1
, R1
),
1584 BPF_ALU64_REG(BPF_XOR
, R2
, R2
),
1585 BPF_JMP_REG(BPF_JEQ
, R1
, R2
, 1),
1587 BPF_ALU64_REG(BPF_SUB
, R2
, R2
),
1588 BPF_ALU64_REG(BPF_XOR
, R3
, R3
),
1589 BPF_ALU64_IMM(BPF_MOV
, R0
, 10),
1590 BPF_ALU64_IMM(BPF_MOV
, R1
, -1),
1591 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 1),
1593 BPF_ALU64_REG(BPF_SUB
, R3
, R3
),
1594 BPF_ALU64_REG(BPF_XOR
, R4
, R4
),
1595 BPF_ALU64_IMM(BPF_MOV
, R2
, 1),
1596 BPF_ALU64_IMM(BPF_MOV
, R5
, -1),
1597 BPF_JMP_REG(BPF_JEQ
, R3
, R4
, 1),
1599 BPF_ALU64_REG(BPF_SUB
, R4
, R4
),
1600 BPF_ALU64_REG(BPF_XOR
, R5
, R5
),
1601 BPF_ALU64_IMM(BPF_MOV
, R3
, 1),
1602 BPF_ALU64_IMM(BPF_MOV
, R7
, -1),
1603 BPF_JMP_REG(BPF_JEQ
, R5
, R4
, 1),
1605 BPF_ALU64_IMM(BPF_MOV
, R5
, 1),
1606 BPF_ALU64_REG(BPF_SUB
, R5
, R5
),
1607 BPF_ALU64_REG(BPF_XOR
, R6
, R6
),
1608 BPF_ALU64_IMM(BPF_MOV
, R1
, 1),
1609 BPF_ALU64_IMM(BPF_MOV
, R8
, -1),
1610 BPF_JMP_REG(BPF_JEQ
, R5
, R6
, 1),
1612 BPF_ALU64_REG(BPF_SUB
, R6
, R6
),
1613 BPF_ALU64_REG(BPF_XOR
, R7
, R7
),
1614 BPF_JMP_REG(BPF_JEQ
, R7
, R6
, 1),
1616 BPF_ALU64_REG(BPF_SUB
, R7
, R7
),
1617 BPF_ALU64_REG(BPF_XOR
, R8
, R8
),
1618 BPF_JMP_REG(BPF_JEQ
, R7
, R8
, 1),
1620 BPF_ALU64_REG(BPF_SUB
, R8
, R8
),
1621 BPF_ALU64_REG(BPF_XOR
, R9
, R9
),
1622 BPF_JMP_REG(BPF_JEQ
, R9
, R8
, 1),
1624 BPF_ALU64_REG(BPF_SUB
, R9
, R9
),
1625 BPF_ALU64_REG(BPF_XOR
, R0
, R0
),
1626 BPF_JMP_REG(BPF_JEQ
, R9
, R0
, 1),
1628 BPF_ALU64_REG(BPF_SUB
, R1
, R1
),
1629 BPF_ALU64_REG(BPF_XOR
, R0
, R0
),
1630 BPF_JMP_REG(BPF_JEQ
, R9
, R0
, 2),
1631 BPF_ALU64_IMM(BPF_MOV
, R0
, 0),
1633 BPF_ALU64_IMM(BPF_MOV
, R0
, 1),
1640 { /* Mainly checking JIT here. */
1643 BPF_ALU64_IMM(BPF_MOV
, R0
, 11),
1644 BPF_ALU64_IMM(BPF_MOV
, R1
, 1),
1645 BPF_ALU64_IMM(BPF_MOV
, R2
, 2),
1646 BPF_ALU64_IMM(BPF_MOV
, R3
, 3),
1647 BPF_ALU64_IMM(BPF_MOV
, R4
, 4),
1648 BPF_ALU64_IMM(BPF_MOV
, R5
, 5),
1649 BPF_ALU64_IMM(BPF_MOV
, R6
, 6),
1650 BPF_ALU64_IMM(BPF_MOV
, R7
, 7),
1651 BPF_ALU64_IMM(BPF_MOV
, R8
, 8),
1652 BPF_ALU64_IMM(BPF_MOV
, R9
, 9),
1653 BPF_ALU64_REG(BPF_MUL
, R0
, R0
),
1654 BPF_ALU64_REG(BPF_MUL
, R0
, R1
),
1655 BPF_ALU64_REG(BPF_MUL
, R0
, R2
),
1656 BPF_ALU64_REG(BPF_MUL
, R0
, R3
),
1657 BPF_ALU64_REG(BPF_MUL
, R0
, R4
),
1658 BPF_ALU64_REG(BPF_MUL
, R0
, R5
),
1659 BPF_ALU64_REG(BPF_MUL
, R0
, R6
),
1660 BPF_ALU64_REG(BPF_MUL
, R0
, R7
),
1661 BPF_ALU64_REG(BPF_MUL
, R0
, R8
),
1662 BPF_ALU64_REG(BPF_MUL
, R0
, R9
),
1663 BPF_ALU64_IMM(BPF_MUL
, R0
, 10),
1664 BPF_JMP_IMM(BPF_JEQ
, R0
, 439084800, 1),
1666 BPF_ALU64_REG(BPF_MUL
, R1
, R0
),
1667 BPF_ALU64_REG(BPF_MUL
, R1
, R2
),
1668 BPF_ALU64_REG(BPF_MUL
, R1
, R3
),
1669 BPF_ALU64_REG(BPF_MUL
, R1
, R4
),
1670 BPF_ALU64_REG(BPF_MUL
, R1
, R5
),
1671 BPF_ALU64_REG(BPF_MUL
, R1
, R6
),
1672 BPF_ALU64_REG(BPF_MUL
, R1
, R7
),
1673 BPF_ALU64_REG(BPF_MUL
, R1
, R8
),
1674 BPF_ALU64_REG(BPF_MUL
, R1
, R9
),
1675 BPF_ALU64_IMM(BPF_MUL
, R1
, 10),
1676 BPF_ALU64_REG(BPF_MOV
, R2
, R1
),
1677 BPF_ALU64_IMM(BPF_RSH
, R2
, 32),
1678 BPF_JMP_IMM(BPF_JEQ
, R2
, 0x5a924, 1),
1680 BPF_ALU64_IMM(BPF_LSH
, R1
, 32),
1681 BPF_ALU64_IMM(BPF_ARSH
, R1
, 32),
1682 BPF_JMP_IMM(BPF_JEQ
, R1
, 0xebb90000, 1),
1684 BPF_ALU64_REG(BPF_MUL
, R2
, R0
),
1685 BPF_ALU64_REG(BPF_MUL
, R2
, R1
),
1686 BPF_ALU64_REG(BPF_MUL
, R2
, R3
),
1687 BPF_ALU64_REG(BPF_MUL
, R2
, R4
),
1688 BPF_ALU64_REG(BPF_MUL
, R2
, R5
),
1689 BPF_ALU64_REG(BPF_MUL
, R2
, R6
),
1690 BPF_ALU64_REG(BPF_MUL
, R2
, R7
),
1691 BPF_ALU64_REG(BPF_MUL
, R2
, R8
),
1692 BPF_ALU64_REG(BPF_MUL
, R2
, R9
),
1693 BPF_ALU64_IMM(BPF_MUL
, R2
, 10),
1694 BPF_ALU64_IMM(BPF_RSH
, R2
, 32),
1695 BPF_ALU64_REG(BPF_MOV
, R0
, R2
),
1700 { { 0, 0x35d97ef2 } }
1702 { /* Mainly checking JIT here. */
1705 BPF_LD_IMM64(R0
, 0xffffffffffffffffLL
),
1706 BPF_MOV64_REG(R1
, R0
),
1707 BPF_MOV64_REG(R2
, R1
),
1708 BPF_MOV64_REG(R3
, R2
),
1709 BPF_MOV64_REG(R4
, R3
),
1710 BPF_MOV64_REG(R5
, R4
),
1711 BPF_MOV64_REG(R6
, R5
),
1712 BPF_MOV64_REG(R7
, R6
),
1713 BPF_MOV64_REG(R8
, R7
),
1714 BPF_MOV64_REG(R9
, R8
),
1715 BPF_ALU64_IMM(BPF_MOV
, R0
, 0),
1716 BPF_ALU64_IMM(BPF_MOV
, R1
, 0),
1717 BPF_ALU64_IMM(BPF_MOV
, R2
, 0),
1718 BPF_ALU64_IMM(BPF_MOV
, R3
, 0),
1719 BPF_ALU64_IMM(BPF_MOV
, R4
, 0),
1720 BPF_ALU64_IMM(BPF_MOV
, R5
, 0),
1721 BPF_ALU64_IMM(BPF_MOV
, R6
, 0),
1722 BPF_ALU64_IMM(BPF_MOV
, R7
, 0),
1723 BPF_ALU64_IMM(BPF_MOV
, R8
, 0),
1724 BPF_ALU64_IMM(BPF_MOV
, R9
, 0),
1725 BPF_ALU64_REG(BPF_ADD
, R0
, R0
),
1726 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
1727 BPF_ALU64_REG(BPF_ADD
, R0
, R2
),
1728 BPF_ALU64_REG(BPF_ADD
, R0
, R3
),
1729 BPF_ALU64_REG(BPF_ADD
, R0
, R4
),
1730 BPF_ALU64_REG(BPF_ADD
, R0
, R5
),
1731 BPF_ALU64_REG(BPF_ADD
, R0
, R6
),
1732 BPF_ALU64_REG(BPF_ADD
, R0
, R7
),
1733 BPF_ALU64_REG(BPF_ADD
, R0
, R8
),
1734 BPF_ALU64_REG(BPF_ADD
, R0
, R9
),
1735 BPF_ALU64_IMM(BPF_ADD
, R0
, 0xfefe),
1742 { /* Mainly checking JIT here. */
1745 BPF_LD_IMM64(R0
, 0xffffffffffffffffLL
),
1746 BPF_MOV64_REG(R1
, R0
),
1747 BPF_MOV64_REG(R2
, R1
),
1748 BPF_MOV64_REG(R3
, R2
),
1749 BPF_MOV64_REG(R4
, R3
),
1750 BPF_MOV64_REG(R5
, R4
),
1751 BPF_MOV64_REG(R6
, R5
),
1752 BPF_MOV64_REG(R7
, R6
),
1753 BPF_MOV64_REG(R8
, R7
),
1754 BPF_MOV64_REG(R9
, R8
),
1755 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
1756 BPF_ALU32_IMM(BPF_MOV
, R1
, 0),
1757 BPF_ALU32_IMM(BPF_MOV
, R2
, 0),
1758 BPF_ALU32_IMM(BPF_MOV
, R3
, 0),
1759 BPF_ALU32_IMM(BPF_MOV
, R4
, 0),
1760 BPF_ALU32_IMM(BPF_MOV
, R5
, 0),
1761 BPF_ALU32_IMM(BPF_MOV
, R6
, 0),
1762 BPF_ALU32_IMM(BPF_MOV
, R7
, 0),
1763 BPF_ALU32_IMM(BPF_MOV
, R8
, 0),
1764 BPF_ALU32_IMM(BPF_MOV
, R9
, 0),
1765 BPF_ALU64_REG(BPF_ADD
, R0
, R0
),
1766 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
1767 BPF_ALU64_REG(BPF_ADD
, R0
, R2
),
1768 BPF_ALU64_REG(BPF_ADD
, R0
, R3
),
1769 BPF_ALU64_REG(BPF_ADD
, R0
, R4
),
1770 BPF_ALU64_REG(BPF_ADD
, R0
, R5
),
1771 BPF_ALU64_REG(BPF_ADD
, R0
, R6
),
1772 BPF_ALU64_REG(BPF_ADD
, R0
, R7
),
1773 BPF_ALU64_REG(BPF_ADD
, R0
, R8
),
1774 BPF_ALU64_REG(BPF_ADD
, R0
, R9
),
1775 BPF_ALU64_IMM(BPF_ADD
, R0
, 0xfefe),
1782 { /* Mainly checking JIT here. */
1785 BPF_LD_IMM64(R0
, 0xffffffffffffffffLL
),
1786 BPF_MOV64_REG(R1
, R0
),
1787 BPF_MOV64_REG(R2
, R1
),
1788 BPF_MOV64_REG(R3
, R2
),
1789 BPF_MOV64_REG(R4
, R3
),
1790 BPF_MOV64_REG(R5
, R4
),
1791 BPF_MOV64_REG(R6
, R5
),
1792 BPF_MOV64_REG(R7
, R6
),
1793 BPF_MOV64_REG(R8
, R7
),
1794 BPF_MOV64_REG(R9
, R8
),
1795 BPF_LD_IMM64(R0
, 0x0LL
),
1796 BPF_LD_IMM64(R1
, 0x0LL
),
1797 BPF_LD_IMM64(R2
, 0x0LL
),
1798 BPF_LD_IMM64(R3
, 0x0LL
),
1799 BPF_LD_IMM64(R4
, 0x0LL
),
1800 BPF_LD_IMM64(R5
, 0x0LL
),
1801 BPF_LD_IMM64(R6
, 0x0LL
),
1802 BPF_LD_IMM64(R7
, 0x0LL
),
1803 BPF_LD_IMM64(R8
, 0x0LL
),
1804 BPF_LD_IMM64(R9
, 0x0LL
),
1805 BPF_ALU64_REG(BPF_ADD
, R0
, R0
),
1806 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
1807 BPF_ALU64_REG(BPF_ADD
, R0
, R2
),
1808 BPF_ALU64_REG(BPF_ADD
, R0
, R3
),
1809 BPF_ALU64_REG(BPF_ADD
, R0
, R4
),
1810 BPF_ALU64_REG(BPF_ADD
, R0
, R5
),
1811 BPF_ALU64_REG(BPF_ADD
, R0
, R6
),
1812 BPF_ALU64_REG(BPF_ADD
, R0
, R7
),
1813 BPF_ALU64_REG(BPF_ADD
, R0
, R8
),
1814 BPF_ALU64_REG(BPF_ADD
, R0
, R9
),
1815 BPF_ALU64_IMM(BPF_ADD
, R0
, 0xfefe),
1825 BPF_ALU64_IMM(BPF_MOV
, R0
, 11),
1826 BPF_ALU64_IMM(BPF_ADD
, R0
, -1),
1827 BPF_ALU64_IMM(BPF_MOV
, R2
, 2),
1828 BPF_ALU64_IMM(BPF_XOR
, R2
, 3),
1829 BPF_ALU64_REG(BPF_DIV
, R0
, R2
),
1830 BPF_JMP_IMM(BPF_JEQ
, R0
, 10, 1),
1832 BPF_ALU64_IMM(BPF_MOD
, R0
, 3),
1833 BPF_JMP_IMM(BPF_JEQ
, R0
, 1, 1),
1835 BPF_ALU64_IMM(BPF_MOV
, R0
, -1),
1843 "INT: shifts by register",
1845 BPF_MOV64_IMM(R0
, -1234),
1846 BPF_MOV64_IMM(R1
, 1),
1847 BPF_ALU32_REG(BPF_RSH
, R0
, R1
),
1848 BPF_JMP_IMM(BPF_JEQ
, R0
, 0x7ffffd97, 1),
1850 BPF_MOV64_IMM(R2
, 1),
1851 BPF_ALU64_REG(BPF_LSH
, R0
, R2
),
1852 BPF_MOV32_IMM(R4
, -1234),
1853 BPF_JMP_REG(BPF_JEQ
, R0
, R4
, 1),
1855 BPF_ALU64_IMM(BPF_AND
, R4
, 63),
1856 BPF_ALU64_REG(BPF_LSH
, R0
, R4
), /* R0 <= 46 */
1857 BPF_MOV64_IMM(R3
, 47),
1858 BPF_ALU64_REG(BPF_ARSH
, R0
, R3
),
1859 BPF_JMP_IMM(BPF_JEQ
, R0
, -617, 1),
1861 BPF_MOV64_IMM(R2
, 1),
1862 BPF_ALU64_REG(BPF_LSH
, R4
, R2
), /* R4 = 46 << 1 */
1863 BPF_JMP_IMM(BPF_JEQ
, R4
, 92, 1),
1865 BPF_MOV64_IMM(R4
, 4),
1866 BPF_ALU64_REG(BPF_LSH
, R4
, R4
), /* R4 = 4 << 4 */
1867 BPF_JMP_IMM(BPF_JEQ
, R4
, 64, 1),
1869 BPF_MOV64_IMM(R4
, 5),
1870 BPF_ALU32_REG(BPF_LSH
, R4
, R4
), /* R4 = 5 << 5 */
1871 BPF_JMP_IMM(BPF_JEQ
, R4
, 160, 1),
1873 BPF_MOV64_IMM(R0
, -1),
1881 "check: missing ret",
1883 BPF_STMT(BPF_LD
| BPF_IMM
, 1),
1885 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
1888 .fill_helper
= NULL
,
1889 .expected_errcode
= -EINVAL
,
1894 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_K
, 0),
1895 BPF_STMT(BPF_RET
| BPF_K
, 0)
1897 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
1900 .fill_helper
= NULL
,
1901 .expected_errcode
= -EINVAL
,
1904 "check: unknown insn",
1906 /* seccomp insn, rejected in socket filter */
1907 BPF_STMT(BPF_LDX
| BPF_W
| BPF_ABS
, 0),
1908 BPF_STMT(BPF_RET
| BPF_K
, 0)
1910 CLASSIC
| FLAG_EXPECTED_FAIL
,
1913 .fill_helper
= NULL
,
1914 .expected_errcode
= -EINVAL
,
1917 "check: out of range spill/fill",
1919 BPF_STMT(BPF_STX
, 16),
1920 BPF_STMT(BPF_RET
| BPF_K
, 0)
1922 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
1925 .fill_helper
= NULL
,
1926 .expected_errcode
= -EINVAL
,
1931 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1932 BPF_JUMP(BPF_JMP
| BPF_JGE
, 0, 13, 15),
1933 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1934 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1935 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1936 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1937 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1938 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1939 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1940 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1941 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1942 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1943 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1944 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1945 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1946 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x90c2894d, 3, 4),
1947 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1948 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x90c2894d, 1, 2),
1949 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1950 BPF_JUMP(BPF_JMP
| BPF_JGE
, 0, 14, 15),
1951 BPF_JUMP(BPF_JMP
| BPF_JGE
, 0, 13, 14),
1952 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1953 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1954 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1955 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1956 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1957 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1958 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1959 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1960 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1961 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1962 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1963 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1964 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1965 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x2ac28349, 2, 3),
1966 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x2ac28349, 1, 2),
1967 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1968 BPF_JUMP(BPF_JMP
| BPF_JGE
, 0, 14, 15),
1969 BPF_JUMP(BPF_JMP
| BPF_JGE
, 0, 13, 14),
1970 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1971 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1972 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1973 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1974 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1975 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1976 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1977 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1978 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1979 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1980 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1981 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1982 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1983 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x90d2ff41, 2, 3),
1984 BPF_JUMP(BPF_JMP
| BPF_JEQ
, 0x90d2ff41, 1, 2),
1985 BPF_STMT(BPF_LD
| BPF_H
| BPF_ABS
, 0),
1986 BPF_STMT(BPF_RET
| BPF_A
, 0),
1987 BPF_STMT(BPF_RET
| BPF_A
, 0),
1990 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
1991 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
1993 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
1994 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
1995 0xc0, 0xa8, 0x33, 0x01,
1996 0xc0, 0xa8, 0x33, 0x02,
1999 0x00, 0x14, 0x00, 0x00,
2000 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2001 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2002 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2003 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2004 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2005 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2006 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2007 0xcc, 0xcc, 0xcc, 0xcc },
2013 BPF_STMT(BPF_RET
| BPF_X
, 0),
2015 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
2018 .fill_helper
= NULL
,
2019 .expected_errcode
= -EINVAL
,
2022 "check: LDX + RET X",
2024 BPF_STMT(BPF_LDX
| BPF_IMM
, 42),
2025 BPF_STMT(BPF_RET
| BPF_X
, 0),
2027 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
2030 .fill_helper
= NULL
,
2031 .expected_errcode
= -EINVAL
,
2033 { /* Mainly checking JIT here. */
2034 "M[]: alt STX + LDX",
2036 BPF_STMT(BPF_LDX
| BPF_IMM
, 100),
2037 BPF_STMT(BPF_STX
, 0),
2038 BPF_STMT(BPF_LDX
| BPF_MEM
, 0),
2039 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2040 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2041 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2042 BPF_STMT(BPF_STX
, 1),
2043 BPF_STMT(BPF_LDX
| BPF_MEM
, 1),
2044 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2045 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2046 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2047 BPF_STMT(BPF_STX
, 2),
2048 BPF_STMT(BPF_LDX
| BPF_MEM
, 2),
2049 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2050 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2051 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2052 BPF_STMT(BPF_STX
, 3),
2053 BPF_STMT(BPF_LDX
| BPF_MEM
, 3),
2054 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2055 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2056 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2057 BPF_STMT(BPF_STX
, 4),
2058 BPF_STMT(BPF_LDX
| BPF_MEM
, 4),
2059 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2060 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2061 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2062 BPF_STMT(BPF_STX
, 5),
2063 BPF_STMT(BPF_LDX
| BPF_MEM
, 5),
2064 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2065 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2066 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2067 BPF_STMT(BPF_STX
, 6),
2068 BPF_STMT(BPF_LDX
| BPF_MEM
, 6),
2069 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2070 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2071 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2072 BPF_STMT(BPF_STX
, 7),
2073 BPF_STMT(BPF_LDX
| BPF_MEM
, 7),
2074 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2075 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2076 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2077 BPF_STMT(BPF_STX
, 8),
2078 BPF_STMT(BPF_LDX
| BPF_MEM
, 8),
2079 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2080 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2081 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2082 BPF_STMT(BPF_STX
, 9),
2083 BPF_STMT(BPF_LDX
| BPF_MEM
, 9),
2084 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2085 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2086 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2087 BPF_STMT(BPF_STX
, 10),
2088 BPF_STMT(BPF_LDX
| BPF_MEM
, 10),
2089 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2090 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2091 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2092 BPF_STMT(BPF_STX
, 11),
2093 BPF_STMT(BPF_LDX
| BPF_MEM
, 11),
2094 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2095 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2096 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2097 BPF_STMT(BPF_STX
, 12),
2098 BPF_STMT(BPF_LDX
| BPF_MEM
, 12),
2099 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2100 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2101 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2102 BPF_STMT(BPF_STX
, 13),
2103 BPF_STMT(BPF_LDX
| BPF_MEM
, 13),
2104 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2105 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2106 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2107 BPF_STMT(BPF_STX
, 14),
2108 BPF_STMT(BPF_LDX
| BPF_MEM
, 14),
2109 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2110 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2111 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2112 BPF_STMT(BPF_STX
, 15),
2113 BPF_STMT(BPF_LDX
| BPF_MEM
, 15),
2114 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2115 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 1),
2116 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
2117 BPF_STMT(BPF_RET
| BPF_A
, 0),
2119 CLASSIC
| FLAG_NO_DATA
,
2123 { /* Mainly checking JIT here. */
2124 "M[]: full STX + full LDX",
2126 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xbadfeedb),
2127 BPF_STMT(BPF_STX
, 0),
2128 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xecabedae),
2129 BPF_STMT(BPF_STX
, 1),
2130 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xafccfeaf),
2131 BPF_STMT(BPF_STX
, 2),
2132 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xbffdcedc),
2133 BPF_STMT(BPF_STX
, 3),
2134 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xfbbbdccb),
2135 BPF_STMT(BPF_STX
, 4),
2136 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xfbabcbda),
2137 BPF_STMT(BPF_STX
, 5),
2138 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xaedecbdb),
2139 BPF_STMT(BPF_STX
, 6),
2140 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xadebbade),
2141 BPF_STMT(BPF_STX
, 7),
2142 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xfcfcfaec),
2143 BPF_STMT(BPF_STX
, 8),
2144 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xbcdddbdc),
2145 BPF_STMT(BPF_STX
, 9),
2146 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xfeefdfac),
2147 BPF_STMT(BPF_STX
, 10),
2148 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xcddcdeea),
2149 BPF_STMT(BPF_STX
, 11),
2150 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xaccfaebb),
2151 BPF_STMT(BPF_STX
, 12),
2152 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xbdcccdcf),
2153 BPF_STMT(BPF_STX
, 13),
2154 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xaaedecde),
2155 BPF_STMT(BPF_STX
, 14),
2156 BPF_STMT(BPF_LDX
| BPF_IMM
, 0xfaeacdad),
2157 BPF_STMT(BPF_STX
, 15),
2158 BPF_STMT(BPF_LDX
| BPF_MEM
, 0),
2159 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
2160 BPF_STMT(BPF_LDX
| BPF_MEM
, 1),
2161 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2162 BPF_STMT(BPF_LDX
| BPF_MEM
, 2),
2163 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2164 BPF_STMT(BPF_LDX
| BPF_MEM
, 3),
2165 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2166 BPF_STMT(BPF_LDX
| BPF_MEM
, 4),
2167 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2168 BPF_STMT(BPF_LDX
| BPF_MEM
, 5),
2169 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2170 BPF_STMT(BPF_LDX
| BPF_MEM
, 6),
2171 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2172 BPF_STMT(BPF_LDX
| BPF_MEM
, 7),
2173 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2174 BPF_STMT(BPF_LDX
| BPF_MEM
, 8),
2175 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2176 BPF_STMT(BPF_LDX
| BPF_MEM
, 9),
2177 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2178 BPF_STMT(BPF_LDX
| BPF_MEM
, 10),
2179 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2180 BPF_STMT(BPF_LDX
| BPF_MEM
, 11),
2181 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2182 BPF_STMT(BPF_LDX
| BPF_MEM
, 12),
2183 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2184 BPF_STMT(BPF_LDX
| BPF_MEM
, 13),
2185 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2186 BPF_STMT(BPF_LDX
| BPF_MEM
, 14),
2187 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2188 BPF_STMT(BPF_LDX
| BPF_MEM
, 15),
2189 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
2190 BPF_STMT(BPF_RET
| BPF_A
, 0),
2192 CLASSIC
| FLAG_NO_DATA
,
2194 { { 0, 0x2a5a5e5 } },
2197 "check: SKF_AD_MAX",
2199 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
2200 SKF_AD_OFF
+ SKF_AD_MAX
),
2201 BPF_STMT(BPF_RET
| BPF_A
, 0),
2203 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
2206 .fill_helper
= NULL
,
2207 .expected_errcode
= -EINVAL
,
2209 { /* Passes checker but fails during runtime. */
2210 "LD [SKF_AD_OFF-1]",
2212 BPF_STMT(BPF_LD
| BPF_W
| BPF_ABS
,
2214 BPF_STMT(BPF_RET
| BPF_K
, 1),
2221 "load 64-bit immediate",
2223 BPF_LD_IMM64(R1
, 0x567800001234LL
),
2224 BPF_MOV64_REG(R2
, R1
),
2225 BPF_MOV64_REG(R3
, R2
),
2226 BPF_ALU64_IMM(BPF_RSH
, R2
, 32),
2227 BPF_ALU64_IMM(BPF_LSH
, R3
, 32),
2228 BPF_ALU64_IMM(BPF_RSH
, R3
, 32),
2229 BPF_ALU64_IMM(BPF_MOV
, R0
, 0),
2230 BPF_JMP_IMM(BPF_JEQ
, R2
, 0x5678, 1),
2232 BPF_JMP_IMM(BPF_JEQ
, R3
, 0x1234, 1),
2234 BPF_LD_IMM64(R0
, 0x1ffffffffLL
),
2235 BPF_ALU64_IMM(BPF_RSH
, R0
, 32), /* R0 = 1 */
2242 /* BPF_ALU | BPF_MOV | BPF_X */
2244 "ALU_MOV_X: dst = 2",
2246 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
2247 BPF_ALU32_REG(BPF_MOV
, R0
, R1
),
2255 "ALU_MOV_X: dst = 4294967295",
2257 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967295U),
2258 BPF_ALU32_REG(BPF_MOV
, R0
, R1
),
2263 { { 0, 4294967295U } },
2266 "ALU64_MOV_X: dst = 2",
2268 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
2269 BPF_ALU64_REG(BPF_MOV
, R0
, R1
),
2277 "ALU64_MOV_X: dst = 4294967295",
2279 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967295U),
2280 BPF_ALU64_REG(BPF_MOV
, R0
, R1
),
2285 { { 0, 4294967295U } },
2287 /* BPF_ALU | BPF_MOV | BPF_K */
2289 "ALU_MOV_K: dst = 2",
2291 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
2299 "ALU_MOV_K: dst = 4294967295",
2301 BPF_ALU32_IMM(BPF_MOV
, R0
, 4294967295U),
2306 { { 0, 4294967295U } },
2309 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2311 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
2312 BPF_LD_IMM64(R3
, 0x00000000ffffffffLL
),
2313 BPF_ALU32_IMM(BPF_MOV
, R2
, 0xffffffff),
2314 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2315 BPF_MOV32_IMM(R0
, 2),
2317 BPF_MOV32_IMM(R0
, 1),
2325 "ALU64_MOV_K: dst = 2",
2327 BPF_ALU64_IMM(BPF_MOV
, R0
, 2),
2335 "ALU64_MOV_K: dst = 2147483647",
2337 BPF_ALU64_IMM(BPF_MOV
, R0
, 2147483647),
2342 { { 0, 2147483647 } },
2345 "ALU64_OR_K: dst = 0x0",
2347 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
2348 BPF_LD_IMM64(R3
, 0x0),
2349 BPF_ALU64_IMM(BPF_MOV
, R2
, 0x0),
2350 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2351 BPF_MOV32_IMM(R0
, 2),
2353 BPF_MOV32_IMM(R0
, 1),
2361 "ALU64_MOV_K: dst = -1",
2363 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
2364 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
2365 BPF_ALU64_IMM(BPF_MOV
, R2
, 0xffffffff),
2366 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2367 BPF_MOV32_IMM(R0
, 2),
2369 BPF_MOV32_IMM(R0
, 1),
2376 /* BPF_ALU | BPF_ADD | BPF_X */
2378 "ALU_ADD_X: 1 + 2 = 3",
2380 BPF_LD_IMM64(R0
, 1),
2381 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
2382 BPF_ALU32_REG(BPF_ADD
, R0
, R1
),
2390 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2392 BPF_LD_IMM64(R0
, 1),
2393 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967294U),
2394 BPF_ALU32_REG(BPF_ADD
, R0
, R1
),
2399 { { 0, 4294967295U } },
2402 "ALU_ADD_X: 2 + 4294967294 = 0",
2404 BPF_LD_IMM64(R0
, 2),
2405 BPF_LD_IMM64(R1
, 4294967294U),
2406 BPF_ALU32_REG(BPF_ADD
, R0
, R1
),
2407 BPF_JMP_IMM(BPF_JEQ
, R0
, 0, 2),
2408 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
2410 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
2418 "ALU64_ADD_X: 1 + 2 = 3",
2420 BPF_LD_IMM64(R0
, 1),
2421 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
2422 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
2430 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2432 BPF_LD_IMM64(R0
, 1),
2433 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967294U),
2434 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
2439 { { 0, 4294967295U } },
2442 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2444 BPF_LD_IMM64(R0
, 2),
2445 BPF_LD_IMM64(R1
, 4294967294U),
2446 BPF_LD_IMM64(R2
, 4294967296ULL),
2447 BPF_ALU64_REG(BPF_ADD
, R0
, R1
),
2448 BPF_JMP_REG(BPF_JEQ
, R0
, R2
, 2),
2449 BPF_MOV32_IMM(R0
, 0),
2451 BPF_MOV32_IMM(R0
, 1),
2458 /* BPF_ALU | BPF_ADD | BPF_K */
2460 "ALU_ADD_K: 1 + 2 = 3",
2462 BPF_LD_IMM64(R0
, 1),
2463 BPF_ALU32_IMM(BPF_ADD
, R0
, 2),
2471 "ALU_ADD_K: 3 + 0 = 3",
2473 BPF_LD_IMM64(R0
, 3),
2474 BPF_ALU32_IMM(BPF_ADD
, R0
, 0),
2482 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2484 BPF_LD_IMM64(R0
, 1),
2485 BPF_ALU32_IMM(BPF_ADD
, R0
, 4294967294U),
2490 { { 0, 4294967295U } },
2493 "ALU_ADD_K: 4294967294 + 2 = 0",
2495 BPF_LD_IMM64(R0
, 4294967294U),
2496 BPF_ALU32_IMM(BPF_ADD
, R0
, 2),
2497 BPF_JMP_IMM(BPF_JEQ
, R0
, 0, 2),
2498 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
2500 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
2508 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2510 BPF_LD_IMM64(R2
, 0x0),
2511 BPF_LD_IMM64(R3
, 0x00000000ffffffff),
2512 BPF_ALU32_IMM(BPF_ADD
, R2
, 0xffffffff),
2513 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2514 BPF_MOV32_IMM(R0
, 2),
2516 BPF_MOV32_IMM(R0
, 1),
2524 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2526 BPF_LD_IMM64(R2
, 0x0),
2527 BPF_LD_IMM64(R3
, 0xffff),
2528 BPF_ALU32_IMM(BPF_ADD
, R2
, 0xffff),
2529 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2530 BPF_MOV32_IMM(R0
, 2),
2532 BPF_MOV32_IMM(R0
, 1),
2540 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2542 BPF_LD_IMM64(R2
, 0x0),
2543 BPF_LD_IMM64(R3
, 0x7fffffff),
2544 BPF_ALU32_IMM(BPF_ADD
, R2
, 0x7fffffff),
2545 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2546 BPF_MOV32_IMM(R0
, 2),
2548 BPF_MOV32_IMM(R0
, 1),
2556 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2558 BPF_LD_IMM64(R2
, 0x0),
2559 BPF_LD_IMM64(R3
, 0x80000000),
2560 BPF_ALU32_IMM(BPF_ADD
, R2
, 0x80000000),
2561 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2562 BPF_MOV32_IMM(R0
, 2),
2564 BPF_MOV32_IMM(R0
, 1),
2572 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2574 BPF_LD_IMM64(R2
, 0x0),
2575 BPF_LD_IMM64(R3
, 0x80008000),
2576 BPF_ALU32_IMM(BPF_ADD
, R2
, 0x80008000),
2577 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2578 BPF_MOV32_IMM(R0
, 2),
2580 BPF_MOV32_IMM(R0
, 1),
2588 "ALU64_ADD_K: 1 + 2 = 3",
2590 BPF_LD_IMM64(R0
, 1),
2591 BPF_ALU64_IMM(BPF_ADD
, R0
, 2),
2599 "ALU64_ADD_K: 3 + 0 = 3",
2601 BPF_LD_IMM64(R0
, 3),
2602 BPF_ALU64_IMM(BPF_ADD
, R0
, 0),
2610 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2612 BPF_LD_IMM64(R0
, 1),
2613 BPF_ALU64_IMM(BPF_ADD
, R0
, 2147483646),
2618 { { 0, 2147483647 } },
2621 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2623 BPF_LD_IMM64(R0
, 4294967294U),
2624 BPF_LD_IMM64(R1
, 4294967296ULL),
2625 BPF_ALU64_IMM(BPF_ADD
, R0
, 2),
2626 BPF_JMP_REG(BPF_JEQ
, R0
, R1
, 2),
2627 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
2629 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
2637 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2639 BPF_LD_IMM64(R0
, 2147483646),
2640 BPF_ALU64_IMM(BPF_ADD
, R0
, -2147483647),
2648 "ALU64_ADD_K: 1 + 0 = 1",
2650 BPF_LD_IMM64(R2
, 0x1),
2651 BPF_LD_IMM64(R3
, 0x1),
2652 BPF_ALU64_IMM(BPF_ADD
, R2
, 0x0),
2653 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2654 BPF_MOV32_IMM(R0
, 2),
2656 BPF_MOV32_IMM(R0
, 1),
2664 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2666 BPF_LD_IMM64(R2
, 0x0),
2667 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
2668 BPF_ALU64_IMM(BPF_ADD
, R2
, 0xffffffff),
2669 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2670 BPF_MOV32_IMM(R0
, 2),
2672 BPF_MOV32_IMM(R0
, 1),
2680 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2682 BPF_LD_IMM64(R2
, 0x0),
2683 BPF_LD_IMM64(R3
, 0xffff),
2684 BPF_ALU64_IMM(BPF_ADD
, R2
, 0xffff),
2685 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2686 BPF_MOV32_IMM(R0
, 2),
2688 BPF_MOV32_IMM(R0
, 1),
2696 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2698 BPF_LD_IMM64(R2
, 0x0),
2699 BPF_LD_IMM64(R3
, 0x7fffffff),
2700 BPF_ALU64_IMM(BPF_ADD
, R2
, 0x7fffffff),
2701 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2702 BPF_MOV32_IMM(R0
, 2),
2704 BPF_MOV32_IMM(R0
, 1),
2712 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
2714 BPF_LD_IMM64(R2
, 0x0),
2715 BPF_LD_IMM64(R3
, 0xffffffff80000000LL
),
2716 BPF_ALU64_IMM(BPF_ADD
, R2
, 0x80000000),
2717 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2718 BPF_MOV32_IMM(R0
, 2),
2720 BPF_MOV32_IMM(R0
, 1),
2728 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
2730 BPF_LD_IMM64(R2
, 0x0),
2731 BPF_LD_IMM64(R3
, 0xffffffff80008000LL
),
2732 BPF_ALU64_IMM(BPF_ADD
, R2
, 0x80008000),
2733 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2734 BPF_MOV32_IMM(R0
, 2),
2736 BPF_MOV32_IMM(R0
, 1),
2743 /* BPF_ALU | BPF_SUB | BPF_X */
2745 "ALU_SUB_X: 3 - 1 = 2",
2747 BPF_LD_IMM64(R0
, 3),
2748 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
2749 BPF_ALU32_REG(BPF_SUB
, R0
, R1
),
2757 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2759 BPF_LD_IMM64(R0
, 4294967295U),
2760 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967294U),
2761 BPF_ALU32_REG(BPF_SUB
, R0
, R1
),
2769 "ALU64_SUB_X: 3 - 1 = 2",
2771 BPF_LD_IMM64(R0
, 3),
2772 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
2773 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
2781 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2783 BPF_LD_IMM64(R0
, 4294967295U),
2784 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967294U),
2785 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
2792 /* BPF_ALU | BPF_SUB | BPF_K */
2794 "ALU_SUB_K: 3 - 1 = 2",
2796 BPF_LD_IMM64(R0
, 3),
2797 BPF_ALU32_IMM(BPF_SUB
, R0
, 1),
2805 "ALU_SUB_K: 3 - 0 = 3",
2807 BPF_LD_IMM64(R0
, 3),
2808 BPF_ALU32_IMM(BPF_SUB
, R0
, 0),
2816 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
2818 BPF_LD_IMM64(R0
, 4294967295U),
2819 BPF_ALU32_IMM(BPF_SUB
, R0
, 4294967294U),
2827 "ALU64_SUB_K: 3 - 1 = 2",
2829 BPF_LD_IMM64(R0
, 3),
2830 BPF_ALU64_IMM(BPF_SUB
, R0
, 1),
2838 "ALU64_SUB_K: 3 - 0 = 3",
2840 BPF_LD_IMM64(R0
, 3),
2841 BPF_ALU64_IMM(BPF_SUB
, R0
, 0),
2849 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
2851 BPF_LD_IMM64(R0
, 4294967294U),
2852 BPF_ALU64_IMM(BPF_SUB
, R0
, 4294967295U),
2860 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
2862 BPF_LD_IMM64(R0
, 2147483646),
2863 BPF_ALU64_IMM(BPF_SUB
, R0
, 2147483647),
2870 /* BPF_ALU | BPF_MUL | BPF_X */
2872 "ALU_MUL_X: 2 * 3 = 6",
2874 BPF_LD_IMM64(R0
, 2),
2875 BPF_ALU32_IMM(BPF_MOV
, R1
, 3),
2876 BPF_ALU32_REG(BPF_MUL
, R0
, R1
),
2884 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2886 BPF_LD_IMM64(R0
, 2),
2887 BPF_ALU32_IMM(BPF_MOV
, R1
, 0x7FFFFFF8),
2888 BPF_ALU32_REG(BPF_MUL
, R0
, R1
),
2893 { { 0, 0xFFFFFFF0 } },
2896 "ALU_MUL_X: -1 * -1 = 1",
2898 BPF_LD_IMM64(R0
, -1),
2899 BPF_ALU32_IMM(BPF_MOV
, R1
, -1),
2900 BPF_ALU32_REG(BPF_MUL
, R0
, R1
),
2908 "ALU64_MUL_X: 2 * 3 = 6",
2910 BPF_LD_IMM64(R0
, 2),
2911 BPF_ALU32_IMM(BPF_MOV
, R1
, 3),
2912 BPF_ALU64_REG(BPF_MUL
, R0
, R1
),
2920 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
2922 BPF_LD_IMM64(R0
, 1),
2923 BPF_ALU32_IMM(BPF_MOV
, R1
, 2147483647),
2924 BPF_ALU64_REG(BPF_MUL
, R0
, R1
),
2929 { { 0, 2147483647 } },
2931 /* BPF_ALU | BPF_MUL | BPF_K */
2933 "ALU_MUL_K: 2 * 3 = 6",
2935 BPF_LD_IMM64(R0
, 2),
2936 BPF_ALU32_IMM(BPF_MUL
, R0
, 3),
2944 "ALU_MUL_K: 3 * 1 = 3",
2946 BPF_LD_IMM64(R0
, 3),
2947 BPF_ALU32_IMM(BPF_MUL
, R0
, 1),
2955 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2957 BPF_LD_IMM64(R0
, 2),
2958 BPF_ALU32_IMM(BPF_MUL
, R0
, 0x7FFFFFF8),
2963 { { 0, 0xFFFFFFF0 } },
2966 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
2968 BPF_LD_IMM64(R2
, 0x1),
2969 BPF_LD_IMM64(R3
, 0x00000000ffffffff),
2970 BPF_ALU32_IMM(BPF_MUL
, R2
, 0xffffffff),
2971 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
2972 BPF_MOV32_IMM(R0
, 2),
2974 BPF_MOV32_IMM(R0
, 1),
2982 "ALU64_MUL_K: 2 * 3 = 6",
2984 BPF_LD_IMM64(R0
, 2),
2985 BPF_ALU64_IMM(BPF_MUL
, R0
, 3),
2993 "ALU64_MUL_K: 3 * 1 = 3",
2995 BPF_LD_IMM64(R0
, 3),
2996 BPF_ALU64_IMM(BPF_MUL
, R0
, 1),
3004 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3006 BPF_LD_IMM64(R0
, 1),
3007 BPF_ALU64_IMM(BPF_MUL
, R0
, 2147483647),
3012 { { 0, 2147483647 } },
3015 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3017 BPF_LD_IMM64(R0
, 1),
3018 BPF_ALU64_IMM(BPF_MUL
, R0
, -2147483647),
3023 { { 0, -2147483647 } },
3026 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3028 BPF_LD_IMM64(R2
, 0x1),
3029 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
3030 BPF_ALU64_IMM(BPF_MUL
, R2
, 0xffffffff),
3031 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3032 BPF_MOV32_IMM(R0
, 2),
3034 BPF_MOV32_IMM(R0
, 1),
3041 /* BPF_ALU | BPF_DIV | BPF_X */
3043 "ALU_DIV_X: 6 / 2 = 3",
3045 BPF_LD_IMM64(R0
, 6),
3046 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3047 BPF_ALU32_REG(BPF_DIV
, R0
, R1
),
3055 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3057 BPF_LD_IMM64(R0
, 4294967295U),
3058 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967295U),
3059 BPF_ALU32_REG(BPF_DIV
, R0
, R1
),
3067 "ALU64_DIV_X: 6 / 2 = 3",
3069 BPF_LD_IMM64(R0
, 6),
3070 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3071 BPF_ALU64_REG(BPF_DIV
, R0
, R1
),
3079 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3081 BPF_LD_IMM64(R0
, 2147483647),
3082 BPF_ALU32_IMM(BPF_MOV
, R1
, 2147483647),
3083 BPF_ALU64_REG(BPF_DIV
, R0
, R1
),
3091 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3093 BPF_LD_IMM64(R2
, 0xffffffffffffffffLL
),
3094 BPF_LD_IMM64(R4
, 0xffffffffffffffffLL
),
3095 BPF_LD_IMM64(R3
, 0x0000000000000001LL
),
3096 BPF_ALU64_REG(BPF_DIV
, R2
, R4
),
3097 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3098 BPF_MOV32_IMM(R0
, 2),
3100 BPF_MOV32_IMM(R0
, 1),
3107 /* BPF_ALU | BPF_DIV | BPF_K */
3109 "ALU_DIV_K: 6 / 2 = 3",
3111 BPF_LD_IMM64(R0
, 6),
3112 BPF_ALU32_IMM(BPF_DIV
, R0
, 2),
3120 "ALU_DIV_K: 3 / 1 = 3",
3122 BPF_LD_IMM64(R0
, 3),
3123 BPF_ALU32_IMM(BPF_DIV
, R0
, 1),
3131 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3133 BPF_LD_IMM64(R0
, 4294967295U),
3134 BPF_ALU32_IMM(BPF_DIV
, R0
, 4294967295U),
3142 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3144 BPF_LD_IMM64(R2
, 0xffffffffffffffffLL
),
3145 BPF_LD_IMM64(R3
, 0x1UL
),
3146 BPF_ALU32_IMM(BPF_DIV
, R2
, 0xffffffff),
3147 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3148 BPF_MOV32_IMM(R0
, 2),
3150 BPF_MOV32_IMM(R0
, 1),
3158 "ALU64_DIV_K: 6 / 2 = 3",
3160 BPF_LD_IMM64(R0
, 6),
3161 BPF_ALU64_IMM(BPF_DIV
, R0
, 2),
3169 "ALU64_DIV_K: 3 / 1 = 3",
3171 BPF_LD_IMM64(R0
, 3),
3172 BPF_ALU64_IMM(BPF_DIV
, R0
, 1),
3180 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3182 BPF_LD_IMM64(R0
, 2147483647),
3183 BPF_ALU64_IMM(BPF_DIV
, R0
, 2147483647),
3191 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3193 BPF_LD_IMM64(R2
, 0xffffffffffffffffLL
),
3194 BPF_LD_IMM64(R3
, 0x0000000000000001LL
),
3195 BPF_ALU64_IMM(BPF_DIV
, R2
, 0xffffffff),
3196 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3197 BPF_MOV32_IMM(R0
, 2),
3199 BPF_MOV32_IMM(R0
, 1),
3206 /* BPF_ALU | BPF_MOD | BPF_X */
3208 "ALU_MOD_X: 3 % 2 = 1",
3210 BPF_LD_IMM64(R0
, 3),
3211 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3212 BPF_ALU32_REG(BPF_MOD
, R0
, R1
),
3220 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3222 BPF_LD_IMM64(R0
, 4294967295U),
3223 BPF_ALU32_IMM(BPF_MOV
, R1
, 4294967293U),
3224 BPF_ALU32_REG(BPF_MOD
, R0
, R1
),
3232 "ALU64_MOD_X: 3 % 2 = 1",
3234 BPF_LD_IMM64(R0
, 3),
3235 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3236 BPF_ALU64_REG(BPF_MOD
, R0
, R1
),
3244 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3246 BPF_LD_IMM64(R0
, 2147483647),
3247 BPF_ALU32_IMM(BPF_MOV
, R1
, 2147483645),
3248 BPF_ALU64_REG(BPF_MOD
, R0
, R1
),
3255 /* BPF_ALU | BPF_MOD | BPF_K */
3257 "ALU_MOD_K: 3 % 2 = 1",
3259 BPF_LD_IMM64(R0
, 3),
3260 BPF_ALU32_IMM(BPF_MOD
, R0
, 2),
3268 "ALU_MOD_K: 3 % 1 = 0",
3270 BPF_LD_IMM64(R0
, 3),
3271 BPF_ALU32_IMM(BPF_MOD
, R0
, 1),
3279 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3281 BPF_LD_IMM64(R0
, 4294967295U),
3282 BPF_ALU32_IMM(BPF_MOD
, R0
, 4294967293U),
3290 "ALU64_MOD_K: 3 % 2 = 1",
3292 BPF_LD_IMM64(R0
, 3),
3293 BPF_ALU64_IMM(BPF_MOD
, R0
, 2),
3301 "ALU64_MOD_K: 3 % 1 = 0",
3303 BPF_LD_IMM64(R0
, 3),
3304 BPF_ALU64_IMM(BPF_MOD
, R0
, 1),
3312 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3314 BPF_LD_IMM64(R0
, 2147483647),
3315 BPF_ALU64_IMM(BPF_MOD
, R0
, 2147483645),
3322 /* BPF_ALU | BPF_AND | BPF_X */
3324 "ALU_AND_X: 3 & 2 = 2",
3326 BPF_LD_IMM64(R0
, 3),
3327 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3328 BPF_ALU32_REG(BPF_AND
, R0
, R1
),
3336 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3338 BPF_LD_IMM64(R0
, 0xffffffff),
3339 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3340 BPF_ALU32_REG(BPF_AND
, R0
, R1
),
3345 { { 0, 0xffffffff } },
3348 "ALU64_AND_X: 3 & 2 = 2",
3350 BPF_LD_IMM64(R0
, 3),
3351 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3352 BPF_ALU64_REG(BPF_AND
, R0
, R1
),
3360 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3362 BPF_LD_IMM64(R0
, 0xffffffff),
3363 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3364 BPF_ALU64_REG(BPF_AND
, R0
, R1
),
3369 { { 0, 0xffffffff } },
3371 /* BPF_ALU | BPF_AND | BPF_K */
3373 "ALU_AND_K: 3 & 2 = 2",
3375 BPF_LD_IMM64(R0
, 3),
3376 BPF_ALU32_IMM(BPF_AND
, R0
, 2),
3384 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3386 BPF_LD_IMM64(R0
, 0xffffffff),
3387 BPF_ALU32_IMM(BPF_AND
, R0
, 0xffffffff),
3392 { { 0, 0xffffffff } },
3395 "ALU64_AND_K: 3 & 2 = 2",
3397 BPF_LD_IMM64(R0
, 3),
3398 BPF_ALU64_IMM(BPF_AND
, R0
, 2),
3406 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3408 BPF_LD_IMM64(R0
, 0xffffffff),
3409 BPF_ALU64_IMM(BPF_AND
, R0
, 0xffffffff),
3414 { { 0, 0xffffffff } },
3417 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3419 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3420 BPF_LD_IMM64(R3
, 0x0000000000000000LL
),
3421 BPF_ALU64_IMM(BPF_AND
, R2
, 0x0),
3422 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3423 BPF_MOV32_IMM(R0
, 2),
3425 BPF_MOV32_IMM(R0
, 1),
3433 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3435 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3436 BPF_LD_IMM64(R3
, 0x0000ffffffff0000LL
),
3437 BPF_ALU64_IMM(BPF_AND
, R2
, 0xffffffff),
3438 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3439 BPF_MOV32_IMM(R0
, 2),
3441 BPF_MOV32_IMM(R0
, 1),
3449 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3451 BPF_LD_IMM64(R2
, 0xffffffffffffffffLL
),
3452 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
3453 BPF_ALU64_IMM(BPF_AND
, R2
, 0xffffffff),
3454 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3455 BPF_MOV32_IMM(R0
, 2),
3457 BPF_MOV32_IMM(R0
, 1),
3464 /* BPF_ALU | BPF_OR | BPF_X */
3466 "ALU_OR_X: 1 | 2 = 3",
3468 BPF_LD_IMM64(R0
, 1),
3469 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3470 BPF_ALU32_REG(BPF_OR
, R0
, R1
),
3478 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3480 BPF_LD_IMM64(R0
, 0),
3481 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3482 BPF_ALU32_REG(BPF_OR
, R0
, R1
),
3487 { { 0, 0xffffffff } },
3490 "ALU64_OR_X: 1 | 2 = 3",
3492 BPF_LD_IMM64(R0
, 1),
3493 BPF_ALU32_IMM(BPF_MOV
, R1
, 2),
3494 BPF_ALU64_REG(BPF_OR
, R0
, R1
),
3502 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3504 BPF_LD_IMM64(R0
, 0),
3505 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3506 BPF_ALU64_REG(BPF_OR
, R0
, R1
),
3511 { { 0, 0xffffffff } },
3513 /* BPF_ALU | BPF_OR | BPF_K */
3515 "ALU_OR_K: 1 | 2 = 3",
3517 BPF_LD_IMM64(R0
, 1),
3518 BPF_ALU32_IMM(BPF_OR
, R0
, 2),
3526 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3528 BPF_LD_IMM64(R0
, 0),
3529 BPF_ALU32_IMM(BPF_OR
, R0
, 0xffffffff),
3534 { { 0, 0xffffffff } },
3537 "ALU64_OR_K: 1 | 2 = 3",
3539 BPF_LD_IMM64(R0
, 1),
3540 BPF_ALU64_IMM(BPF_OR
, R0
, 2),
3548 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3550 BPF_LD_IMM64(R0
, 0),
3551 BPF_ALU64_IMM(BPF_OR
, R0
, 0xffffffff),
3556 { { 0, 0xffffffff } },
3559 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3561 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3562 BPF_LD_IMM64(R3
, 0x0000ffffffff0000LL
),
3563 BPF_ALU64_IMM(BPF_OR
, R2
, 0x0),
3564 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3565 BPF_MOV32_IMM(R0
, 2),
3567 BPF_MOV32_IMM(R0
, 1),
3575 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3577 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3578 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
3579 BPF_ALU64_IMM(BPF_OR
, R2
, 0xffffffff),
3580 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3581 BPF_MOV32_IMM(R0
, 2),
3583 BPF_MOV32_IMM(R0
, 1),
3591 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3593 BPF_LD_IMM64(R2
, 0x0000000000000000LL
),
3594 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
3595 BPF_ALU64_IMM(BPF_OR
, R2
, 0xffffffff),
3596 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3597 BPF_MOV32_IMM(R0
, 2),
3599 BPF_MOV32_IMM(R0
, 1),
3606 /* BPF_ALU | BPF_XOR | BPF_X */
3608 "ALU_XOR_X: 5 ^ 6 = 3",
3610 BPF_LD_IMM64(R0
, 5),
3611 BPF_ALU32_IMM(BPF_MOV
, R1
, 6),
3612 BPF_ALU32_REG(BPF_XOR
, R0
, R1
),
3620 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3622 BPF_LD_IMM64(R0
, 1),
3623 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3624 BPF_ALU32_REG(BPF_XOR
, R0
, R1
),
3629 { { 0, 0xfffffffe } },
3632 "ALU64_XOR_X: 5 ^ 6 = 3",
3634 BPF_LD_IMM64(R0
, 5),
3635 BPF_ALU32_IMM(BPF_MOV
, R1
, 6),
3636 BPF_ALU64_REG(BPF_XOR
, R0
, R1
),
3644 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3646 BPF_LD_IMM64(R0
, 1),
3647 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xffffffff),
3648 BPF_ALU64_REG(BPF_XOR
, R0
, R1
),
3653 { { 0, 0xfffffffe } },
3655 /* BPF_ALU | BPF_XOR | BPF_K */
3657 "ALU_XOR_K: 5 ^ 6 = 3",
3659 BPF_LD_IMM64(R0
, 5),
3660 BPF_ALU32_IMM(BPF_XOR
, R0
, 6),
3668 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3670 BPF_LD_IMM64(R0
, 1),
3671 BPF_ALU32_IMM(BPF_XOR
, R0
, 0xffffffff),
3676 { { 0, 0xfffffffe } },
3679 "ALU64_XOR_K: 5 ^ 6 = 3",
3681 BPF_LD_IMM64(R0
, 5),
3682 BPF_ALU64_IMM(BPF_XOR
, R0
, 6),
3690 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3692 BPF_LD_IMM64(R0
, 1),
3693 BPF_ALU64_IMM(BPF_XOR
, R0
, 0xffffffff),
3698 { { 0, 0xfffffffe } },
3701 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3703 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3704 BPF_LD_IMM64(R3
, 0x0000ffffffff0000LL
),
3705 BPF_ALU64_IMM(BPF_XOR
, R2
, 0x0),
3706 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3707 BPF_MOV32_IMM(R0
, 2),
3709 BPF_MOV32_IMM(R0
, 1),
3717 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3719 BPF_LD_IMM64(R2
, 0x0000ffffffff0000LL
),
3720 BPF_LD_IMM64(R3
, 0xffff00000000ffffLL
),
3721 BPF_ALU64_IMM(BPF_XOR
, R2
, 0xffffffff),
3722 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3723 BPF_MOV32_IMM(R0
, 2),
3725 BPF_MOV32_IMM(R0
, 1),
3733 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3735 BPF_LD_IMM64(R2
, 0x0000000000000000LL
),
3736 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
3737 BPF_ALU64_IMM(BPF_XOR
, R2
, 0xffffffff),
3738 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
3739 BPF_MOV32_IMM(R0
, 2),
3741 BPF_MOV32_IMM(R0
, 1),
3748 /* BPF_ALU | BPF_LSH | BPF_X */
3750 "ALU_LSH_X: 1 << 1 = 2",
3752 BPF_LD_IMM64(R0
, 1),
3753 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
3754 BPF_ALU32_REG(BPF_LSH
, R0
, R1
),
3762 "ALU_LSH_X: 1 << 31 = 0x80000000",
3764 BPF_LD_IMM64(R0
, 1),
3765 BPF_ALU32_IMM(BPF_MOV
, R1
, 31),
3766 BPF_ALU32_REG(BPF_LSH
, R0
, R1
),
3771 { { 0, 0x80000000 } },
3774 "ALU64_LSH_X: 1 << 1 = 2",
3776 BPF_LD_IMM64(R0
, 1),
3777 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
3778 BPF_ALU64_REG(BPF_LSH
, R0
, R1
),
3786 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3788 BPF_LD_IMM64(R0
, 1),
3789 BPF_ALU32_IMM(BPF_MOV
, R1
, 31),
3790 BPF_ALU64_REG(BPF_LSH
, R0
, R1
),
3795 { { 0, 0x80000000 } },
3797 /* BPF_ALU | BPF_LSH | BPF_K */
3799 "ALU_LSH_K: 1 << 1 = 2",
3801 BPF_LD_IMM64(R0
, 1),
3802 BPF_ALU32_IMM(BPF_LSH
, R0
, 1),
3810 "ALU_LSH_K: 1 << 31 = 0x80000000",
3812 BPF_LD_IMM64(R0
, 1),
3813 BPF_ALU32_IMM(BPF_LSH
, R0
, 31),
3818 { { 0, 0x80000000 } },
3821 "ALU64_LSH_K: 1 << 1 = 2",
3823 BPF_LD_IMM64(R0
, 1),
3824 BPF_ALU64_IMM(BPF_LSH
, R0
, 1),
3832 "ALU64_LSH_K: 1 << 31 = 0x80000000",
3834 BPF_LD_IMM64(R0
, 1),
3835 BPF_ALU64_IMM(BPF_LSH
, R0
, 31),
3840 { { 0, 0x80000000 } },
3842 /* BPF_ALU | BPF_RSH | BPF_X */
3844 "ALU_RSH_X: 2 >> 1 = 1",
3846 BPF_LD_IMM64(R0
, 2),
3847 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
3848 BPF_ALU32_REG(BPF_RSH
, R0
, R1
),
3856 "ALU_RSH_X: 0x80000000 >> 31 = 1",
3858 BPF_LD_IMM64(R0
, 0x80000000),
3859 BPF_ALU32_IMM(BPF_MOV
, R1
, 31),
3860 BPF_ALU32_REG(BPF_RSH
, R0
, R1
),
3868 "ALU64_RSH_X: 2 >> 1 = 1",
3870 BPF_LD_IMM64(R0
, 2),
3871 BPF_ALU32_IMM(BPF_MOV
, R1
, 1),
3872 BPF_ALU64_REG(BPF_RSH
, R0
, R1
),
3880 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
3882 BPF_LD_IMM64(R0
, 0x80000000),
3883 BPF_ALU32_IMM(BPF_MOV
, R1
, 31),
3884 BPF_ALU64_REG(BPF_RSH
, R0
, R1
),
3891 /* BPF_ALU | BPF_RSH | BPF_K */
3893 "ALU_RSH_K: 2 >> 1 = 1",
3895 BPF_LD_IMM64(R0
, 2),
3896 BPF_ALU32_IMM(BPF_RSH
, R0
, 1),
3904 "ALU_RSH_K: 0x80000000 >> 31 = 1",
3906 BPF_LD_IMM64(R0
, 0x80000000),
3907 BPF_ALU32_IMM(BPF_RSH
, R0
, 31),
3915 "ALU64_RSH_K: 2 >> 1 = 1",
3917 BPF_LD_IMM64(R0
, 2),
3918 BPF_ALU64_IMM(BPF_RSH
, R0
, 1),
3926 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
3928 BPF_LD_IMM64(R0
, 0x80000000),
3929 BPF_ALU64_IMM(BPF_RSH
, R0
, 31),
3936 /* BPF_ALU | BPF_ARSH | BPF_X */
3938 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3940 BPF_LD_IMM64(R0
, 0xff00ff0000000000LL
),
3941 BPF_ALU32_IMM(BPF_MOV
, R1
, 40),
3942 BPF_ALU64_REG(BPF_ARSH
, R0
, R1
),
3947 { { 0, 0xffff00ff } },
3949 /* BPF_ALU | BPF_ARSH | BPF_K */
3951 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3953 BPF_LD_IMM64(R0
, 0xff00ff0000000000LL
),
3954 BPF_ALU64_IMM(BPF_ARSH
, R0
, 40),
3959 { { 0, 0xffff00ff } },
3961 /* BPF_ALU | BPF_NEG */
3963 "ALU_NEG: -(3) = -3",
3965 BPF_ALU32_IMM(BPF_MOV
, R0
, 3),
3966 BPF_ALU32_IMM(BPF_NEG
, R0
, 0),
3974 "ALU_NEG: -(-3) = 3",
3976 BPF_ALU32_IMM(BPF_MOV
, R0
, -3),
3977 BPF_ALU32_IMM(BPF_NEG
, R0
, 0),
3985 "ALU64_NEG: -(3) = -3",
3987 BPF_LD_IMM64(R0
, 3),
3988 BPF_ALU64_IMM(BPF_NEG
, R0
, 0),
3996 "ALU64_NEG: -(-3) = 3",
3998 BPF_LD_IMM64(R0
, -3),
3999 BPF_ALU64_IMM(BPF_NEG
, R0
, 0),
4006 /* BPF_ALU | BPF_END | BPF_FROM_BE */
4008 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
4010 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4011 BPF_ENDIAN(BPF_FROM_BE
, R0
, 16),
4016 { { 0, cpu_to_be16(0xcdef) } },
4019 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
4021 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4022 BPF_ENDIAN(BPF_FROM_BE
, R0
, 32),
4023 BPF_ALU64_REG(BPF_MOV
, R1
, R0
),
4024 BPF_ALU64_IMM(BPF_RSH
, R1
, 32),
4025 BPF_ALU32_REG(BPF_ADD
, R0
, R1
), /* R1 = 0 */
4030 { { 0, cpu_to_be32(0x89abcdef) } },
4033 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
4035 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4036 BPF_ENDIAN(BPF_FROM_BE
, R0
, 64),
4041 { { 0, (u32
) cpu_to_be64(0x0123456789abcdefLL
) } },
4043 /* BPF_ALU | BPF_END | BPF_FROM_LE */
4045 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
4047 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4048 BPF_ENDIAN(BPF_FROM_LE
, R0
, 16),
4053 { { 0, cpu_to_le16(0xcdef) } },
4056 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
4058 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4059 BPF_ENDIAN(BPF_FROM_LE
, R0
, 32),
4060 BPF_ALU64_REG(BPF_MOV
, R1
, R0
),
4061 BPF_ALU64_IMM(BPF_RSH
, R1
, 32),
4062 BPF_ALU32_REG(BPF_ADD
, R0
, R1
), /* R1 = 0 */
4067 { { 0, cpu_to_le32(0x89abcdef) } },
4070 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
4072 BPF_LD_IMM64(R0
, 0x0123456789abcdefLL
),
4073 BPF_ENDIAN(BPF_FROM_LE
, R0
, 64),
4078 { { 0, (u32
) cpu_to_le64(0x0123456789abcdefLL
) } },
4080 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
4082 "ST_MEM_B: Store/Load byte: max negative",
4084 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4085 BPF_ST_MEM(BPF_B
, R10
, -40, 0xff),
4086 BPF_LDX_MEM(BPF_B
, R0
, R10
, -40),
4095 "ST_MEM_B: Store/Load byte: max positive",
4097 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4098 BPF_ST_MEM(BPF_H
, R10
, -40, 0x7f),
4099 BPF_LDX_MEM(BPF_H
, R0
, R10
, -40),
4108 "STX_MEM_B: Store/Load byte: max negative",
4110 BPF_LD_IMM64(R0
, 0),
4111 BPF_LD_IMM64(R1
, 0xffLL
),
4112 BPF_STX_MEM(BPF_B
, R10
, R1
, -40),
4113 BPF_LDX_MEM(BPF_B
, R0
, R10
, -40),
4122 "ST_MEM_H: Store/Load half word: max negative",
4124 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4125 BPF_ST_MEM(BPF_H
, R10
, -40, 0xffff),
4126 BPF_LDX_MEM(BPF_H
, R0
, R10
, -40),
4135 "ST_MEM_H: Store/Load half word: max positive",
4137 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4138 BPF_ST_MEM(BPF_H
, R10
, -40, 0x7fff),
4139 BPF_LDX_MEM(BPF_H
, R0
, R10
, -40),
4148 "STX_MEM_H: Store/Load half word: max negative",
4150 BPF_LD_IMM64(R0
, 0),
4151 BPF_LD_IMM64(R1
, 0xffffLL
),
4152 BPF_STX_MEM(BPF_H
, R10
, R1
, -40),
4153 BPF_LDX_MEM(BPF_H
, R0
, R10
, -40),
4162 "ST_MEM_W: Store/Load word: max negative",
4164 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4165 BPF_ST_MEM(BPF_W
, R10
, -40, 0xffffffff),
4166 BPF_LDX_MEM(BPF_W
, R0
, R10
, -40),
4171 { { 0, 0xffffffff } },
4175 "ST_MEM_W: Store/Load word: max positive",
4177 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4178 BPF_ST_MEM(BPF_W
, R10
, -40, 0x7fffffff),
4179 BPF_LDX_MEM(BPF_W
, R0
, R10
, -40),
4184 { { 0, 0x7fffffff } },
4188 "STX_MEM_W: Store/Load word: max negative",
4190 BPF_LD_IMM64(R0
, 0),
4191 BPF_LD_IMM64(R1
, 0xffffffffLL
),
4192 BPF_STX_MEM(BPF_W
, R10
, R1
, -40),
4193 BPF_LDX_MEM(BPF_W
, R0
, R10
, -40),
4198 { { 0, 0xffffffff } },
4202 "ST_MEM_DW: Store/Load double word: max negative",
4204 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4205 BPF_ST_MEM(BPF_DW
, R10
, -40, 0xffffffff),
4206 BPF_LDX_MEM(BPF_DW
, R0
, R10
, -40),
4211 { { 0, 0xffffffff } },
4215 "ST_MEM_DW: Store/Load double word: max negative 2",
4217 BPF_LD_IMM64(R2
, 0xffff00000000ffffLL
),
4218 BPF_LD_IMM64(R3
, 0xffffffffffffffffLL
),
4219 BPF_ST_MEM(BPF_DW
, R10
, -40, 0xffffffff),
4220 BPF_LDX_MEM(BPF_DW
, R2
, R10
, -40),
4221 BPF_JMP_REG(BPF_JEQ
, R2
, R3
, 2),
4222 BPF_MOV32_IMM(R0
, 2),
4224 BPF_MOV32_IMM(R0
, 1),
4233 "ST_MEM_DW: Store/Load double word: max positive",
4235 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4236 BPF_ST_MEM(BPF_DW
, R10
, -40, 0x7fffffff),
4237 BPF_LDX_MEM(BPF_DW
, R0
, R10
, -40),
4242 { { 0, 0x7fffffff } },
4246 "STX_MEM_DW: Store/Load double word: max negative",
4248 BPF_LD_IMM64(R0
, 0),
4249 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4250 BPF_STX_MEM(BPF_W
, R10
, R1
, -40),
4251 BPF_LDX_MEM(BPF_W
, R0
, R10
, -40),
4256 { { 0, 0xffffffff } },
4259 /* BPF_STX | BPF_XADD | BPF_W/DW */
4261 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
4263 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4264 BPF_ST_MEM(BPF_W
, R10
, -40, 0x10),
4265 BPF_STX_XADD(BPF_W
, R10
, R0
, -40),
4266 BPF_LDX_MEM(BPF_W
, R0
, R10
, -40),
4275 "STX_XADD_W: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4277 BPF_ALU64_REG(BPF_MOV
, R1
, R10
),
4278 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4279 BPF_ST_MEM(BPF_W
, R10
, -40, 0x10),
4280 BPF_STX_XADD(BPF_W
, R10
, R0
, -40),
4281 BPF_ALU64_REG(BPF_MOV
, R0
, R10
),
4282 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
4291 "STX_XADD_W: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4293 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4294 BPF_ST_MEM(BPF_W
, R10
, -40, 0x10),
4295 BPF_STX_XADD(BPF_W
, R10
, R0
, -40),
4304 "STX_XADD_W: X + 1 + 1 + 1 + ...",
4309 .fill_helper
= bpf_fill_stxw
,
4312 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
4314 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4315 BPF_ST_MEM(BPF_DW
, R10
, -40, 0x10),
4316 BPF_STX_XADD(BPF_DW
, R10
, R0
, -40),
4317 BPF_LDX_MEM(BPF_DW
, R0
, R10
, -40),
4326 "STX_XADD_DW: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4328 BPF_ALU64_REG(BPF_MOV
, R1
, R10
),
4329 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4330 BPF_ST_MEM(BPF_DW
, R10
, -40, 0x10),
4331 BPF_STX_XADD(BPF_DW
, R10
, R0
, -40),
4332 BPF_ALU64_REG(BPF_MOV
, R0
, R10
),
4333 BPF_ALU64_REG(BPF_SUB
, R0
, R1
),
4342 "STX_XADD_DW: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4344 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x12),
4345 BPF_ST_MEM(BPF_DW
, R10
, -40, 0x10),
4346 BPF_STX_XADD(BPF_DW
, R10
, R0
, -40),
4355 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
4360 .fill_helper
= bpf_fill_stxdw
,
4362 /* BPF_JMP | BPF_EXIT */
4366 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x4711),
4368 BPF_ALU32_IMM(BPF_MOV
, R0
, 0x4712),
4374 /* BPF_JMP | BPF_JA */
4376 "JMP_JA: Unconditional jump: if (true) return 1",
4378 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4379 BPF_JMP_IMM(BPF_JA
, 0, 0, 1),
4381 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4388 /* BPF_JMP | BPF_JSLT | BPF_K */
4390 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
4392 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4393 BPF_LD_IMM64(R1
, 0xfffffffffffffffeLL
),
4394 BPF_JMP_IMM(BPF_JSLT
, R1
, -1, 1),
4396 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4404 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
4406 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4407 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4408 BPF_JMP_IMM(BPF_JSLT
, R1
, -1, 1),
4410 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4417 /* BPF_JMP | BPF_JSGT | BPF_K */
4419 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4421 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4422 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4423 BPF_JMP_IMM(BPF_JSGT
, R1
, -2, 1),
4425 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4433 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4435 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4436 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4437 BPF_JMP_IMM(BPF_JSGT
, R1
, -1, 1),
4439 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4446 /* BPF_JMP | BPF_JSLE | BPF_K */
4448 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
4450 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4451 BPF_LD_IMM64(R1
, 0xfffffffffffffffeLL
),
4452 BPF_JMP_IMM(BPF_JSLE
, R1
, -1, 1),
4454 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4462 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
4464 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4465 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4466 BPF_JMP_IMM(BPF_JSLE
, R1
, -1, 1),
4468 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4476 "JMP_JSLE_K: Signed jump: value walk 1",
4478 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4479 BPF_LD_IMM64(R1
, 3),
4480 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 6),
4481 BPF_ALU64_IMM(BPF_SUB
, R1
, 1),
4482 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 4),
4483 BPF_ALU64_IMM(BPF_SUB
, R1
, 1),
4484 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 2),
4485 BPF_ALU64_IMM(BPF_SUB
, R1
, 1),
4486 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 1),
4487 BPF_EXIT_INSN(), /* bad exit */
4488 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* good exit */
4496 "JMP_JSLE_K: Signed jump: value walk 2",
4498 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4499 BPF_LD_IMM64(R1
, 3),
4500 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 4),
4501 BPF_ALU64_IMM(BPF_SUB
, R1
, 2),
4502 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 2),
4503 BPF_ALU64_IMM(BPF_SUB
, R1
, 2),
4504 BPF_JMP_IMM(BPF_JSLE
, R1
, 0, 1),
4505 BPF_EXIT_INSN(), /* bad exit */
4506 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* good exit */
4513 /* BPF_JMP | BPF_JSGE | BPF_K */
4515 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4517 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4518 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4519 BPF_JMP_IMM(BPF_JSGE
, R1
, -2, 1),
4521 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4529 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4531 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4532 BPF_LD_IMM64(R1
, 0xffffffffffffffffLL
),
4533 BPF_JMP_IMM(BPF_JSGE
, R1
, -1, 1),
4535 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4543 "JMP_JSGE_K: Signed jump: value walk 1",
4545 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4546 BPF_LD_IMM64(R1
, -3),
4547 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 6),
4548 BPF_ALU64_IMM(BPF_ADD
, R1
, 1),
4549 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 4),
4550 BPF_ALU64_IMM(BPF_ADD
, R1
, 1),
4551 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 2),
4552 BPF_ALU64_IMM(BPF_ADD
, R1
, 1),
4553 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 1),
4554 BPF_EXIT_INSN(), /* bad exit */
4555 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* good exit */
4563 "JMP_JSGE_K: Signed jump: value walk 2",
4565 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4566 BPF_LD_IMM64(R1
, -3),
4567 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 4),
4568 BPF_ALU64_IMM(BPF_ADD
, R1
, 2),
4569 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 2),
4570 BPF_ALU64_IMM(BPF_ADD
, R1
, 2),
4571 BPF_JMP_IMM(BPF_JSGE
, R1
, 0, 1),
4572 BPF_EXIT_INSN(), /* bad exit */
4573 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* good exit */
4580 /* BPF_JMP | BPF_JGT | BPF_K */
4582 "JMP_JGT_K: if (3 > 2) return 1",
4584 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4585 BPF_LD_IMM64(R1
, 3),
4586 BPF_JMP_IMM(BPF_JGT
, R1
, 2, 1),
4588 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4596 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
4598 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4599 BPF_LD_IMM64(R1
, -1),
4600 BPF_JMP_IMM(BPF_JGT
, R1
, 1, 1),
4602 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4609 /* BPF_JMP | BPF_JLT | BPF_K */
4611 "JMP_JLT_K: if (2 < 3) return 1",
4613 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4614 BPF_LD_IMM64(R1
, 2),
4615 BPF_JMP_IMM(BPF_JLT
, R1
, 3, 1),
4617 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4625 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
4627 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4628 BPF_LD_IMM64(R1
, 1),
4629 BPF_JMP_IMM(BPF_JLT
, R1
, -1, 1),
4631 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4638 /* BPF_JMP | BPF_JGE | BPF_K */
4640 "JMP_JGE_K: if (3 >= 2) return 1",
4642 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4643 BPF_LD_IMM64(R1
, 3),
4644 BPF_JMP_IMM(BPF_JGE
, R1
, 2, 1),
4646 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4653 /* BPF_JMP | BPF_JLE | BPF_K */
4655 "JMP_JLE_K: if (2 <= 3) return 1",
4657 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4658 BPF_LD_IMM64(R1
, 2),
4659 BPF_JMP_IMM(BPF_JLE
, R1
, 3, 1),
4661 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4668 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4670 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4672 BPF_JMP_IMM(BPF_JA
, 0, 0, 2), /* goto start */
4673 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* out: */
4675 BPF_ALU32_IMM(BPF_MOV
, R0
, 0), /* start: */
4676 BPF_LD_IMM64(R1
, 3), /* note: this takes 2 insns */
4677 BPF_JMP_IMM(BPF_JGT
, R1
, 2, -6), /* goto out */
4685 "JMP_JGE_K: if (3 >= 3) return 1",
4687 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4688 BPF_LD_IMM64(R1
, 3),
4689 BPF_JMP_IMM(BPF_JGE
, R1
, 3, 1),
4691 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4698 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
4700 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
4702 BPF_JMP_IMM(BPF_JA
, 0, 0, 2), /* goto start */
4703 BPF_ALU32_IMM(BPF_MOV
, R0
, 1), /* out: */
4705 BPF_ALU32_IMM(BPF_MOV
, R0
, 0), /* start: */
4706 BPF_LD_IMM64(R1
, 2), /* note: this takes 2 insns */
4707 BPF_JMP_IMM(BPF_JLT
, R1
, 3, -6), /* goto out */
4715 "JMP_JLE_K: if (3 <= 3) return 1",
4717 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4718 BPF_LD_IMM64(R1
, 3),
4719 BPF_JMP_IMM(BPF_JLE
, R1
, 3, 1),
4721 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4728 /* BPF_JMP | BPF_JNE | BPF_K */
4730 "JMP_JNE_K: if (3 != 2) return 1",
4732 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4733 BPF_LD_IMM64(R1
, 3),
4734 BPF_JMP_IMM(BPF_JNE
, R1
, 2, 1),
4736 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4743 /* BPF_JMP | BPF_JEQ | BPF_K */
4745 "JMP_JEQ_K: if (3 == 3) return 1",
4747 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4748 BPF_LD_IMM64(R1
, 3),
4749 BPF_JMP_IMM(BPF_JEQ
, R1
, 3, 1),
4751 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4758 /* BPF_JMP | BPF_JSET | BPF_K */
4760 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4762 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4763 BPF_LD_IMM64(R1
, 3),
4764 BPF_JMP_IMM(BPF_JSET
, R1
, 2, 1),
4766 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4774 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4776 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4777 BPF_LD_IMM64(R1
, 3),
4778 BPF_JMP_IMM(BPF_JSET
, R1
, 0xffffffff, 1),
4780 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4787 /* BPF_JMP | BPF_JSGT | BPF_X */
4789 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4791 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4792 BPF_LD_IMM64(R1
, -1),
4793 BPF_LD_IMM64(R2
, -2),
4794 BPF_JMP_REG(BPF_JSGT
, R1
, R2
, 1),
4796 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4804 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
4806 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4807 BPF_LD_IMM64(R1
, -1),
4808 BPF_LD_IMM64(R2
, -1),
4809 BPF_JMP_REG(BPF_JSGT
, R1
, R2
, 1),
4811 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4818 /* BPF_JMP | BPF_JSLT | BPF_X */
4820 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
4822 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4823 BPF_LD_IMM64(R1
, -1),
4824 BPF_LD_IMM64(R2
, -2),
4825 BPF_JMP_REG(BPF_JSLT
, R2
, R1
, 1),
4827 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4835 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
4837 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4838 BPF_LD_IMM64(R1
, -1),
4839 BPF_LD_IMM64(R2
, -1),
4840 BPF_JMP_REG(BPF_JSLT
, R1
, R2
, 1),
4842 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4849 /* BPF_JMP | BPF_JSGE | BPF_X */
4851 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
4853 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4854 BPF_LD_IMM64(R1
, -1),
4855 BPF_LD_IMM64(R2
, -2),
4856 BPF_JMP_REG(BPF_JSGE
, R1
, R2
, 1),
4858 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4866 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
4868 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4869 BPF_LD_IMM64(R1
, -1),
4870 BPF_LD_IMM64(R2
, -1),
4871 BPF_JMP_REG(BPF_JSGE
, R1
, R2
, 1),
4873 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4880 /* BPF_JMP | BPF_JSLE | BPF_X */
4882 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
4884 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4885 BPF_LD_IMM64(R1
, -1),
4886 BPF_LD_IMM64(R2
, -2),
4887 BPF_JMP_REG(BPF_JSLE
, R2
, R1
, 1),
4889 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4897 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
4899 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4900 BPF_LD_IMM64(R1
, -1),
4901 BPF_LD_IMM64(R2
, -1),
4902 BPF_JMP_REG(BPF_JSLE
, R1
, R2
, 1),
4904 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4911 /* BPF_JMP | BPF_JGT | BPF_X */
4913 "JMP_JGT_X: if (3 > 2) return 1",
4915 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4916 BPF_LD_IMM64(R1
, 3),
4917 BPF_LD_IMM64(R2
, 2),
4918 BPF_JMP_REG(BPF_JGT
, R1
, R2
, 1),
4920 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4928 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
4930 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4931 BPF_LD_IMM64(R1
, -1),
4932 BPF_LD_IMM64(R2
, 1),
4933 BPF_JMP_REG(BPF_JGT
, R1
, R2
, 1),
4935 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4942 /* BPF_JMP | BPF_JLT | BPF_X */
4944 "JMP_JLT_X: if (2 < 3) return 1",
4946 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4947 BPF_LD_IMM64(R1
, 3),
4948 BPF_LD_IMM64(R2
, 2),
4949 BPF_JMP_REG(BPF_JLT
, R2
, R1
, 1),
4951 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4959 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
4961 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4962 BPF_LD_IMM64(R1
, -1),
4963 BPF_LD_IMM64(R2
, 1),
4964 BPF_JMP_REG(BPF_JLT
, R2
, R1
, 1),
4966 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4973 /* BPF_JMP | BPF_JGE | BPF_X */
4975 "JMP_JGE_X: if (3 >= 2) return 1",
4977 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4978 BPF_LD_IMM64(R1
, 3),
4979 BPF_LD_IMM64(R2
, 2),
4980 BPF_JMP_REG(BPF_JGE
, R1
, R2
, 1),
4982 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
4990 "JMP_JGE_X: if (3 >= 3) return 1",
4992 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
4993 BPF_LD_IMM64(R1
, 3),
4994 BPF_LD_IMM64(R2
, 3),
4995 BPF_JMP_REG(BPF_JGE
, R1
, R2
, 1),
4997 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5004 /* BPF_JMP | BPF_JLE | BPF_X */
5006 "JMP_JLE_X: if (2 <= 3) return 1",
5008 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5009 BPF_LD_IMM64(R1
, 3),
5010 BPF_LD_IMM64(R2
, 2),
5011 BPF_JMP_REG(BPF_JLE
, R2
, R1
, 1),
5013 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5021 "JMP_JLE_X: if (3 <= 3) return 1",
5023 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5024 BPF_LD_IMM64(R1
, 3),
5025 BPF_LD_IMM64(R2
, 3),
5026 BPF_JMP_REG(BPF_JLE
, R1
, R2
, 1),
5028 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5036 /* Mainly testing JIT + imm64 here. */
5037 "JMP_JGE_X: ldimm64 test 1",
5039 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5040 BPF_LD_IMM64(R1
, 3),
5041 BPF_LD_IMM64(R2
, 2),
5042 BPF_JMP_REG(BPF_JGE
, R1
, R2
, 2),
5043 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5044 BPF_LD_IMM64(R0
, 0xeeeeeeeeeeeeeeeeULL
),
5049 { { 0, 0xeeeeeeeeU
} },
5052 "JMP_JGE_X: ldimm64 test 2",
5054 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5055 BPF_LD_IMM64(R1
, 3),
5056 BPF_LD_IMM64(R2
, 2),
5057 BPF_JMP_REG(BPF_JGE
, R1
, R2
, 0),
5058 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5063 { { 0, 0xffffffffU
} },
5066 "JMP_JGE_X: ldimm64 test 3",
5068 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5069 BPF_LD_IMM64(R1
, 3),
5070 BPF_LD_IMM64(R2
, 2),
5071 BPF_JMP_REG(BPF_JGE
, R1
, R2
, 4),
5072 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5073 BPF_LD_IMM64(R0
, 0xeeeeeeeeeeeeeeeeULL
),
5081 "JMP_JLE_X: ldimm64 test 1",
5083 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5084 BPF_LD_IMM64(R1
, 3),
5085 BPF_LD_IMM64(R2
, 2),
5086 BPF_JMP_REG(BPF_JLE
, R2
, R1
, 2),
5087 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5088 BPF_LD_IMM64(R0
, 0xeeeeeeeeeeeeeeeeULL
),
5093 { { 0, 0xeeeeeeeeU
} },
5096 "JMP_JLE_X: ldimm64 test 2",
5098 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5099 BPF_LD_IMM64(R1
, 3),
5100 BPF_LD_IMM64(R2
, 2),
5101 BPF_JMP_REG(BPF_JLE
, R2
, R1
, 0),
5102 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5107 { { 0, 0xffffffffU
} },
5110 "JMP_JLE_X: ldimm64 test 3",
5112 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5113 BPF_LD_IMM64(R1
, 3),
5114 BPF_LD_IMM64(R2
, 2),
5115 BPF_JMP_REG(BPF_JLE
, R2
, R1
, 4),
5116 BPF_LD_IMM64(R0
, 0xffffffffffffffffULL
),
5117 BPF_LD_IMM64(R0
, 0xeeeeeeeeeeeeeeeeULL
),
5124 /* BPF_JMP | BPF_JNE | BPF_X */
5126 "JMP_JNE_X: if (3 != 2) return 1",
5128 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5129 BPF_LD_IMM64(R1
, 3),
5130 BPF_LD_IMM64(R2
, 2),
5131 BPF_JMP_REG(BPF_JNE
, R1
, R2
, 1),
5133 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5140 /* BPF_JMP | BPF_JEQ | BPF_X */
5142 "JMP_JEQ_X: if (3 == 3) return 1",
5144 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5145 BPF_LD_IMM64(R1
, 3),
5146 BPF_LD_IMM64(R2
, 3),
5147 BPF_JMP_REG(BPF_JEQ
, R1
, R2
, 1),
5149 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5156 /* BPF_JMP | BPF_JSET | BPF_X */
5158 "JMP_JSET_X: if (0x3 & 0x2) return 1",
5160 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5161 BPF_LD_IMM64(R1
, 3),
5162 BPF_LD_IMM64(R2
, 2),
5163 BPF_JMP_REG(BPF_JSET
, R1
, R2
, 1),
5165 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5173 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
5175 BPF_ALU32_IMM(BPF_MOV
, R0
, 0),
5176 BPF_LD_IMM64(R1
, 3),
5177 BPF_LD_IMM64(R2
, 0xffffffff),
5178 BPF_JMP_REG(BPF_JSET
, R1
, R2
, 1),
5180 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
5188 "JMP_JA: Jump, gap, jump, ...",
5190 CLASSIC
| FLAG_NO_DATA
,
5192 { { 0, 0xababcbac } },
5193 .fill_helper
= bpf_fill_ja
,
5195 { /* Mainly checking JIT here. */
5196 "BPF_MAXINSNS: Maximum possible literals",
5198 CLASSIC
| FLAG_NO_DATA
,
5200 { { 0, 0xffffffff } },
5201 .fill_helper
= bpf_fill_maxinsns1
,
5203 { /* Mainly checking JIT here. */
5204 "BPF_MAXINSNS: Single literal",
5206 CLASSIC
| FLAG_NO_DATA
,
5208 { { 0, 0xfefefefe } },
5209 .fill_helper
= bpf_fill_maxinsns2
,
5211 { /* Mainly checking JIT here. */
5212 "BPF_MAXINSNS: Run/add until end",
5214 CLASSIC
| FLAG_NO_DATA
,
5216 { { 0, 0x947bf368 } },
5217 .fill_helper
= bpf_fill_maxinsns3
,
5220 "BPF_MAXINSNS: Too many instructions",
5222 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
5225 .fill_helper
= bpf_fill_maxinsns4
,
5226 .expected_errcode
= -EINVAL
,
5228 { /* Mainly checking JIT here. */
5229 "BPF_MAXINSNS: Very long jump",
5231 CLASSIC
| FLAG_NO_DATA
,
5233 { { 0, 0xabababab } },
5234 .fill_helper
= bpf_fill_maxinsns5
,
5236 { /* Mainly checking JIT here. */
5237 "BPF_MAXINSNS: Ctx heavy transformations",
5242 { 1, !!(SKB_VLAN_TCI
& VLAN_TAG_PRESENT
) },
5243 { 10, !!(SKB_VLAN_TCI
& VLAN_TAG_PRESENT
) }
5245 .fill_helper
= bpf_fill_maxinsns6
,
5247 { /* Mainly checking JIT here. */
5248 "BPF_MAXINSNS: Call heavy transformations",
5250 CLASSIC
| FLAG_NO_DATA
,
5252 { { 1, 0 }, { 10, 0 } },
5253 .fill_helper
= bpf_fill_maxinsns7
,
5255 { /* Mainly checking JIT here. */
5256 "BPF_MAXINSNS: Jump heavy test",
5258 CLASSIC
| FLAG_NO_DATA
,
5260 { { 0, 0xffffffff } },
5261 .fill_helper
= bpf_fill_maxinsns8
,
5263 { /* Mainly checking JIT here. */
5264 "BPF_MAXINSNS: Very long jump backwards",
5266 INTERNAL
| FLAG_NO_DATA
,
5268 { { 0, 0xcbababab } },
5269 .fill_helper
= bpf_fill_maxinsns9
,
5271 { /* Mainly checking JIT here. */
5272 "BPF_MAXINSNS: Edge hopping nuthouse",
5274 INTERNAL
| FLAG_NO_DATA
,
5276 { { 0, 0xabababac } },
5277 .fill_helper
= bpf_fill_maxinsns10
,
5280 "BPF_MAXINSNS: Jump, gap, jump, ...",
5282 #if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_X86)
5283 CLASSIC
| FLAG_NO_DATA
| FLAG_EXPECTED_FAIL
,
5285 CLASSIC
| FLAG_NO_DATA
,
5288 { { 0, 0xababcbac } },
5289 .fill_helper
= bpf_fill_maxinsns11
,
5290 .expected_errcode
= -ENOTSUPP
,
5293 "BPF_MAXINSNS: ld_abs+get_processor_id",
5298 .fill_helper
= bpf_fill_ld_abs_get_processor_id
,
5301 * LD_IND / LD_ABS on fragmented SKBs
5306 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x40),
5307 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, 0x0),
5308 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5310 CLASSIC
| FLAG_SKB_FRAG
,
5314 0x42, 0x00, 0x00, 0x00,
5315 0x43, 0x44, 0x00, 0x00,
5316 0x21, 0x07, 0x19, 0x83,
5320 "LD_IND halfword frag",
5322 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x40),
5323 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, 0x4),
5324 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5326 CLASSIC
| FLAG_SKB_FRAG
,
5330 0x42, 0x00, 0x00, 0x00,
5331 0x43, 0x44, 0x00, 0x00,
5332 0x21, 0x07, 0x19, 0x83,
5338 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x40),
5339 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, 0x8),
5340 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5342 CLASSIC
| FLAG_SKB_FRAG
,
5344 { {0x40, 0x21071983} },
5346 0x42, 0x00, 0x00, 0x00,
5347 0x43, 0x44, 0x00, 0x00,
5348 0x21, 0x07, 0x19, 0x83,
5352 "LD_IND halfword mixed head/frag",
5354 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x40),
5355 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, -0x1),
5356 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5358 CLASSIC
| FLAG_SKB_FRAG
,
5359 { [0x3e] = 0x25, [0x3f] = 0x05, },
5361 .frag_data
= { 0x19, 0x82 },
5364 "LD_IND word mixed head/frag",
5366 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x40),
5367 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x2),
5368 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5370 CLASSIC
| FLAG_SKB_FRAG
,
5371 { [0x3e] = 0x25, [0x3f] = 0x05, },
5372 { {0x40, 0x25051982} },
5373 .frag_data
= { 0x19, 0x82 },
5378 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, 0x40),
5379 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5381 CLASSIC
| FLAG_SKB_FRAG
,
5385 0x42, 0x00, 0x00, 0x00,
5386 0x43, 0x44, 0x00, 0x00,
5387 0x21, 0x07, 0x19, 0x83,
5391 "LD_ABS halfword frag",
5393 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x44),
5394 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5396 CLASSIC
| FLAG_SKB_FRAG
,
5400 0x42, 0x00, 0x00, 0x00,
5401 0x43, 0x44, 0x00, 0x00,
5402 0x21, 0x07, 0x19, 0x83,
5408 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x48),
5409 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5411 CLASSIC
| FLAG_SKB_FRAG
,
5413 { {0x40, 0x21071983} },
5415 0x42, 0x00, 0x00, 0x00,
5416 0x43, 0x44, 0x00, 0x00,
5417 0x21, 0x07, 0x19, 0x83,
5421 "LD_ABS halfword mixed head/frag",
5423 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x3f),
5424 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5426 CLASSIC
| FLAG_SKB_FRAG
,
5427 { [0x3e] = 0x25, [0x3f] = 0x05, },
5429 .frag_data
= { 0x19, 0x82 },
5432 "LD_ABS word mixed head/frag",
5434 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x3e),
5435 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5437 CLASSIC
| FLAG_SKB_FRAG
,
5438 { [0x3e] = 0x25, [0x3f] = 0x05, },
5439 { {0x40, 0x25051982} },
5440 .frag_data
= { 0x19, 0x82 },
5443 * LD_IND / LD_ABS on non fragmented SKBs
5447 * this tests that the JIT/interpreter correctly resets X
5448 * before using it in an LD_IND instruction.
5450 "LD_IND byte default X",
5452 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, 0x1),
5453 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5460 "LD_IND byte positive offset",
5462 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5463 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, 0x1),
5464 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5467 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5471 "LD_IND byte negative offset",
5473 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5474 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, -0x1),
5475 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5478 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5482 "LD_IND byte positive offset, all ff",
5484 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5485 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, 0x1),
5486 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5489 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5493 "LD_IND byte positive offset, out of bounds",
5495 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5496 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, 0x1),
5497 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5500 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5504 "LD_IND byte negative offset, out of bounds",
5506 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5507 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, -0x3f),
5508 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5511 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5515 "LD_IND byte negative offset, multiple calls",
5517 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3b),
5518 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, SKF_LL_OFF
+ 1),
5519 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, SKF_LL_OFF
+ 2),
5520 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, SKF_LL_OFF
+ 3),
5521 BPF_STMT(BPF_LD
| BPF_IND
| BPF_B
, SKF_LL_OFF
+ 4),
5522 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5525 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5529 "LD_IND halfword positive offset",
5531 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5532 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, 0x2),
5533 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5537 [0x1c] = 0xaa, [0x1d] = 0x55,
5538 [0x1e] = 0xbb, [0x1f] = 0x66,
5539 [0x20] = 0xcc, [0x21] = 0x77,
5540 [0x22] = 0xdd, [0x23] = 0x88,
5542 { {0x40, 0xdd88 } },
5545 "LD_IND halfword negative offset",
5547 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5548 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, -0x2),
5549 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5553 [0x1c] = 0xaa, [0x1d] = 0x55,
5554 [0x1e] = 0xbb, [0x1f] = 0x66,
5555 [0x20] = 0xcc, [0x21] = 0x77,
5556 [0x22] = 0xdd, [0x23] = 0x88,
5558 { {0x40, 0xbb66 } },
5561 "LD_IND halfword unaligned",
5563 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5564 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, -0x1),
5565 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5569 [0x1c] = 0xaa, [0x1d] = 0x55,
5570 [0x1e] = 0xbb, [0x1f] = 0x66,
5571 [0x20] = 0xcc, [0x21] = 0x77,
5572 [0x22] = 0xdd, [0x23] = 0x88,
5574 { {0x40, 0x66cc } },
5577 "LD_IND halfword positive offset, all ff",
5579 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3d),
5580 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, 0x1),
5581 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5584 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5585 { {0x40, 0xffff } },
5588 "LD_IND halfword positive offset, out of bounds",
5590 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5591 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, 0x1),
5592 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5595 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5599 "LD_IND halfword negative offset, out of bounds",
5601 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5602 BPF_STMT(BPF_LD
| BPF_IND
| BPF_H
, -0x3f),
5603 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5606 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5610 "LD_IND word positive offset",
5612 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5613 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, 0x4),
5614 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5618 [0x1c] = 0xaa, [0x1d] = 0x55,
5619 [0x1e] = 0xbb, [0x1f] = 0x66,
5620 [0x20] = 0xcc, [0x21] = 0x77,
5621 [0x22] = 0xdd, [0x23] = 0x88,
5622 [0x24] = 0xee, [0x25] = 0x99,
5623 [0x26] = 0xff, [0x27] = 0xaa,
5625 { {0x40, 0xee99ffaa } },
5628 "LD_IND word negative offset",
5630 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5631 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x4),
5632 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5636 [0x1c] = 0xaa, [0x1d] = 0x55,
5637 [0x1e] = 0xbb, [0x1f] = 0x66,
5638 [0x20] = 0xcc, [0x21] = 0x77,
5639 [0x22] = 0xdd, [0x23] = 0x88,
5640 [0x24] = 0xee, [0x25] = 0x99,
5641 [0x26] = 0xff, [0x27] = 0xaa,
5643 { {0x40, 0xaa55bb66 } },
5646 "LD_IND word unaligned (addr & 3 == 2)",
5648 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5649 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x2),
5650 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5654 [0x1c] = 0xaa, [0x1d] = 0x55,
5655 [0x1e] = 0xbb, [0x1f] = 0x66,
5656 [0x20] = 0xcc, [0x21] = 0x77,
5657 [0x22] = 0xdd, [0x23] = 0x88,
5658 [0x24] = 0xee, [0x25] = 0x99,
5659 [0x26] = 0xff, [0x27] = 0xaa,
5661 { {0x40, 0xbb66cc77 } },
5664 "LD_IND word unaligned (addr & 3 == 1)",
5666 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5667 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x3),
5668 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5672 [0x1c] = 0xaa, [0x1d] = 0x55,
5673 [0x1e] = 0xbb, [0x1f] = 0x66,
5674 [0x20] = 0xcc, [0x21] = 0x77,
5675 [0x22] = 0xdd, [0x23] = 0x88,
5676 [0x24] = 0xee, [0x25] = 0x99,
5677 [0x26] = 0xff, [0x27] = 0xaa,
5679 { {0x40, 0x55bb66cc } },
5682 "LD_IND word unaligned (addr & 3 == 3)",
5684 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x20),
5685 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x1),
5686 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5690 [0x1c] = 0xaa, [0x1d] = 0x55,
5691 [0x1e] = 0xbb, [0x1f] = 0x66,
5692 [0x20] = 0xcc, [0x21] = 0x77,
5693 [0x22] = 0xdd, [0x23] = 0x88,
5694 [0x24] = 0xee, [0x25] = 0x99,
5695 [0x26] = 0xff, [0x27] = 0xaa,
5697 { {0x40, 0x66cc77dd } },
5700 "LD_IND word positive offset, all ff",
5702 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3b),
5703 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, 0x1),
5704 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5707 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5708 { {0x40, 0xffffffff } },
5711 "LD_IND word positive offset, out of bounds",
5713 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5714 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, 0x1),
5715 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5718 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5722 "LD_IND word negative offset, out of bounds",
5724 BPF_STMT(BPF_LDX
| BPF_IMM
, 0x3e),
5725 BPF_STMT(BPF_LD
| BPF_IND
| BPF_W
, -0x3f),
5726 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5729 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5735 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, 0x20),
5736 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5740 [0x1c] = 0xaa, [0x1d] = 0x55,
5741 [0x1e] = 0xbb, [0x1f] = 0x66,
5742 [0x20] = 0xcc, [0x21] = 0x77,
5743 [0x22] = 0xdd, [0x23] = 0x88,
5744 [0x24] = 0xee, [0x25] = 0x99,
5745 [0x26] = 0xff, [0x27] = 0xaa,
5750 "LD_ABS byte positive offset, all ff",
5752 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, 0x3f),
5753 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5756 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5760 "LD_ABS byte positive offset, out of bounds",
5762 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, 0x3f),
5763 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5766 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5770 "LD_ABS byte negative offset, out of bounds load",
5772 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, -1),
5773 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5775 CLASSIC
| FLAG_EXPECTED_FAIL
,
5776 .expected_errcode
= -EINVAL
,
5779 "LD_ABS byte negative offset, in bounds",
5781 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3f),
5782 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5785 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5789 "LD_ABS byte negative offset, out of bounds",
5791 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3f),
5792 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5795 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5799 "LD_ABS byte negative offset, multiple calls",
5801 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3c),
5802 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3d),
5803 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3e),
5804 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_B
, SKF_LL_OFF
+ 0x3f),
5805 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5808 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5814 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x22),
5815 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5819 [0x1c] = 0xaa, [0x1d] = 0x55,
5820 [0x1e] = 0xbb, [0x1f] = 0x66,
5821 [0x20] = 0xcc, [0x21] = 0x77,
5822 [0x22] = 0xdd, [0x23] = 0x88,
5823 [0x24] = 0xee, [0x25] = 0x99,
5824 [0x26] = 0xff, [0x27] = 0xaa,
5826 { {0x40, 0xdd88 } },
5829 "LD_ABS halfword unaligned",
5831 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x25),
5832 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5836 [0x1c] = 0xaa, [0x1d] = 0x55,
5837 [0x1e] = 0xbb, [0x1f] = 0x66,
5838 [0x20] = 0xcc, [0x21] = 0x77,
5839 [0x22] = 0xdd, [0x23] = 0x88,
5840 [0x24] = 0xee, [0x25] = 0x99,
5841 [0x26] = 0xff, [0x27] = 0xaa,
5843 { {0x40, 0x99ff } },
5846 "LD_ABS halfword positive offset, all ff",
5848 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x3e),
5849 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5852 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5853 { {0x40, 0xffff } },
5856 "LD_ABS halfword positive offset, out of bounds",
5858 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, 0x3f),
5859 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5862 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5866 "LD_ABS halfword negative offset, out of bounds load",
5868 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, -1),
5869 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5871 CLASSIC
| FLAG_EXPECTED_FAIL
,
5872 .expected_errcode
= -EINVAL
,
5875 "LD_ABS halfword negative offset, in bounds",
5877 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, SKF_LL_OFF
+ 0x3e),
5878 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5881 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5882 { {0x40, 0x1982 }, },
5885 "LD_ABS halfword negative offset, out of bounds",
5887 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_H
, SKF_LL_OFF
+ 0x3e),
5888 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5891 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5897 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x1c),
5898 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5902 [0x1c] = 0xaa, [0x1d] = 0x55,
5903 [0x1e] = 0xbb, [0x1f] = 0x66,
5904 [0x20] = 0xcc, [0x21] = 0x77,
5905 [0x22] = 0xdd, [0x23] = 0x88,
5906 [0x24] = 0xee, [0x25] = 0x99,
5907 [0x26] = 0xff, [0x27] = 0xaa,
5909 { {0x40, 0xaa55bb66 } },
5912 "LD_ABS word unaligned (addr & 3 == 2)",
5914 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x22),
5915 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5919 [0x1c] = 0xaa, [0x1d] = 0x55,
5920 [0x1e] = 0xbb, [0x1f] = 0x66,
5921 [0x20] = 0xcc, [0x21] = 0x77,
5922 [0x22] = 0xdd, [0x23] = 0x88,
5923 [0x24] = 0xee, [0x25] = 0x99,
5924 [0x26] = 0xff, [0x27] = 0xaa,
5926 { {0x40, 0xdd88ee99 } },
5929 "LD_ABS word unaligned (addr & 3 == 1)",
5931 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x21),
5932 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5936 [0x1c] = 0xaa, [0x1d] = 0x55,
5937 [0x1e] = 0xbb, [0x1f] = 0x66,
5938 [0x20] = 0xcc, [0x21] = 0x77,
5939 [0x22] = 0xdd, [0x23] = 0x88,
5940 [0x24] = 0xee, [0x25] = 0x99,
5941 [0x26] = 0xff, [0x27] = 0xaa,
5943 { {0x40, 0x77dd88ee } },
5946 "LD_ABS word unaligned (addr & 3 == 3)",
5948 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x23),
5949 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5953 [0x1c] = 0xaa, [0x1d] = 0x55,
5954 [0x1e] = 0xbb, [0x1f] = 0x66,
5955 [0x20] = 0xcc, [0x21] = 0x77,
5956 [0x22] = 0xdd, [0x23] = 0x88,
5957 [0x24] = 0xee, [0x25] = 0x99,
5958 [0x26] = 0xff, [0x27] = 0xaa,
5960 { {0x40, 0x88ee99ff } },
5963 "LD_ABS word positive offset, all ff",
5965 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x3c),
5966 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5969 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
5970 { {0x40, 0xffffffff } },
5973 "LD_ABS word positive offset, out of bounds",
5975 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, 0x3f),
5976 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5979 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5983 "LD_ABS word negative offset, out of bounds load",
5985 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, -1),
5986 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5988 CLASSIC
| FLAG_EXPECTED_FAIL
,
5989 .expected_errcode
= -EINVAL
,
5992 "LD_ABS word negative offset, in bounds",
5994 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, SKF_LL_OFF
+ 0x3c),
5995 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
5998 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5999 { {0x40, 0x25051982 }, },
6002 "LD_ABS word negative offset, out of bounds",
6004 BPF_STMT(BPF_LD
| BPF_ABS
| BPF_W
, SKF_LL_OFF
+ 0x3c),
6005 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6008 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6012 "LDX_MSH standalone, preserved A",
6014 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6015 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3c),
6016 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6019 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6020 { {0x40, 0xffeebbaa }, },
6023 "LDX_MSH standalone, preserved A 2",
6025 BPF_STMT(BPF_LD
| BPF_IMM
, 0x175e9d63),
6026 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3c),
6027 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3d),
6028 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3e),
6029 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3f),
6030 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6033 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6034 { {0x40, 0x175e9d63 }, },
6037 "LDX_MSH standalone, test result 1",
6039 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6040 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3c),
6041 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
6042 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6045 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6049 "LDX_MSH standalone, test result 2",
6051 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6052 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x3e),
6053 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
6054 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6057 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6061 "LDX_MSH standalone, negative offset",
6063 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6064 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, -1),
6065 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
6066 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6069 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6073 "LDX_MSH standalone, negative offset 2",
6075 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6076 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, SKF_LL_OFF
+ 0x3e),
6077 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
6078 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6081 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6085 "LDX_MSH standalone, out of bounds",
6087 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffeebbaa),
6088 BPF_STMT(BPF_LDX
| BPF_B
| BPF_MSH
, 0x40),
6089 BPF_STMT(BPF_MISC
| BPF_TXA
, 0),
6090 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6093 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
6097 * verify that the interpreter or JIT correctly sets A and X
6108 BPF_STMT(BPF_LD
| BPF_IMM
, 0x42),
6109 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
6110 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6112 CLASSIC
| FLAG_NO_DATA
,
6123 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 0x42),
6124 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6126 CLASSIC
| FLAG_NO_DATA
,
6138 BPF_STMT(BPF_LD
| BPF_IMM
, 0x66),
6139 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_X
, 0),
6140 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6142 CLASSIC
| FLAG_NO_DATA
,
6153 BPF_STMT(BPF_ALU
| BPF_SUB
| BPF_K
, -0x66),
6154 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6156 CLASSIC
| FLAG_NO_DATA
,
6168 BPF_STMT(BPF_LD
| BPF_IMM
, 0x42),
6169 BPF_STMT(BPF_ALU
| BPF_MUL
| BPF_X
, 0),
6170 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6172 CLASSIC
| FLAG_NO_DATA
,
6183 BPF_STMT(BPF_ALU
| BPF_MUL
| BPF_K
, 0x66),
6184 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6186 CLASSIC
| FLAG_NO_DATA
,
6195 * A = A / X ; this halt the filter execution if X is 0
6198 BPF_STMT(BPF_LD
| BPF_IMM
, 0x42),
6199 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_X
, 0),
6200 BPF_STMT(BPF_RET
| BPF_K
, 0x42),
6202 CLASSIC
| FLAG_NO_DATA
,
6213 BPF_STMT(BPF_ALU
| BPF_DIV
| BPF_K
, 0x1),
6214 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6216 CLASSIC
| FLAG_NO_DATA
,
6225 * A = A mod X ; this halt the filter execution if X is 0
6228 BPF_STMT(BPF_LD
| BPF_IMM
, 0x42),
6229 BPF_STMT(BPF_ALU
| BPF_MOD
| BPF_X
, 0),
6230 BPF_STMT(BPF_RET
| BPF_K
, 0x42),
6232 CLASSIC
| FLAG_NO_DATA
,
6243 BPF_STMT(BPF_ALU
| BPF_MOD
| BPF_K
, 0x1),
6244 BPF_STMT(BPF_RET
| BPF_A
, 0x0),
6246 CLASSIC
| FLAG_NO_DATA
,
6258 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x0, 0, 1),
6259 BPF_STMT(BPF_RET
| BPF_K
, 0x42),
6260 BPF_STMT(BPF_RET
| BPF_K
, 0x66),
6262 CLASSIC
| FLAG_NO_DATA
,
6275 BPF_STMT(BPF_LD
| BPF_IMM
, 0x0),
6276 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_X
, 0x0, 0, 1),
6277 BPF_STMT(BPF_RET
| BPF_K
, 0x42),
6278 BPF_STMT(BPF_RET
| BPF_K
, 0x66),
6280 CLASSIC
| FLAG_NO_DATA
,
6284 /* Checking interpreter vs JIT wrt signed extended imms. */
6286 "JNE signed compare, test 1",
6288 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xfefbbc12),
6289 BPF_ALU32_IMM(BPF_MOV
, R3
, 0xffff0000),
6290 BPF_MOV64_REG(R2
, R1
),
6291 BPF_ALU64_REG(BPF_AND
, R2
, R3
),
6292 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6293 BPF_JMP_IMM(BPF_JNE
, R2
, -17104896, 1),
6294 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6302 "JNE signed compare, test 2",
6304 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xfefbbc12),
6305 BPF_ALU32_IMM(BPF_MOV
, R3
, 0xffff0000),
6306 BPF_MOV64_REG(R2
, R1
),
6307 BPF_ALU64_REG(BPF_AND
, R2
, R3
),
6308 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6309 BPF_JMP_IMM(BPF_JNE
, R2
, 0xfefb0000, 1),
6310 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6318 "JNE signed compare, test 3",
6320 BPF_ALU32_IMM(BPF_MOV
, R1
, 0xfefbbc12),
6321 BPF_ALU32_IMM(BPF_MOV
, R3
, 0xffff0000),
6322 BPF_ALU32_IMM(BPF_MOV
, R4
, 0xfefb0000),
6323 BPF_MOV64_REG(R2
, R1
),
6324 BPF_ALU64_REG(BPF_AND
, R2
, R3
),
6325 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6326 BPF_JMP_REG(BPF_JNE
, R2
, R4
, 1),
6327 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6335 "JNE signed compare, test 4",
6337 BPF_LD_IMM64(R1
, -17104896),
6338 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6339 BPF_JMP_IMM(BPF_JNE
, R1
, -17104896, 1),
6340 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6348 "JNE signed compare, test 5",
6350 BPF_LD_IMM64(R1
, 0xfefb0000),
6351 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6352 BPF_JMP_IMM(BPF_JNE
, R1
, 0xfefb0000, 1),
6353 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6361 "JNE signed compare, test 6",
6363 BPF_LD_IMM64(R1
, 0x7efb0000),
6364 BPF_ALU32_IMM(BPF_MOV
, R0
, 1),
6365 BPF_JMP_IMM(BPF_JNE
, R1
, 0x7efb0000, 1),
6366 BPF_ALU32_IMM(BPF_MOV
, R0
, 2),
6374 "JNE signed compare, test 7",
6376 BPF_STMT(BPF_LD
| BPF_IMM
, 0xffff0000),
6377 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
6378 BPF_STMT(BPF_LD
| BPF_IMM
, 0xfefbbc12),
6379 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_X
, 0),
6380 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0xfefb0000, 1, 0),
6381 BPF_STMT(BPF_RET
| BPF_K
, 1),
6382 BPF_STMT(BPF_RET
| BPF_K
, 2),
6384 CLASSIC
| FLAG_NO_DATA
,
6390 static struct net_device dev
;
6392 static struct sk_buff
*populate_skb(char *buf
, int size
)
6394 struct sk_buff
*skb
;
6396 if (size
>= MAX_DATA
)
6399 skb
= alloc_skb(MAX_DATA
, GFP_KERNEL
);
6403 __skb_put_data(skb
, buf
, size
);
6405 /* Initialize a fake skb with test pattern. */
6406 skb_reset_mac_header(skb
);
6407 skb
->protocol
= htons(ETH_P_IP
);
6408 skb
->pkt_type
= SKB_TYPE
;
6409 skb
->mark
= SKB_MARK
;
6410 skb
->hash
= SKB_HASH
;
6411 skb
->queue_mapping
= SKB_QUEUE_MAP
;
6412 skb
->vlan_tci
= SKB_VLAN_TCI
;
6413 skb
->vlan_proto
= htons(ETH_P_IP
);
6415 skb
->dev
->ifindex
= SKB_DEV_IFINDEX
;
6416 skb
->dev
->type
= SKB_DEV_TYPE
;
6417 skb_set_network_header(skb
, min(size
, ETH_HLEN
));
6422 static void *generate_test_data(struct bpf_test
*test
, int sub
)
6424 struct sk_buff
*skb
;
6427 if (test
->aux
& FLAG_NO_DATA
)
6430 /* Test case expects an skb, so populate one. Various
6431 * subtests generate skbs of different sizes based on
6434 skb
= populate_skb(test
->data
, test
->test
[sub
].data_size
);
6438 if (test
->aux
& FLAG_SKB_FRAG
) {
6440 * when the test requires a fragmented skb, add a
6441 * single fragment to the skb, filled with
6446 page
= alloc_page(GFP_KERNEL
);
6454 memcpy(ptr
, test
->frag_data
, MAX_DATA
);
6456 skb_add_rx_frag(skb
, 0, page
, 0, MAX_DATA
, MAX_DATA
);
6468 static void release_test_data(const struct bpf_test
*test
, void *data
)
6470 if (test
->aux
& FLAG_NO_DATA
)
6476 static int filter_length(int which
)
6478 struct sock_filter
*fp
;
6481 if (tests
[which
].fill_helper
)
6482 return tests
[which
].u
.ptr
.len
;
6484 fp
= tests
[which
].u
.insns
;
6485 for (len
= MAX_INSNS
- 1; len
> 0; --len
)
6486 if (fp
[len
].code
!= 0 || fp
[len
].k
!= 0)
6492 static void *filter_pointer(int which
)
6494 if (tests
[which
].fill_helper
)
6495 return tests
[which
].u
.ptr
.insns
;
6497 return tests
[which
].u
.insns
;
6500 static struct bpf_prog
*generate_filter(int which
, int *err
)
6502 __u8 test_type
= tests
[which
].aux
& TEST_TYPE_MASK
;
6503 unsigned int flen
= filter_length(which
);
6504 void *fptr
= filter_pointer(which
);
6505 struct sock_fprog_kern fprog
;
6506 struct bpf_prog
*fp
;
6508 switch (test_type
) {
6510 fprog
.filter
= fptr
;
6513 *err
= bpf_prog_create(&fp
, &fprog
);
6514 if (tests
[which
].aux
& FLAG_EXPECTED_FAIL
) {
6515 if (*err
== tests
[which
].expected_errcode
) {
6517 /* Verifier rejected filter as expected. */
6521 pr_cont("UNEXPECTED_PASS\n");
6522 /* Verifier didn't reject the test that's
6523 * bad enough, just return!
6530 pr_cont("FAIL to prog_create err=%d len=%d\n",
6537 fp
= bpf_prog_alloc(bpf_prog_size(flen
), 0);
6539 pr_cont("UNEXPECTED_FAIL no memory left\n");
6545 /* Type doesn't really matter here as long as it's not unspec. */
6546 fp
->type
= BPF_PROG_TYPE_SOCKET_FILTER
;
6547 memcpy(fp
->insnsi
, fptr
, fp
->len
* sizeof(struct bpf_insn
));
6548 fp
->aux
->stack_depth
= tests
[which
].stack_depth
;
6550 /* We cannot error here as we don't need type compatibility
6553 fp
= bpf_prog_select_runtime(fp
, err
);
6555 pr_cont("FAIL to select_runtime err=%d\n", *err
);
6565 static void release_filter(struct bpf_prog
*fp
, int which
)
6567 __u8 test_type
= tests
[which
].aux
& TEST_TYPE_MASK
;
6569 switch (test_type
) {
6571 bpf_prog_destroy(fp
);
6579 static int __run_one(const struct bpf_prog
*fp
, const void *data
,
6580 int runs
, u64
*duration
)
6585 start
= ktime_get_ns();
6587 for (i
= 0; i
< runs
; i
++)
6588 ret
= BPF_PROG_RUN(fp
, data
);
6590 finish
= ktime_get_ns();
6592 *duration
= finish
- start
;
6593 do_div(*duration
, runs
);
6598 static int run_one(const struct bpf_prog
*fp
, struct bpf_test
*test
)
6600 int err_cnt
= 0, i
, runs
= MAX_TESTRUNS
;
6602 for (i
= 0; i
< MAX_SUBTESTS
; i
++) {
6607 if (test
->test
[i
].data_size
== 0 &&
6608 test
->test
[i
].result
== 0)
6611 data
= generate_test_data(test
, i
);
6612 if (!data
&& !(test
->aux
& FLAG_NO_DATA
)) {
6613 pr_cont("data generation failed ");
6617 ret
= __run_one(fp
, data
, runs
, &duration
);
6618 release_test_data(test
, data
);
6620 if (ret
== test
->test
[i
].result
) {
6621 pr_cont("%lld ", duration
);
6623 pr_cont("ret %d != %d ", ret
,
6624 test
->test
[i
].result
);
6632 static char test_name
[64];
6633 module_param_string(test_name
, test_name
, sizeof(test_name
), 0);
6635 static int test_id
= -1;
6636 module_param(test_id
, int, 0);
6638 static int test_range
[2] = { 0, ARRAY_SIZE(tests
) - 1 };
6639 module_param_array(test_range
, int, NULL
, 0);
6641 static __init
int find_test_index(const char *test_name
)
6645 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++) {
6646 if (!strcmp(tests
[i
].descr
, test_name
))
6652 static __init
int prepare_bpf_tests(void)
6658 * if a test_id was specified, use test_range to
6659 * cover only that test.
6661 if (test_id
>= ARRAY_SIZE(tests
)) {
6662 pr_err("test_bpf: invalid test_id specified.\n");
6666 test_range
[0] = test_id
;
6667 test_range
[1] = test_id
;
6668 } else if (*test_name
) {
6670 * if a test_name was specified, find it and setup
6671 * test_range to cover only that test.
6673 int idx
= find_test_index(test_name
);
6676 pr_err("test_bpf: no test named '%s' found.\n",
6680 test_range
[0] = idx
;
6681 test_range
[1] = idx
;
6684 * check that the supplied test_range is valid.
6686 if (test_range
[0] >= ARRAY_SIZE(tests
) ||
6687 test_range
[1] >= ARRAY_SIZE(tests
) ||
6688 test_range
[0] < 0 || test_range
[1] < 0) {
6689 pr_err("test_bpf: test_range is out of bound.\n");
6693 if (test_range
[1] < test_range
[0]) {
6694 pr_err("test_bpf: test_range is ending before it starts.\n");
6699 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++) {
6700 if (tests
[i
].fill_helper
&&
6701 tests
[i
].fill_helper(&tests
[i
]) < 0)
6708 static __init
void destroy_bpf_tests(void)
6712 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++) {
6713 if (tests
[i
].fill_helper
)
6714 kfree(tests
[i
].u
.ptr
.insns
);
6718 static bool exclude_test(int test_id
)
6720 return test_id
< test_range
[0] || test_id
> test_range
[1];
6723 static __init
struct sk_buff
*build_test_skb(void)
6725 u32 headroom
= NET_SKB_PAD
+ NET_IP_ALIGN
+ ETH_HLEN
;
6726 struct sk_buff
*skb
[2];
6727 struct page
*page
[2];
6728 int i
, data_size
= 8;
6730 for (i
= 0; i
< 2; i
++) {
6731 page
[i
] = alloc_page(GFP_KERNEL
);
6739 /* this will set skb[i]->head_frag */
6740 skb
[i
] = dev_alloc_skb(headroom
+ data_size
);
6748 skb_reserve(skb
[i
], headroom
);
6749 skb_put(skb
[i
], data_size
);
6750 skb
[i
]->protocol
= htons(ETH_P_IP
);
6751 skb_reset_network_header(skb
[i
]);
6752 skb_set_mac_header(skb
[i
], -ETH_HLEN
);
6754 skb_add_rx_frag(skb
[i
], 0, page
[i
], 0, 64, 64);
6755 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
6759 skb_shinfo(skb
[0])->gso_size
= 1448;
6760 skb_shinfo(skb
[0])->gso_type
= SKB_GSO_TCPV4
;
6761 skb_shinfo(skb
[0])->gso_type
|= SKB_GSO_DODGY
;
6762 skb_shinfo(skb
[0])->gso_segs
= 0;
6763 skb_shinfo(skb
[0])->frag_list
= skb
[1];
6765 /* adjust skb[0]'s len */
6766 skb
[0]->len
+= skb
[1]->len
;
6767 skb
[0]->data_len
+= skb
[1]->data_len
;
6768 skb
[0]->truesize
+= skb
[1]->truesize
;
6773 __free_page(page
[1]);
6777 __free_page(page
[0]);
6782 static __init
int test_skb_segment(void)
6784 netdev_features_t features
;
6785 struct sk_buff
*skb
, *segs
;
6788 features
= NETIF_F_SG
| NETIF_F_GSO_PARTIAL
| NETIF_F_IP_CSUM
|
6790 features
|= NETIF_F_RXCSUM
;
6791 skb
= build_test_skb();
6793 pr_info("%s: failed to build_test_skb", __func__
);
6797 segs
= skb_segment(skb
, features
);
6798 if (!IS_ERR(segs
)) {
6799 kfree_skb_list(segs
);
6801 pr_info("%s: success in skb_segment!", __func__
);
6803 pr_info("%s: failed in skb_segment!", __func__
);
6810 static __init
int test_bpf(void)
6812 int i
, err_cnt
= 0, pass_cnt
= 0;
6813 int jit_cnt
= 0, run_cnt
= 0;
6815 for (i
= 0; i
< ARRAY_SIZE(tests
); i
++) {
6816 struct bpf_prog
*fp
;
6820 if (exclude_test(i
))
6823 pr_info("#%d %s ", i
, tests
[i
].descr
);
6825 fp
= generate_filter(i
, &err
);
6835 pr_cont("jited:%u ", fp
->jited
);
6841 err
= run_one(fp
, &tests
[i
]);
6842 release_filter(fp
, i
);
6845 pr_cont("FAIL (%d times)\n", err
);
6853 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
6854 pass_cnt
, err_cnt
, jit_cnt
, run_cnt
);
6856 return err_cnt
? -EINVAL
: 0;
6859 static int __init
test_bpf_init(void)
6863 ret
= prepare_bpf_tests();
6868 destroy_bpf_tests();
6872 return test_skb_segment();
6875 static void __exit
test_bpf_exit(void)
6879 module_init(test_bpf_init
);
6880 module_exit(test_bpf_exit
);
6882 MODULE_LICENSE("GPL");