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>
28 /* General test specific settings */
29 #define MAX_SUBTESTS 3
30 #define MAX_TESTRUNS 10000
33 #define MAX_K 0xffffFFFF
35 /* Few constants used to init test 'skb' */
37 #define SKB_MARK 0x1234aaaa
38 #define SKB_HASH 0x1234aaab
39 #define SKB_QUEUE_MAP 123
40 #define SKB_VLAN_TCI 0xffff
41 #define SKB_DEV_IFINDEX 577
42 #define SKB_DEV_TYPE 588
44 /* Redefine REGs to make tests less verbose */
55 #define R10 BPF_REG_10
57 /* Flags that can be passed to test cases */
58 #define FLAG_NO_DATA BIT(0)
59 #define FLAG_EXPECTED_FAIL BIT(1)
60 #define FLAG_SKB_FRAG BIT(2)
63 CLASSIC = BIT(6), /* Old BPF instructions only. */
64 INTERNAL = BIT(7), /* Extended instruction set. */
67 #define TEST_TYPE_MASK (CLASSIC | INTERNAL)
72 struct sock_filter insns[MAX_INSNS];
73 struct bpf_insn insns_int[MAX_INSNS];
85 int (*fill_helper)(struct bpf_test *self);
86 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
87 __u8 frag_data[MAX_DATA];
88 int stack_depth; /* for eBPF only, since tests don't call verifier */
91 /* Large test cases need separate allocation and fill handler. */
93 static int bpf_fill_maxinsns1(struct bpf_test *self)
95 unsigned int len = BPF_MAXINSNS;
96 struct sock_filter *insn;
100 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
104 for (i = 0; i < len; i++, k--)
105 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
107 self->u.ptr.insns = insn;
108 self->u.ptr.len = len;
113 static int bpf_fill_maxinsns2(struct bpf_test *self)
115 unsigned int len = BPF_MAXINSNS;
116 struct sock_filter *insn;
119 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
123 for (i = 0; i < len; i++)
124 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
126 self->u.ptr.insns = insn;
127 self->u.ptr.len = len;
132 static int bpf_fill_maxinsns3(struct bpf_test *self)
134 unsigned int len = BPF_MAXINSNS;
135 struct sock_filter *insn;
136 struct rnd_state rnd;
139 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
143 prandom_seed_state(&rnd, 3141592653589793238ULL);
145 for (i = 0; i < len - 1; i++) {
146 __u32 k = prandom_u32_state(&rnd);
148 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
151 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
153 self->u.ptr.insns = insn;
154 self->u.ptr.len = len;
159 static int bpf_fill_maxinsns4(struct bpf_test *self)
161 unsigned int len = BPF_MAXINSNS + 1;
162 struct sock_filter *insn;
165 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
169 for (i = 0; i < len; i++)
170 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
172 self->u.ptr.insns = insn;
173 self->u.ptr.len = len;
178 static int bpf_fill_maxinsns5(struct bpf_test *self)
180 unsigned int len = BPF_MAXINSNS;
181 struct sock_filter *insn;
184 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
188 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
190 for (i = 1; i < len - 1; i++)
191 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
193 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
195 self->u.ptr.insns = insn;
196 self->u.ptr.len = len;
201 static int bpf_fill_maxinsns6(struct bpf_test *self)
203 unsigned int len = BPF_MAXINSNS;
204 struct sock_filter *insn;
207 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
211 for (i = 0; i < len - 1; i++)
212 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
213 SKF_AD_VLAN_TAG_PRESENT);
215 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
217 self->u.ptr.insns = insn;
218 self->u.ptr.len = len;
223 static int bpf_fill_maxinsns7(struct bpf_test *self)
225 unsigned int len = BPF_MAXINSNS;
226 struct sock_filter *insn;
229 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
233 for (i = 0; i < len - 4; i++)
234 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
237 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
238 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
240 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
241 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
243 self->u.ptr.insns = insn;
244 self->u.ptr.len = len;
249 static int bpf_fill_maxinsns8(struct bpf_test *self)
251 unsigned int len = BPF_MAXINSNS;
252 struct sock_filter *insn;
253 int i, jmp_off = len - 3;
255 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
259 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
261 for (i = 1; i < len - 1; i++)
262 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
264 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
266 self->u.ptr.insns = insn;
267 self->u.ptr.len = len;
272 static int bpf_fill_maxinsns9(struct bpf_test *self)
274 unsigned int len = BPF_MAXINSNS;
275 struct bpf_insn *insn;
278 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
282 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
283 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
284 insn[2] = BPF_EXIT_INSN();
286 for (i = 3; i < len - 2; i++)
287 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
289 insn[len - 2] = BPF_EXIT_INSN();
290 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
292 self->u.ptr.insns = insn;
293 self->u.ptr.len = len;
298 static int bpf_fill_maxinsns10(struct bpf_test *self)
300 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
301 struct bpf_insn *insn;
304 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
308 for (i = 0; i < hlen / 2; i++)
309 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
310 for (i = hlen - 1; i > hlen / 2; i--)
311 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
313 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
314 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
315 insn[hlen + 1] = BPF_EXIT_INSN();
317 self->u.ptr.insns = insn;
318 self->u.ptr.len = len;
323 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
326 struct sock_filter *insn;
330 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
334 rlen = (len % plen) - 1;
336 for (i = 0; i + plen < len; i += plen)
337 for (j = 0; j < plen; j++)
338 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
340 for (j = 0; j < rlen; j++)
341 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
344 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
346 self->u.ptr.insns = insn;
347 self->u.ptr.len = len;
352 static int bpf_fill_maxinsns11(struct bpf_test *self)
354 /* Hits 70 passes on x86_64, so cannot get JITed there. */
355 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
358 static int bpf_fill_maxinsns12(struct bpf_test *self)
360 unsigned int len = BPF_MAXINSNS;
361 struct sock_filter *insn;
364 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
368 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
370 for (i = 1; i < len - 1; i++)
371 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
373 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
375 self->u.ptr.insns = insn;
376 self->u.ptr.len = len;
381 static int bpf_fill_maxinsns13(struct bpf_test *self)
383 unsigned int len = BPF_MAXINSNS;
384 struct sock_filter *insn;
387 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
391 for (i = 0; i < len - 3; i++)
392 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
394 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
395 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
396 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
398 self->u.ptr.insns = insn;
399 self->u.ptr.len = len;
404 static int bpf_fill_ja(struct bpf_test *self)
406 /* Hits exactly 11 passes on x86_64 JIT. */
407 return __bpf_fill_ja(self, 12, 9);
410 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
412 unsigned int len = BPF_MAXINSNS;
413 struct sock_filter *insn;
416 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
420 for (i = 0; i < len - 1; i += 2) {
421 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
422 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
423 SKF_AD_OFF + SKF_AD_CPU);
426 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
428 self->u.ptr.insns = insn;
429 self->u.ptr.len = len;
435 /* test: {skb->data[0], vlan_push} x 68 + {skb->data[0], vlan_pop} x 68 */
436 static int bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
438 unsigned int len = BPF_MAXINSNS;
439 struct bpf_insn *insn;
442 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
446 insn[i++] = BPF_MOV64_REG(R6, R1);
448 for (j = 0; j < PUSH_CNT; j++) {
449 insn[i++] = BPF_LD_ABS(BPF_B, 0);
450 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
452 insn[i++] = BPF_MOV64_REG(R1, R6);
453 insn[i++] = BPF_MOV64_IMM(R2, 1);
454 insn[i++] = BPF_MOV64_IMM(R3, 2);
455 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
456 bpf_skb_vlan_push_proto.func - __bpf_call_base);
457 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
461 for (j = 0; j < PUSH_CNT; j++) {
462 insn[i++] = BPF_LD_ABS(BPF_B, 0);
463 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
465 insn[i++] = BPF_MOV64_REG(R1, R6);
466 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
467 bpf_skb_vlan_pop_proto.func - __bpf_call_base);
468 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
474 for (; i < len - 1; i++)
475 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xbef);
477 insn[len - 1] = BPF_EXIT_INSN();
479 self->u.ptr.insns = insn;
480 self->u.ptr.len = len;
485 static int bpf_fill_jump_around_ld_abs(struct bpf_test *self)
487 unsigned int len = BPF_MAXINSNS;
488 struct bpf_insn *insn;
491 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
495 insn[i++] = BPF_MOV64_REG(R6, R1);
496 insn[i++] = BPF_LD_ABS(BPF_B, 0);
497 insn[i] = BPF_JMP_IMM(BPF_JEQ, R0, 10, len - i - 2);
500 insn[i++] = BPF_LD_ABS(BPF_B, 1);
501 insn[i] = BPF_EXIT_INSN();
503 self->u.ptr.insns = insn;
504 self->u.ptr.len = len;
509 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
511 unsigned int len = BPF_MAXINSNS;
512 struct bpf_insn *insn;
515 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
519 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
520 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
522 for (i = 2; i < len - 2; i++)
523 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
525 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
526 insn[len - 1] = BPF_EXIT_INSN();
528 self->u.ptr.insns = insn;
529 self->u.ptr.len = len;
530 self->stack_depth = 40;
535 static int bpf_fill_stxw(struct bpf_test *self)
537 return __bpf_fill_stxdw(self, BPF_W);
540 static int bpf_fill_stxdw(struct bpf_test *self)
542 return __bpf_fill_stxdw(self, BPF_DW);
545 static struct bpf_test tests[] = {
549 BPF_STMT(BPF_LD | BPF_IMM, 1),
550 BPF_STMT(BPF_MISC | BPF_TAX, 0),
551 BPF_STMT(BPF_LD | BPF_IMM, 2),
552 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
553 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
554 BPF_STMT(BPF_MISC | BPF_TAX, 0),
555 BPF_STMT(BPF_LD | BPF_LEN, 0),
556 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
557 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
558 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
559 BPF_STMT(BPF_RET | BPF_A, 0)
562 { 10, 20, 30, 40, 50 },
563 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
568 BPF_STMT(BPF_LDX | BPF_LEN, 0),
569 BPF_STMT(BPF_MISC | BPF_TXA, 0),
570 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
571 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
574 { 10, 20, 30, 40, 50 },
575 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
580 BPF_STMT(BPF_LD | BPF_IMM, 1),
581 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
582 BPF_STMT(BPF_LDX | BPF_IMM, 3),
583 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
584 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
585 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
586 BPF_STMT(BPF_RET | BPF_A, 0)
588 CLASSIC | FLAG_NO_DATA,
590 { { 0, 0xfffffffd } }
595 BPF_STMT(BPF_LD | BPF_IMM, 8),
596 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
597 BPF_STMT(BPF_MISC | BPF_TAX, 0),
598 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
599 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
600 BPF_STMT(BPF_MISC | BPF_TAX, 0),
601 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
602 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
603 BPF_STMT(BPF_MISC | BPF_TAX, 0),
604 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
605 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
606 BPF_STMT(BPF_MISC | BPF_TAX, 0),
607 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
608 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
609 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
610 BPF_STMT(BPF_RET | BPF_A, 0)
612 CLASSIC | FLAG_NO_DATA,
614 { { 0, 0x20000000 } }
619 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
620 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
621 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
622 BPF_STMT(BPF_MISC | BPF_TAX, 0),
623 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
624 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
625 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
626 BPF_STMT(BPF_RET | BPF_A, 0)
628 CLASSIC | FLAG_NO_DATA,
630 { { 0, 0x800000ff }, { 1, 0x800000ff } },
635 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
636 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
637 BPF_STMT(BPF_RET | BPF_K, 0),
638 BPF_STMT(BPF_RET | BPF_K, 1),
647 BPF_STMT(BPF_LDX | BPF_LEN, 0),
648 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
649 BPF_STMT(BPF_RET | BPF_K, 1)
653 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
658 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
659 BPF_STMT(BPF_RET | BPF_K, 1)
663 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
668 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
669 BPF_STMT(BPF_MISC | BPF_TAX, 0),
670 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
671 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
672 BPF_STMT(BPF_RET | BPF_A, 0)
676 { { 1, 0 }, { 2, 3 } },
681 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
682 BPF_STMT(BPF_LDX | BPF_LEN, 0),
683 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
684 BPF_STMT(BPF_MISC | BPF_TAX, 0),
685 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
686 BPF_STMT(BPF_RET | BPF_A, 0)
690 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
695 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
696 BPF_STMT(BPF_MISC | BPF_TAX, 0),
697 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
698 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
699 BPF_STMT(BPF_RET | BPF_A, 0)
702 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
703 { { 15, 0 }, { 16, 3 } },
708 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
709 BPF_STMT(BPF_LDX | BPF_LEN, 0),
710 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
711 BPF_STMT(BPF_MISC | BPF_TAX, 0),
712 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
713 BPF_STMT(BPF_RET | BPF_A, 0)
716 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
717 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
722 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
723 SKF_AD_OFF + SKF_AD_PKTTYPE),
724 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
725 BPF_STMT(BPF_RET | BPF_K, 1),
726 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
727 SKF_AD_OFF + SKF_AD_PKTTYPE),
728 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
729 BPF_STMT(BPF_RET | BPF_K, 1),
730 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
731 SKF_AD_OFF + SKF_AD_PKTTYPE),
732 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
733 BPF_STMT(BPF_RET | BPF_K, 1),
734 BPF_STMT(BPF_RET | BPF_A, 0)
738 { { 1, 3 }, { 10, 3 } },
743 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
744 SKF_AD_OFF + SKF_AD_MARK),
745 BPF_STMT(BPF_RET | BPF_A, 0)
749 { { 1, SKB_MARK}, { 10, SKB_MARK} },
754 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
755 SKF_AD_OFF + SKF_AD_RXHASH),
756 BPF_STMT(BPF_RET | BPF_A, 0)
760 { { 1, SKB_HASH}, { 10, SKB_HASH} },
765 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
766 SKF_AD_OFF + SKF_AD_QUEUE),
767 BPF_STMT(BPF_RET | BPF_A, 0)
771 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
776 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
777 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
778 BPF_STMT(BPF_RET | BPF_K, 0),
779 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
780 SKF_AD_OFF + SKF_AD_PROTOCOL),
781 BPF_STMT(BPF_MISC | BPF_TAX, 0),
782 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
783 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
784 BPF_STMT(BPF_RET | BPF_K, 0),
785 BPF_STMT(BPF_MISC | BPF_TXA, 0),
786 BPF_STMT(BPF_RET | BPF_A, 0)
790 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
795 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
796 SKF_AD_OFF + SKF_AD_VLAN_TAG),
797 BPF_STMT(BPF_RET | BPF_A, 0)
802 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
803 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
807 "LD_VLAN_TAG_PRESENT",
809 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
810 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
811 BPF_STMT(BPF_RET | BPF_A, 0)
816 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
817 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
823 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
824 SKF_AD_OFF + SKF_AD_IFINDEX),
825 BPF_STMT(BPF_RET | BPF_A, 0)
829 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
834 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
835 SKF_AD_OFF + SKF_AD_HATYPE),
836 BPF_STMT(BPF_RET | BPF_A, 0)
840 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
845 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
846 SKF_AD_OFF + SKF_AD_CPU),
847 BPF_STMT(BPF_MISC | BPF_TAX, 0),
848 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
849 SKF_AD_OFF + SKF_AD_CPU),
850 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
851 BPF_STMT(BPF_RET | BPF_A, 0)
855 { { 1, 0 }, { 10, 0 } },
860 BPF_STMT(BPF_LDX | BPF_IMM, 2),
861 BPF_STMT(BPF_MISC | BPF_TXA, 0),
862 BPF_STMT(BPF_LDX | BPF_IMM, 3),
863 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
864 SKF_AD_OFF + SKF_AD_NLATTR),
865 BPF_STMT(BPF_RET | BPF_A, 0)
869 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
871 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
873 { { 4, 0 }, { 20, 6 } },
878 BPF_STMT(BPF_LD | BPF_IMM, 2),
879 BPF_STMT(BPF_LDX | BPF_IMM, 3),
880 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
881 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
882 BPF_STMT(BPF_LD | BPF_IMM, 2),
883 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
884 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
885 BPF_STMT(BPF_LD | BPF_IMM, 2),
886 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
887 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
888 BPF_STMT(BPF_LD | BPF_IMM, 2),
889 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
890 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
891 BPF_STMT(BPF_LD | BPF_IMM, 2),
892 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
893 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
894 BPF_STMT(BPF_LD | BPF_IMM, 2),
895 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
896 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
897 BPF_STMT(BPF_LD | BPF_IMM, 2),
898 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
899 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
900 BPF_STMT(BPF_LD | BPF_IMM, 2),
901 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
902 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
903 BPF_STMT(BPF_RET | BPF_A, 0)
907 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
909 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
911 { { 4, 0 }, { 20, 10 } },
916 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
917 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
918 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
919 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
920 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
921 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
922 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
923 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
924 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
925 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
926 BPF_STMT(BPF_RET | BPF_A, 0)
929 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
930 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
931 * id 9737, seq 1, length 64
933 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
934 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
936 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
937 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
938 { { 30, 0 }, { 100, 42 } },
943 BPF_STMT(BPF_LD | BPF_IMM, 10),
944 BPF_STMT(BPF_LDX | BPF_IMM, 300),
945 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
946 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
947 BPF_STMT(BPF_RET | BPF_A, 0)
951 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
956 BPF_STMT(BPF_LDX | BPF_LEN, 0),
957 BPF_STMT(BPF_LD | BPF_IMM, 2),
958 BPF_STMT(BPF_ALU | BPF_RSH, 1),
959 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
960 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
961 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
962 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
963 BPF_STMT(BPF_STX, 15), /* M3 = len */
964 BPF_STMT(BPF_LDX | BPF_MEM, 1),
965 BPF_STMT(BPF_LD | BPF_MEM, 2),
966 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
967 BPF_STMT(BPF_LDX | BPF_MEM, 15),
968 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
969 BPF_STMT(BPF_RET | BPF_A, 0)
973 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
978 BPF_STMT(BPF_LDX | BPF_LEN, 0),
979 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
980 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
981 BPF_STMT(BPF_RET | BPF_K, 1),
982 BPF_STMT(BPF_RET | BPF_K, MAX_K)
986 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
991 BPF_STMT(BPF_LDX | BPF_LEN, 0),
992 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
993 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
994 BPF_STMT(BPF_RET | BPF_K, 1),
995 BPF_STMT(BPF_RET | BPF_K, MAX_K)
999 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
1002 "JGE (jt 0), test 1",
1004 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1005 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
1006 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
1007 BPF_STMT(BPF_RET | BPF_K, 1),
1008 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1012 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
1015 "JGE (jt 0), test 2",
1017 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1018 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
1019 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
1020 BPF_STMT(BPF_RET | BPF_K, 1),
1021 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1025 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
1030 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1031 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
1032 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
1033 BPF_STMT(BPF_RET | BPF_K, 10),
1034 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
1035 BPF_STMT(BPF_RET | BPF_K, 20),
1036 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
1037 BPF_STMT(BPF_RET | BPF_K, 30),
1038 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
1039 BPF_STMT(BPF_RET | BPF_K, 40),
1040 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1044 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
1049 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1050 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
1051 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1052 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1053 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1054 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1055 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
1056 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1057 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
1058 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
1059 BPF_STMT(BPF_RET | BPF_K, 10),
1060 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
1061 BPF_STMT(BPF_RET | BPF_K, 20),
1062 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1063 BPF_STMT(BPF_RET | BPF_K, 30),
1064 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1065 BPF_STMT(BPF_RET | BPF_K, 30),
1066 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1067 BPF_STMT(BPF_RET | BPF_K, 30),
1068 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1069 BPF_STMT(BPF_RET | BPF_K, 30),
1070 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1071 BPF_STMT(BPF_RET | BPF_K, 30),
1072 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1075 { 0, 0xAA, 0x55, 1 },
1076 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
1081 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1082 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
1083 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
1084 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1085 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1086 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
1087 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
1088 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
1089 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
1090 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
1091 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
1092 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1093 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1094 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1095 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
1096 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1097 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
1098 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1099 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1100 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1101 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1102 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
1103 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1104 BPF_STMT(BPF_RET | BPF_K, 0),
1107 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
1108 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
1109 * seq 1305692979:1305693027, ack 3650467037, win 65535,
1110 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
1112 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1113 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1115 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1116 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1117 0x0a, 0x01, 0x01, 0x95, /* ip src */
1118 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1120 0x00, 0x16 /* dst port */ },
1121 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1126 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
1127 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
1128 * (len > 115 or len < 30000000000)' -d
1130 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1131 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
1132 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
1133 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1134 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1135 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1136 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1137 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1138 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1139 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1140 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1141 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1142 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1143 BPF_STMT(BPF_ST, 1),
1144 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1145 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1146 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1147 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1148 BPF_STMT(BPF_LD | BPF_MEM, 1),
1149 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1150 BPF_STMT(BPF_ST, 5),
1151 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1152 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1153 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1154 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1155 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1156 BPF_STMT(BPF_LD | BPF_MEM, 5),
1157 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1158 BPF_STMT(BPF_LD | BPF_LEN, 0),
1159 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1160 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1161 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1162 BPF_STMT(BPF_RET | BPF_K, 0),
1165 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1166 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1168 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1169 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1170 0x0a, 0x01, 0x01, 0x95, /* ip src */
1171 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1173 0x00, 0x16 /* dst port */ },
1174 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1179 /* check that unitialized X and A contain zeros */
1180 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1181 BPF_STMT(BPF_RET | BPF_A, 0)
1190 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1191 BPF_ALU64_IMM(BPF_ADD, R1, 2),
1192 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1193 BPF_ALU64_REG(BPF_SUB, R1, R2),
1194 BPF_ALU64_IMM(BPF_ADD, R1, -1),
1195 BPF_ALU64_IMM(BPF_MUL, R1, 3),
1196 BPF_ALU64_REG(BPF_MOV, R0, R1),
1201 { { 0, 0xfffffffd } }
1206 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1207 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1208 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1209 BPF_ALU64_REG(BPF_MUL, R1, R2),
1210 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1212 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1222 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1223 BPF_ALU32_IMM(BPF_MOV, R1, -1),
1224 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1225 BPF_ALU64_REG(BPF_MUL, R1, R2),
1226 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1227 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1229 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1239 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1240 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1241 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1242 BPF_ALU32_REG(BPF_MUL, R1, R2),
1243 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1244 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1246 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1254 /* Have to test all register combinations, since
1255 * JITing of different registers will produce
1256 * different asm code.
1260 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1261 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1262 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1263 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1264 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1265 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1266 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1267 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1268 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1269 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1270 BPF_ALU64_IMM(BPF_ADD, R0, 20),
1271 BPF_ALU64_IMM(BPF_ADD, R1, 20),
1272 BPF_ALU64_IMM(BPF_ADD, R2, 20),
1273 BPF_ALU64_IMM(BPF_ADD, R3, 20),
1274 BPF_ALU64_IMM(BPF_ADD, R4, 20),
1275 BPF_ALU64_IMM(BPF_ADD, R5, 20),
1276 BPF_ALU64_IMM(BPF_ADD, R6, 20),
1277 BPF_ALU64_IMM(BPF_ADD, R7, 20),
1278 BPF_ALU64_IMM(BPF_ADD, R8, 20),
1279 BPF_ALU64_IMM(BPF_ADD, R9, 20),
1280 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1281 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1282 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1283 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1284 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1285 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1286 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1287 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1288 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1289 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1290 BPF_ALU64_REG(BPF_ADD, R0, R0),
1291 BPF_ALU64_REG(BPF_ADD, R0, R1),
1292 BPF_ALU64_REG(BPF_ADD, R0, R2),
1293 BPF_ALU64_REG(BPF_ADD, R0, R3),
1294 BPF_ALU64_REG(BPF_ADD, R0, R4),
1295 BPF_ALU64_REG(BPF_ADD, R0, R5),
1296 BPF_ALU64_REG(BPF_ADD, R0, R6),
1297 BPF_ALU64_REG(BPF_ADD, R0, R7),
1298 BPF_ALU64_REG(BPF_ADD, R0, R8),
1299 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1300 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1302 BPF_ALU64_REG(BPF_ADD, R1, R0),
1303 BPF_ALU64_REG(BPF_ADD, R1, R1),
1304 BPF_ALU64_REG(BPF_ADD, R1, R2),
1305 BPF_ALU64_REG(BPF_ADD, R1, R3),
1306 BPF_ALU64_REG(BPF_ADD, R1, R4),
1307 BPF_ALU64_REG(BPF_ADD, R1, R5),
1308 BPF_ALU64_REG(BPF_ADD, R1, R6),
1309 BPF_ALU64_REG(BPF_ADD, R1, R7),
1310 BPF_ALU64_REG(BPF_ADD, R1, R8),
1311 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1312 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1314 BPF_ALU64_REG(BPF_ADD, R2, R0),
1315 BPF_ALU64_REG(BPF_ADD, R2, R1),
1316 BPF_ALU64_REG(BPF_ADD, R2, R2),
1317 BPF_ALU64_REG(BPF_ADD, R2, R3),
1318 BPF_ALU64_REG(BPF_ADD, R2, R4),
1319 BPF_ALU64_REG(BPF_ADD, R2, R5),
1320 BPF_ALU64_REG(BPF_ADD, R2, R6),
1321 BPF_ALU64_REG(BPF_ADD, R2, R7),
1322 BPF_ALU64_REG(BPF_ADD, R2, R8),
1323 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1324 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1326 BPF_ALU64_REG(BPF_ADD, R3, R0),
1327 BPF_ALU64_REG(BPF_ADD, R3, R1),
1328 BPF_ALU64_REG(BPF_ADD, R3, R2),
1329 BPF_ALU64_REG(BPF_ADD, R3, R3),
1330 BPF_ALU64_REG(BPF_ADD, R3, R4),
1331 BPF_ALU64_REG(BPF_ADD, R3, R5),
1332 BPF_ALU64_REG(BPF_ADD, R3, R6),
1333 BPF_ALU64_REG(BPF_ADD, R3, R7),
1334 BPF_ALU64_REG(BPF_ADD, R3, R8),
1335 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1336 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1338 BPF_ALU64_REG(BPF_ADD, R4, R0),
1339 BPF_ALU64_REG(BPF_ADD, R4, R1),
1340 BPF_ALU64_REG(BPF_ADD, R4, R2),
1341 BPF_ALU64_REG(BPF_ADD, R4, R3),
1342 BPF_ALU64_REG(BPF_ADD, R4, R4),
1343 BPF_ALU64_REG(BPF_ADD, R4, R5),
1344 BPF_ALU64_REG(BPF_ADD, R4, R6),
1345 BPF_ALU64_REG(BPF_ADD, R4, R7),
1346 BPF_ALU64_REG(BPF_ADD, R4, R8),
1347 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1348 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1350 BPF_ALU64_REG(BPF_ADD, R5, R0),
1351 BPF_ALU64_REG(BPF_ADD, R5, R1),
1352 BPF_ALU64_REG(BPF_ADD, R5, R2),
1353 BPF_ALU64_REG(BPF_ADD, R5, R3),
1354 BPF_ALU64_REG(BPF_ADD, R5, R4),
1355 BPF_ALU64_REG(BPF_ADD, R5, R5),
1356 BPF_ALU64_REG(BPF_ADD, R5, R6),
1357 BPF_ALU64_REG(BPF_ADD, R5, R7),
1358 BPF_ALU64_REG(BPF_ADD, R5, R8),
1359 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1360 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1362 BPF_ALU64_REG(BPF_ADD, R6, R0),
1363 BPF_ALU64_REG(BPF_ADD, R6, R1),
1364 BPF_ALU64_REG(BPF_ADD, R6, R2),
1365 BPF_ALU64_REG(BPF_ADD, R6, R3),
1366 BPF_ALU64_REG(BPF_ADD, R6, R4),
1367 BPF_ALU64_REG(BPF_ADD, R6, R5),
1368 BPF_ALU64_REG(BPF_ADD, R6, R6),
1369 BPF_ALU64_REG(BPF_ADD, R6, R7),
1370 BPF_ALU64_REG(BPF_ADD, R6, R8),
1371 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1372 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1374 BPF_ALU64_REG(BPF_ADD, R7, R0),
1375 BPF_ALU64_REG(BPF_ADD, R7, R1),
1376 BPF_ALU64_REG(BPF_ADD, R7, R2),
1377 BPF_ALU64_REG(BPF_ADD, R7, R3),
1378 BPF_ALU64_REG(BPF_ADD, R7, R4),
1379 BPF_ALU64_REG(BPF_ADD, R7, R5),
1380 BPF_ALU64_REG(BPF_ADD, R7, R6),
1381 BPF_ALU64_REG(BPF_ADD, R7, R7),
1382 BPF_ALU64_REG(BPF_ADD, R7, R8),
1383 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1384 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1386 BPF_ALU64_REG(BPF_ADD, R8, R0),
1387 BPF_ALU64_REG(BPF_ADD, R8, R1),
1388 BPF_ALU64_REG(BPF_ADD, R8, R2),
1389 BPF_ALU64_REG(BPF_ADD, R8, R3),
1390 BPF_ALU64_REG(BPF_ADD, R8, R4),
1391 BPF_ALU64_REG(BPF_ADD, R8, R5),
1392 BPF_ALU64_REG(BPF_ADD, R8, R6),
1393 BPF_ALU64_REG(BPF_ADD, R8, R7),
1394 BPF_ALU64_REG(BPF_ADD, R8, R8),
1395 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1396 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1398 BPF_ALU64_REG(BPF_ADD, R9, R0),
1399 BPF_ALU64_REG(BPF_ADD, R9, R1),
1400 BPF_ALU64_REG(BPF_ADD, R9, R2),
1401 BPF_ALU64_REG(BPF_ADD, R9, R3),
1402 BPF_ALU64_REG(BPF_ADD, R9, R4),
1403 BPF_ALU64_REG(BPF_ADD, R9, R5),
1404 BPF_ALU64_REG(BPF_ADD, R9, R6),
1405 BPF_ALU64_REG(BPF_ADD, R9, R7),
1406 BPF_ALU64_REG(BPF_ADD, R9, R8),
1407 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1408 BPF_ALU64_REG(BPF_MOV, R0, R9),
1418 BPF_ALU32_IMM(BPF_MOV, R0, 20),
1419 BPF_ALU32_IMM(BPF_MOV, R1, 1),
1420 BPF_ALU32_IMM(BPF_MOV, R2, 2),
1421 BPF_ALU32_IMM(BPF_MOV, R3, 3),
1422 BPF_ALU32_IMM(BPF_MOV, R4, 4),
1423 BPF_ALU32_IMM(BPF_MOV, R5, 5),
1424 BPF_ALU32_IMM(BPF_MOV, R6, 6),
1425 BPF_ALU32_IMM(BPF_MOV, R7, 7),
1426 BPF_ALU32_IMM(BPF_MOV, R8, 8),
1427 BPF_ALU32_IMM(BPF_MOV, R9, 9),
1428 BPF_ALU64_IMM(BPF_ADD, R1, 10),
1429 BPF_ALU64_IMM(BPF_ADD, R2, 10),
1430 BPF_ALU64_IMM(BPF_ADD, R3, 10),
1431 BPF_ALU64_IMM(BPF_ADD, R4, 10),
1432 BPF_ALU64_IMM(BPF_ADD, R5, 10),
1433 BPF_ALU64_IMM(BPF_ADD, R6, 10),
1434 BPF_ALU64_IMM(BPF_ADD, R7, 10),
1435 BPF_ALU64_IMM(BPF_ADD, R8, 10),
1436 BPF_ALU64_IMM(BPF_ADD, R9, 10),
1437 BPF_ALU32_REG(BPF_ADD, R0, R1),
1438 BPF_ALU32_REG(BPF_ADD, R0, R2),
1439 BPF_ALU32_REG(BPF_ADD, R0, R3),
1440 BPF_ALU32_REG(BPF_ADD, R0, R4),
1441 BPF_ALU32_REG(BPF_ADD, R0, R5),
1442 BPF_ALU32_REG(BPF_ADD, R0, R6),
1443 BPF_ALU32_REG(BPF_ADD, R0, R7),
1444 BPF_ALU32_REG(BPF_ADD, R0, R8),
1445 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1446 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1448 BPF_ALU32_REG(BPF_ADD, R1, R0),
1449 BPF_ALU32_REG(BPF_ADD, R1, R1),
1450 BPF_ALU32_REG(BPF_ADD, R1, R2),
1451 BPF_ALU32_REG(BPF_ADD, R1, R3),
1452 BPF_ALU32_REG(BPF_ADD, R1, R4),
1453 BPF_ALU32_REG(BPF_ADD, R1, R5),
1454 BPF_ALU32_REG(BPF_ADD, R1, R6),
1455 BPF_ALU32_REG(BPF_ADD, R1, R7),
1456 BPF_ALU32_REG(BPF_ADD, R1, R8),
1457 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1458 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1460 BPF_ALU32_REG(BPF_ADD, R2, R0),
1461 BPF_ALU32_REG(BPF_ADD, R2, R1),
1462 BPF_ALU32_REG(BPF_ADD, R2, R2),
1463 BPF_ALU32_REG(BPF_ADD, R2, R3),
1464 BPF_ALU32_REG(BPF_ADD, R2, R4),
1465 BPF_ALU32_REG(BPF_ADD, R2, R5),
1466 BPF_ALU32_REG(BPF_ADD, R2, R6),
1467 BPF_ALU32_REG(BPF_ADD, R2, R7),
1468 BPF_ALU32_REG(BPF_ADD, R2, R8),
1469 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1470 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1472 BPF_ALU32_REG(BPF_ADD, R3, R0),
1473 BPF_ALU32_REG(BPF_ADD, R3, R1),
1474 BPF_ALU32_REG(BPF_ADD, R3, R2),
1475 BPF_ALU32_REG(BPF_ADD, R3, R3),
1476 BPF_ALU32_REG(BPF_ADD, R3, R4),
1477 BPF_ALU32_REG(BPF_ADD, R3, R5),
1478 BPF_ALU32_REG(BPF_ADD, R3, R6),
1479 BPF_ALU32_REG(BPF_ADD, R3, R7),
1480 BPF_ALU32_REG(BPF_ADD, R3, R8),
1481 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1482 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1484 BPF_ALU32_REG(BPF_ADD, R4, R0),
1485 BPF_ALU32_REG(BPF_ADD, R4, R1),
1486 BPF_ALU32_REG(BPF_ADD, R4, R2),
1487 BPF_ALU32_REG(BPF_ADD, R4, R3),
1488 BPF_ALU32_REG(BPF_ADD, R4, R4),
1489 BPF_ALU32_REG(BPF_ADD, R4, R5),
1490 BPF_ALU32_REG(BPF_ADD, R4, R6),
1491 BPF_ALU32_REG(BPF_ADD, R4, R7),
1492 BPF_ALU32_REG(BPF_ADD, R4, R8),
1493 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1494 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1496 BPF_ALU32_REG(BPF_ADD, R5, R0),
1497 BPF_ALU32_REG(BPF_ADD, R5, R1),
1498 BPF_ALU32_REG(BPF_ADD, R5, R2),
1499 BPF_ALU32_REG(BPF_ADD, R5, R3),
1500 BPF_ALU32_REG(BPF_ADD, R5, R4),
1501 BPF_ALU32_REG(BPF_ADD, R5, R5),
1502 BPF_ALU32_REG(BPF_ADD, R5, R6),
1503 BPF_ALU32_REG(BPF_ADD, R5, R7),
1504 BPF_ALU32_REG(BPF_ADD, R5, R8),
1505 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1506 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1508 BPF_ALU32_REG(BPF_ADD, R6, R0),
1509 BPF_ALU32_REG(BPF_ADD, R6, R1),
1510 BPF_ALU32_REG(BPF_ADD, R6, R2),
1511 BPF_ALU32_REG(BPF_ADD, R6, R3),
1512 BPF_ALU32_REG(BPF_ADD, R6, R4),
1513 BPF_ALU32_REG(BPF_ADD, R6, R5),
1514 BPF_ALU32_REG(BPF_ADD, R6, R6),
1515 BPF_ALU32_REG(BPF_ADD, R6, R7),
1516 BPF_ALU32_REG(BPF_ADD, R6, R8),
1517 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1518 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1520 BPF_ALU32_REG(BPF_ADD, R7, R0),
1521 BPF_ALU32_REG(BPF_ADD, R7, R1),
1522 BPF_ALU32_REG(BPF_ADD, R7, R2),
1523 BPF_ALU32_REG(BPF_ADD, R7, R3),
1524 BPF_ALU32_REG(BPF_ADD, R7, R4),
1525 BPF_ALU32_REG(BPF_ADD, R7, R5),
1526 BPF_ALU32_REG(BPF_ADD, R7, R6),
1527 BPF_ALU32_REG(BPF_ADD, R7, R7),
1528 BPF_ALU32_REG(BPF_ADD, R7, R8),
1529 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1530 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1532 BPF_ALU32_REG(BPF_ADD, R8, R0),
1533 BPF_ALU32_REG(BPF_ADD, R8, R1),
1534 BPF_ALU32_REG(BPF_ADD, R8, R2),
1535 BPF_ALU32_REG(BPF_ADD, R8, R3),
1536 BPF_ALU32_REG(BPF_ADD, R8, R4),
1537 BPF_ALU32_REG(BPF_ADD, R8, R5),
1538 BPF_ALU32_REG(BPF_ADD, R8, R6),
1539 BPF_ALU32_REG(BPF_ADD, R8, R7),
1540 BPF_ALU32_REG(BPF_ADD, R8, R8),
1541 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1542 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1544 BPF_ALU32_REG(BPF_ADD, R9, R0),
1545 BPF_ALU32_REG(BPF_ADD, R9, R1),
1546 BPF_ALU32_REG(BPF_ADD, R9, R2),
1547 BPF_ALU32_REG(BPF_ADD, R9, R3),
1548 BPF_ALU32_REG(BPF_ADD, R9, R4),
1549 BPF_ALU32_REG(BPF_ADD, R9, R5),
1550 BPF_ALU32_REG(BPF_ADD, R9, R6),
1551 BPF_ALU32_REG(BPF_ADD, R9, R7),
1552 BPF_ALU32_REG(BPF_ADD, R9, R8),
1553 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1554 BPF_ALU32_REG(BPF_MOV, R0, R9),
1561 { /* Mainly checking JIT here. */
1564 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1565 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1566 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1567 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1568 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1569 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1570 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1571 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1572 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1573 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1574 BPF_ALU64_REG(BPF_SUB, R0, R0),
1575 BPF_ALU64_REG(BPF_SUB, R0, R1),
1576 BPF_ALU64_REG(BPF_SUB, R0, R2),
1577 BPF_ALU64_REG(BPF_SUB, R0, R3),
1578 BPF_ALU64_REG(BPF_SUB, R0, R4),
1579 BPF_ALU64_REG(BPF_SUB, R0, R5),
1580 BPF_ALU64_REG(BPF_SUB, R0, R6),
1581 BPF_ALU64_REG(BPF_SUB, R0, R7),
1582 BPF_ALU64_REG(BPF_SUB, R0, R8),
1583 BPF_ALU64_REG(BPF_SUB, R0, R9),
1584 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1585 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1587 BPF_ALU64_REG(BPF_SUB, R1, R0),
1588 BPF_ALU64_REG(BPF_SUB, R1, R2),
1589 BPF_ALU64_REG(BPF_SUB, R1, R3),
1590 BPF_ALU64_REG(BPF_SUB, R1, R4),
1591 BPF_ALU64_REG(BPF_SUB, R1, R5),
1592 BPF_ALU64_REG(BPF_SUB, R1, R6),
1593 BPF_ALU64_REG(BPF_SUB, R1, R7),
1594 BPF_ALU64_REG(BPF_SUB, R1, R8),
1595 BPF_ALU64_REG(BPF_SUB, R1, R9),
1596 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1597 BPF_ALU64_REG(BPF_SUB, R2, R0),
1598 BPF_ALU64_REG(BPF_SUB, R2, R1),
1599 BPF_ALU64_REG(BPF_SUB, R2, R3),
1600 BPF_ALU64_REG(BPF_SUB, R2, R4),
1601 BPF_ALU64_REG(BPF_SUB, R2, R5),
1602 BPF_ALU64_REG(BPF_SUB, R2, R6),
1603 BPF_ALU64_REG(BPF_SUB, R2, R7),
1604 BPF_ALU64_REG(BPF_SUB, R2, R8),
1605 BPF_ALU64_REG(BPF_SUB, R2, R9),
1606 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1607 BPF_ALU64_REG(BPF_SUB, R3, R0),
1608 BPF_ALU64_REG(BPF_SUB, R3, R1),
1609 BPF_ALU64_REG(BPF_SUB, R3, R2),
1610 BPF_ALU64_REG(BPF_SUB, R3, R4),
1611 BPF_ALU64_REG(BPF_SUB, R3, R5),
1612 BPF_ALU64_REG(BPF_SUB, R3, R6),
1613 BPF_ALU64_REG(BPF_SUB, R3, R7),
1614 BPF_ALU64_REG(BPF_SUB, R3, R8),
1615 BPF_ALU64_REG(BPF_SUB, R3, R9),
1616 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1617 BPF_ALU64_REG(BPF_SUB, R4, R0),
1618 BPF_ALU64_REG(BPF_SUB, R4, R1),
1619 BPF_ALU64_REG(BPF_SUB, R4, R2),
1620 BPF_ALU64_REG(BPF_SUB, R4, R3),
1621 BPF_ALU64_REG(BPF_SUB, R4, R5),
1622 BPF_ALU64_REG(BPF_SUB, R4, R6),
1623 BPF_ALU64_REG(BPF_SUB, R4, R7),
1624 BPF_ALU64_REG(BPF_SUB, R4, R8),
1625 BPF_ALU64_REG(BPF_SUB, R4, R9),
1626 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1627 BPF_ALU64_REG(BPF_SUB, R5, R0),
1628 BPF_ALU64_REG(BPF_SUB, R5, R1),
1629 BPF_ALU64_REG(BPF_SUB, R5, R2),
1630 BPF_ALU64_REG(BPF_SUB, R5, R3),
1631 BPF_ALU64_REG(BPF_SUB, R5, R4),
1632 BPF_ALU64_REG(BPF_SUB, R5, R6),
1633 BPF_ALU64_REG(BPF_SUB, R5, R7),
1634 BPF_ALU64_REG(BPF_SUB, R5, R8),
1635 BPF_ALU64_REG(BPF_SUB, R5, R9),
1636 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1637 BPF_ALU64_REG(BPF_SUB, R6, R0),
1638 BPF_ALU64_REG(BPF_SUB, R6, R1),
1639 BPF_ALU64_REG(BPF_SUB, R6, R2),
1640 BPF_ALU64_REG(BPF_SUB, R6, R3),
1641 BPF_ALU64_REG(BPF_SUB, R6, R4),
1642 BPF_ALU64_REG(BPF_SUB, R6, R5),
1643 BPF_ALU64_REG(BPF_SUB, R6, R7),
1644 BPF_ALU64_REG(BPF_SUB, R6, R8),
1645 BPF_ALU64_REG(BPF_SUB, R6, R9),
1646 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1647 BPF_ALU64_REG(BPF_SUB, R7, R0),
1648 BPF_ALU64_REG(BPF_SUB, R7, R1),
1649 BPF_ALU64_REG(BPF_SUB, R7, R2),
1650 BPF_ALU64_REG(BPF_SUB, R7, R3),
1651 BPF_ALU64_REG(BPF_SUB, R7, R4),
1652 BPF_ALU64_REG(BPF_SUB, R7, R5),
1653 BPF_ALU64_REG(BPF_SUB, R7, R6),
1654 BPF_ALU64_REG(BPF_SUB, R7, R8),
1655 BPF_ALU64_REG(BPF_SUB, R7, R9),
1656 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1657 BPF_ALU64_REG(BPF_SUB, R8, R0),
1658 BPF_ALU64_REG(BPF_SUB, R8, R1),
1659 BPF_ALU64_REG(BPF_SUB, R8, R2),
1660 BPF_ALU64_REG(BPF_SUB, R8, R3),
1661 BPF_ALU64_REG(BPF_SUB, R8, R4),
1662 BPF_ALU64_REG(BPF_SUB, R8, R5),
1663 BPF_ALU64_REG(BPF_SUB, R8, R6),
1664 BPF_ALU64_REG(BPF_SUB, R8, R7),
1665 BPF_ALU64_REG(BPF_SUB, R8, R9),
1666 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1667 BPF_ALU64_REG(BPF_SUB, R9, R0),
1668 BPF_ALU64_REG(BPF_SUB, R9, R1),
1669 BPF_ALU64_REG(BPF_SUB, R9, R2),
1670 BPF_ALU64_REG(BPF_SUB, R9, R3),
1671 BPF_ALU64_REG(BPF_SUB, R9, R4),
1672 BPF_ALU64_REG(BPF_SUB, R9, R5),
1673 BPF_ALU64_REG(BPF_SUB, R9, R6),
1674 BPF_ALU64_REG(BPF_SUB, R9, R7),
1675 BPF_ALU64_REG(BPF_SUB, R9, R8),
1676 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1677 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1678 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1679 BPF_ALU64_REG(BPF_SUB, R0, R1),
1680 BPF_ALU64_REG(BPF_SUB, R0, R2),
1681 BPF_ALU64_REG(BPF_SUB, R0, R3),
1682 BPF_ALU64_REG(BPF_SUB, R0, R4),
1683 BPF_ALU64_REG(BPF_SUB, R0, R5),
1684 BPF_ALU64_REG(BPF_SUB, R0, R6),
1685 BPF_ALU64_REG(BPF_SUB, R0, R7),
1686 BPF_ALU64_REG(BPF_SUB, R0, R8),
1687 BPF_ALU64_REG(BPF_SUB, R0, R9),
1694 { /* Mainly checking JIT here. */
1697 BPF_ALU64_REG(BPF_SUB, R0, R0),
1698 BPF_ALU64_REG(BPF_XOR, R1, R1),
1699 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1701 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1702 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1703 BPF_ALU64_REG(BPF_SUB, R1, R1),
1704 BPF_ALU64_REG(BPF_XOR, R2, R2),
1705 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1707 BPF_ALU64_REG(BPF_SUB, R2, R2),
1708 BPF_ALU64_REG(BPF_XOR, R3, R3),
1709 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1710 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1711 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1713 BPF_ALU64_REG(BPF_SUB, R3, R3),
1714 BPF_ALU64_REG(BPF_XOR, R4, R4),
1715 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1716 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1717 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1719 BPF_ALU64_REG(BPF_SUB, R4, R4),
1720 BPF_ALU64_REG(BPF_XOR, R5, R5),
1721 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1722 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1723 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1725 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1726 BPF_ALU64_REG(BPF_SUB, R5, R5),
1727 BPF_ALU64_REG(BPF_XOR, R6, R6),
1728 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1729 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1730 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1732 BPF_ALU64_REG(BPF_SUB, R6, R6),
1733 BPF_ALU64_REG(BPF_XOR, R7, R7),
1734 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1736 BPF_ALU64_REG(BPF_SUB, R7, R7),
1737 BPF_ALU64_REG(BPF_XOR, R8, R8),
1738 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1740 BPF_ALU64_REG(BPF_SUB, R8, R8),
1741 BPF_ALU64_REG(BPF_XOR, R9, R9),
1742 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1744 BPF_ALU64_REG(BPF_SUB, R9, R9),
1745 BPF_ALU64_REG(BPF_XOR, R0, R0),
1746 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1748 BPF_ALU64_REG(BPF_SUB, R1, R1),
1749 BPF_ALU64_REG(BPF_XOR, R0, R0),
1750 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1751 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1753 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1760 { /* Mainly checking JIT here. */
1763 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1764 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1765 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1766 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1767 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1768 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1769 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1770 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1771 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1772 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1773 BPF_ALU64_REG(BPF_MUL, R0, R0),
1774 BPF_ALU64_REG(BPF_MUL, R0, R1),
1775 BPF_ALU64_REG(BPF_MUL, R0, R2),
1776 BPF_ALU64_REG(BPF_MUL, R0, R3),
1777 BPF_ALU64_REG(BPF_MUL, R0, R4),
1778 BPF_ALU64_REG(BPF_MUL, R0, R5),
1779 BPF_ALU64_REG(BPF_MUL, R0, R6),
1780 BPF_ALU64_REG(BPF_MUL, R0, R7),
1781 BPF_ALU64_REG(BPF_MUL, R0, R8),
1782 BPF_ALU64_REG(BPF_MUL, R0, R9),
1783 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1784 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1786 BPF_ALU64_REG(BPF_MUL, R1, R0),
1787 BPF_ALU64_REG(BPF_MUL, R1, R2),
1788 BPF_ALU64_REG(BPF_MUL, R1, R3),
1789 BPF_ALU64_REG(BPF_MUL, R1, R4),
1790 BPF_ALU64_REG(BPF_MUL, R1, R5),
1791 BPF_ALU64_REG(BPF_MUL, R1, R6),
1792 BPF_ALU64_REG(BPF_MUL, R1, R7),
1793 BPF_ALU64_REG(BPF_MUL, R1, R8),
1794 BPF_ALU64_REG(BPF_MUL, R1, R9),
1795 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1796 BPF_ALU64_REG(BPF_MOV, R2, R1),
1797 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1798 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1800 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1801 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1802 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1804 BPF_ALU64_REG(BPF_MUL, R2, R0),
1805 BPF_ALU64_REG(BPF_MUL, R2, R1),
1806 BPF_ALU64_REG(BPF_MUL, R2, R3),
1807 BPF_ALU64_REG(BPF_MUL, R2, R4),
1808 BPF_ALU64_REG(BPF_MUL, R2, R5),
1809 BPF_ALU64_REG(BPF_MUL, R2, R6),
1810 BPF_ALU64_REG(BPF_MUL, R2, R7),
1811 BPF_ALU64_REG(BPF_MUL, R2, R8),
1812 BPF_ALU64_REG(BPF_MUL, R2, R9),
1813 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1814 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1815 BPF_ALU64_REG(BPF_MOV, R0, R2),
1820 { { 0, 0x35d97ef2 } }
1822 { /* Mainly checking JIT here. */
1825 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1826 BPF_MOV64_REG(R1, R0),
1827 BPF_MOV64_REG(R2, R1),
1828 BPF_MOV64_REG(R3, R2),
1829 BPF_MOV64_REG(R4, R3),
1830 BPF_MOV64_REG(R5, R4),
1831 BPF_MOV64_REG(R6, R5),
1832 BPF_MOV64_REG(R7, R6),
1833 BPF_MOV64_REG(R8, R7),
1834 BPF_MOV64_REG(R9, R8),
1835 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1836 BPF_ALU64_IMM(BPF_MOV, R1, 0),
1837 BPF_ALU64_IMM(BPF_MOV, R2, 0),
1838 BPF_ALU64_IMM(BPF_MOV, R3, 0),
1839 BPF_ALU64_IMM(BPF_MOV, R4, 0),
1840 BPF_ALU64_IMM(BPF_MOV, R5, 0),
1841 BPF_ALU64_IMM(BPF_MOV, R6, 0),
1842 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1843 BPF_ALU64_IMM(BPF_MOV, R8, 0),
1844 BPF_ALU64_IMM(BPF_MOV, R9, 0),
1845 BPF_ALU64_REG(BPF_ADD, R0, R0),
1846 BPF_ALU64_REG(BPF_ADD, R0, R1),
1847 BPF_ALU64_REG(BPF_ADD, R0, R2),
1848 BPF_ALU64_REG(BPF_ADD, R0, R3),
1849 BPF_ALU64_REG(BPF_ADD, R0, R4),
1850 BPF_ALU64_REG(BPF_ADD, R0, R5),
1851 BPF_ALU64_REG(BPF_ADD, R0, R6),
1852 BPF_ALU64_REG(BPF_ADD, R0, R7),
1853 BPF_ALU64_REG(BPF_ADD, R0, R8),
1854 BPF_ALU64_REG(BPF_ADD, R0, R9),
1855 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1862 { /* Mainly checking JIT here. */
1865 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1866 BPF_MOV64_REG(R1, R0),
1867 BPF_MOV64_REG(R2, R1),
1868 BPF_MOV64_REG(R3, R2),
1869 BPF_MOV64_REG(R4, R3),
1870 BPF_MOV64_REG(R5, R4),
1871 BPF_MOV64_REG(R6, R5),
1872 BPF_MOV64_REG(R7, R6),
1873 BPF_MOV64_REG(R8, R7),
1874 BPF_MOV64_REG(R9, R8),
1875 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1876 BPF_ALU32_IMM(BPF_MOV, R1, 0),
1877 BPF_ALU32_IMM(BPF_MOV, R2, 0),
1878 BPF_ALU32_IMM(BPF_MOV, R3, 0),
1879 BPF_ALU32_IMM(BPF_MOV, R4, 0),
1880 BPF_ALU32_IMM(BPF_MOV, R5, 0),
1881 BPF_ALU32_IMM(BPF_MOV, R6, 0),
1882 BPF_ALU32_IMM(BPF_MOV, R7, 0),
1883 BPF_ALU32_IMM(BPF_MOV, R8, 0),
1884 BPF_ALU32_IMM(BPF_MOV, R9, 0),
1885 BPF_ALU64_REG(BPF_ADD, R0, R0),
1886 BPF_ALU64_REG(BPF_ADD, R0, R1),
1887 BPF_ALU64_REG(BPF_ADD, R0, R2),
1888 BPF_ALU64_REG(BPF_ADD, R0, R3),
1889 BPF_ALU64_REG(BPF_ADD, R0, R4),
1890 BPF_ALU64_REG(BPF_ADD, R0, R5),
1891 BPF_ALU64_REG(BPF_ADD, R0, R6),
1892 BPF_ALU64_REG(BPF_ADD, R0, R7),
1893 BPF_ALU64_REG(BPF_ADD, R0, R8),
1894 BPF_ALU64_REG(BPF_ADD, R0, R9),
1895 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1902 { /* Mainly checking JIT here. */
1905 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1906 BPF_MOV64_REG(R1, R0),
1907 BPF_MOV64_REG(R2, R1),
1908 BPF_MOV64_REG(R3, R2),
1909 BPF_MOV64_REG(R4, R3),
1910 BPF_MOV64_REG(R5, R4),
1911 BPF_MOV64_REG(R6, R5),
1912 BPF_MOV64_REG(R7, R6),
1913 BPF_MOV64_REG(R8, R7),
1914 BPF_MOV64_REG(R9, R8),
1915 BPF_LD_IMM64(R0, 0x0LL),
1916 BPF_LD_IMM64(R1, 0x0LL),
1917 BPF_LD_IMM64(R2, 0x0LL),
1918 BPF_LD_IMM64(R3, 0x0LL),
1919 BPF_LD_IMM64(R4, 0x0LL),
1920 BPF_LD_IMM64(R5, 0x0LL),
1921 BPF_LD_IMM64(R6, 0x0LL),
1922 BPF_LD_IMM64(R7, 0x0LL),
1923 BPF_LD_IMM64(R8, 0x0LL),
1924 BPF_LD_IMM64(R9, 0x0LL),
1925 BPF_ALU64_REG(BPF_ADD, R0, R0),
1926 BPF_ALU64_REG(BPF_ADD, R0, R1),
1927 BPF_ALU64_REG(BPF_ADD, R0, R2),
1928 BPF_ALU64_REG(BPF_ADD, R0, R3),
1929 BPF_ALU64_REG(BPF_ADD, R0, R4),
1930 BPF_ALU64_REG(BPF_ADD, R0, R5),
1931 BPF_ALU64_REG(BPF_ADD, R0, R6),
1932 BPF_ALU64_REG(BPF_ADD, R0, R7),
1933 BPF_ALU64_REG(BPF_ADD, R0, R8),
1934 BPF_ALU64_REG(BPF_ADD, R0, R9),
1935 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1945 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1946 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1947 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1948 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1949 BPF_ALU64_REG(BPF_DIV, R0, R2),
1950 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1952 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1953 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1955 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1963 "INT: shifts by register",
1965 BPF_MOV64_IMM(R0, -1234),
1966 BPF_MOV64_IMM(R1, 1),
1967 BPF_ALU32_REG(BPF_RSH, R0, R1),
1968 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1970 BPF_MOV64_IMM(R2, 1),
1971 BPF_ALU64_REG(BPF_LSH, R0, R2),
1972 BPF_MOV32_IMM(R4, -1234),
1973 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1975 BPF_ALU64_IMM(BPF_AND, R4, 63),
1976 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1977 BPF_MOV64_IMM(R3, 47),
1978 BPF_ALU64_REG(BPF_ARSH, R0, R3),
1979 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1981 BPF_MOV64_IMM(R2, 1),
1982 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1983 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1985 BPF_MOV64_IMM(R4, 4),
1986 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1987 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1989 BPF_MOV64_IMM(R4, 5),
1990 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1991 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1993 BPF_MOV64_IMM(R0, -1),
2003 BPF_ALU64_REG(BPF_MOV, R6, R1),
2004 BPF_LD_ABS(BPF_B, 3),
2005 BPF_ALU64_IMM(BPF_MOV, R2, 2),
2006 BPF_ALU32_REG(BPF_DIV, R0, R2),
2007 BPF_ALU64_REG(BPF_MOV, R8, R0),
2008 BPF_LD_ABS(BPF_B, 4),
2009 BPF_ALU64_REG(BPF_ADD, R8, R0),
2010 BPF_LD_IND(BPF_B, R8, -70),
2014 { 10, 20, 30, 40, 50 },
2015 { { 4, 0 }, { 5, 10 } }
2020 BPF_ALU64_REG(BPF_MOV, R6, R1),
2021 BPF_ALU64_IMM(BPF_MOV, R7, 0),
2022 BPF_LD_ABS(BPF_B, 3),
2023 BPF_ALU32_REG(BPF_DIV, R0, R7),
2027 { 10, 20, 30, 40, 50 },
2028 { { 3, 0 }, { 4, 0 } }
2031 "check: missing ret",
2033 BPF_STMT(BPF_LD | BPF_IMM, 1),
2035 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2038 .fill_helper = NULL,
2039 .expected_errcode = -EINVAL,
2044 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
2045 BPF_STMT(BPF_RET | BPF_K, 0)
2047 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2050 .fill_helper = NULL,
2051 .expected_errcode = -EINVAL,
2054 "check: unknown insn",
2056 /* seccomp insn, rejected in socket filter */
2057 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
2058 BPF_STMT(BPF_RET | BPF_K, 0)
2060 CLASSIC | FLAG_EXPECTED_FAIL,
2063 .fill_helper = NULL,
2064 .expected_errcode = -EINVAL,
2067 "check: out of range spill/fill",
2069 BPF_STMT(BPF_STX, 16),
2070 BPF_STMT(BPF_RET | BPF_K, 0)
2072 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2075 .fill_helper = NULL,
2076 .expected_errcode = -EINVAL,
2081 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2082 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
2083 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2084 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2085 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2086 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2087 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2088 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2089 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2090 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2091 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2092 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2093 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2094 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2095 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2096 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
2097 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2098 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
2099 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2100 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2101 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2102 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2103 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2104 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2105 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2106 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2107 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2108 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2109 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2110 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2111 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2112 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2113 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2114 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2115 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
2116 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
2117 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2118 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2119 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2120 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2121 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2122 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2123 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2124 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2125 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2126 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2127 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2128 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2129 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2130 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2131 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2132 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2133 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
2134 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
2135 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2136 BPF_STMT(BPF_RET | BPF_A, 0),
2137 BPF_STMT(BPF_RET | BPF_A, 0),
2140 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2141 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2143 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2144 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2145 0xc0, 0xa8, 0x33, 0x01,
2146 0xc0, 0xa8, 0x33, 0x02,
2149 0x00, 0x14, 0x00, 0x00,
2150 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2151 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2152 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2153 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2154 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2155 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2156 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2157 0xcc, 0xcc, 0xcc, 0xcc },
2163 BPF_STMT(BPF_RET | BPF_X, 0),
2165 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2168 .fill_helper = NULL,
2169 .expected_errcode = -EINVAL,
2172 "check: LDX + RET X",
2174 BPF_STMT(BPF_LDX | BPF_IMM, 42),
2175 BPF_STMT(BPF_RET | BPF_X, 0),
2177 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2180 .fill_helper = NULL,
2181 .expected_errcode = -EINVAL,
2183 { /* Mainly checking JIT here. */
2184 "M[]: alt STX + LDX",
2186 BPF_STMT(BPF_LDX | BPF_IMM, 100),
2187 BPF_STMT(BPF_STX, 0),
2188 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2189 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2190 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2191 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2192 BPF_STMT(BPF_STX, 1),
2193 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2194 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2195 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2196 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2197 BPF_STMT(BPF_STX, 2),
2198 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2199 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2200 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2201 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2202 BPF_STMT(BPF_STX, 3),
2203 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2204 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2205 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2206 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2207 BPF_STMT(BPF_STX, 4),
2208 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2209 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2210 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2211 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2212 BPF_STMT(BPF_STX, 5),
2213 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2214 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2215 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2216 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2217 BPF_STMT(BPF_STX, 6),
2218 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2219 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2220 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2221 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2222 BPF_STMT(BPF_STX, 7),
2223 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2224 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2225 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2226 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2227 BPF_STMT(BPF_STX, 8),
2228 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2229 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2230 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2231 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2232 BPF_STMT(BPF_STX, 9),
2233 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2234 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2235 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2236 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2237 BPF_STMT(BPF_STX, 10),
2238 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2239 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2240 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2241 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2242 BPF_STMT(BPF_STX, 11),
2243 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2244 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2245 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2246 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2247 BPF_STMT(BPF_STX, 12),
2248 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2249 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2250 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2251 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2252 BPF_STMT(BPF_STX, 13),
2253 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2254 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2255 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2256 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2257 BPF_STMT(BPF_STX, 14),
2258 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2259 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2260 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2261 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2262 BPF_STMT(BPF_STX, 15),
2263 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2264 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2265 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2266 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2267 BPF_STMT(BPF_RET | BPF_A, 0),
2269 CLASSIC | FLAG_NO_DATA,
2273 { /* Mainly checking JIT here. */
2274 "M[]: full STX + full LDX",
2276 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2277 BPF_STMT(BPF_STX, 0),
2278 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2279 BPF_STMT(BPF_STX, 1),
2280 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2281 BPF_STMT(BPF_STX, 2),
2282 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2283 BPF_STMT(BPF_STX, 3),
2284 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2285 BPF_STMT(BPF_STX, 4),
2286 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2287 BPF_STMT(BPF_STX, 5),
2288 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2289 BPF_STMT(BPF_STX, 6),
2290 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2291 BPF_STMT(BPF_STX, 7),
2292 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2293 BPF_STMT(BPF_STX, 8),
2294 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2295 BPF_STMT(BPF_STX, 9),
2296 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2297 BPF_STMT(BPF_STX, 10),
2298 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2299 BPF_STMT(BPF_STX, 11),
2300 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2301 BPF_STMT(BPF_STX, 12),
2302 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2303 BPF_STMT(BPF_STX, 13),
2304 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2305 BPF_STMT(BPF_STX, 14),
2306 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2307 BPF_STMT(BPF_STX, 15),
2308 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2309 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2310 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2311 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2312 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2313 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2314 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2315 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2316 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2317 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2318 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2319 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2320 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2321 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2322 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2323 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2324 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2325 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2326 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2327 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2328 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2329 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2330 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2331 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2332 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2333 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2334 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2335 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2336 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2337 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2338 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2339 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2340 BPF_STMT(BPF_RET | BPF_A, 0),
2342 CLASSIC | FLAG_NO_DATA,
2344 { { 0, 0x2a5a5e5 } },
2347 "check: SKF_AD_MAX",
2349 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2350 SKF_AD_OFF + SKF_AD_MAX),
2351 BPF_STMT(BPF_RET | BPF_A, 0),
2353 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2356 .fill_helper = NULL,
2357 .expected_errcode = -EINVAL,
2359 { /* Passes checker but fails during runtime. */
2360 "LD [SKF_AD_OFF-1]",
2362 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2364 BPF_STMT(BPF_RET | BPF_K, 1),
2371 "load 64-bit immediate",
2373 BPF_LD_IMM64(R1, 0x567800001234LL),
2374 BPF_MOV64_REG(R2, R1),
2375 BPF_MOV64_REG(R3, R2),
2376 BPF_ALU64_IMM(BPF_RSH, R2, 32),
2377 BPF_ALU64_IMM(BPF_LSH, R3, 32),
2378 BPF_ALU64_IMM(BPF_RSH, R3, 32),
2379 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2380 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2382 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2384 BPF_LD_IMM64(R0, 0x1ffffffffLL),
2385 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2395 BPF_MOV64_REG(R6, R1),
2396 BPF_LD_ABS(BPF_H, 12),
2397 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
2398 BPF_LD_ABS(BPF_H, 12),
2399 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
2400 BPF_MOV32_IMM(R0, 18),
2401 BPF_STX_MEM(BPF_W, R10, R0, -64),
2402 BPF_LDX_MEM(BPF_W, R7, R10, -64),
2403 BPF_LD_IND(BPF_W, R7, 14),
2404 BPF_STX_MEM(BPF_W, R10, R0, -60),
2405 BPF_MOV32_IMM(R0, 280971478),
2406 BPF_STX_MEM(BPF_W, R10, R0, -56),
2407 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2408 BPF_LDX_MEM(BPF_W, R0, R10, -60),
2409 BPF_ALU32_REG(BPF_SUB, R0, R7),
2410 BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
2411 BPF_LD_ABS(BPF_H, 12),
2412 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
2413 BPF_MOV32_IMM(R0, 22),
2414 BPF_STX_MEM(BPF_W, R10, R0, -56),
2415 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2416 BPF_LD_IND(BPF_H, R7, 14),
2417 BPF_STX_MEM(BPF_W, R10, R0, -52),
2418 BPF_MOV32_IMM(R0, 17366),
2419 BPF_STX_MEM(BPF_W, R10, R0, -48),
2420 BPF_LDX_MEM(BPF_W, R7, R10, -48),
2421 BPF_LDX_MEM(BPF_W, R0, R10, -52),
2422 BPF_ALU32_REG(BPF_SUB, R0, R7),
2423 BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
2424 BPF_MOV32_IMM(R0, 256),
2426 BPF_MOV32_IMM(R0, 0),
2430 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
2431 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2432 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
2436 /* BPF_ALU | BPF_MOV | BPF_X */
2438 "ALU_MOV_X: dst = 2",
2440 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2441 BPF_ALU32_REG(BPF_MOV, R0, R1),
2449 "ALU_MOV_X: dst = 4294967295",
2451 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2452 BPF_ALU32_REG(BPF_MOV, R0, R1),
2457 { { 0, 4294967295U } },
2460 "ALU64_MOV_X: dst = 2",
2462 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2463 BPF_ALU64_REG(BPF_MOV, R0, R1),
2471 "ALU64_MOV_X: dst = 4294967295",
2473 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2474 BPF_ALU64_REG(BPF_MOV, R0, R1),
2479 { { 0, 4294967295U } },
2481 /* BPF_ALU | BPF_MOV | BPF_K */
2483 "ALU_MOV_K: dst = 2",
2485 BPF_ALU32_IMM(BPF_MOV, R0, 2),
2493 "ALU_MOV_K: dst = 4294967295",
2495 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2500 { { 0, 4294967295U } },
2503 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2505 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2506 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
2507 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2508 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2509 BPF_MOV32_IMM(R0, 2),
2511 BPF_MOV32_IMM(R0, 1),
2519 "ALU64_MOV_K: dst = 2",
2521 BPF_ALU64_IMM(BPF_MOV, R0, 2),
2529 "ALU64_MOV_K: dst = 2147483647",
2531 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2536 { { 0, 2147483647 } },
2539 "ALU64_OR_K: dst = 0x0",
2541 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2542 BPF_LD_IMM64(R3, 0x0),
2543 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2544 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2545 BPF_MOV32_IMM(R0, 2),
2547 BPF_MOV32_IMM(R0, 1),
2555 "ALU64_MOV_K: dst = -1",
2557 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2558 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2559 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2560 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2561 BPF_MOV32_IMM(R0, 2),
2563 BPF_MOV32_IMM(R0, 1),
2570 /* BPF_ALU | BPF_ADD | BPF_X */
2572 "ALU_ADD_X: 1 + 2 = 3",
2574 BPF_LD_IMM64(R0, 1),
2575 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2576 BPF_ALU32_REG(BPF_ADD, R0, R1),
2584 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2586 BPF_LD_IMM64(R0, 1),
2587 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2588 BPF_ALU32_REG(BPF_ADD, R0, R1),
2593 { { 0, 4294967295U } },
2596 "ALU_ADD_X: 2 + 4294967294 = 0",
2598 BPF_LD_IMM64(R0, 2),
2599 BPF_LD_IMM64(R1, 4294967294U),
2600 BPF_ALU32_REG(BPF_ADD, R0, R1),
2601 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2602 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2604 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2612 "ALU64_ADD_X: 1 + 2 = 3",
2614 BPF_LD_IMM64(R0, 1),
2615 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2616 BPF_ALU64_REG(BPF_ADD, R0, R1),
2624 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2626 BPF_LD_IMM64(R0, 1),
2627 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2628 BPF_ALU64_REG(BPF_ADD, R0, R1),
2633 { { 0, 4294967295U } },
2636 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2638 BPF_LD_IMM64(R0, 2),
2639 BPF_LD_IMM64(R1, 4294967294U),
2640 BPF_LD_IMM64(R2, 4294967296ULL),
2641 BPF_ALU64_REG(BPF_ADD, R0, R1),
2642 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2643 BPF_MOV32_IMM(R0, 0),
2645 BPF_MOV32_IMM(R0, 1),
2652 /* BPF_ALU | BPF_ADD | BPF_K */
2654 "ALU_ADD_K: 1 + 2 = 3",
2656 BPF_LD_IMM64(R0, 1),
2657 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2665 "ALU_ADD_K: 3 + 0 = 3",
2667 BPF_LD_IMM64(R0, 3),
2668 BPF_ALU32_IMM(BPF_ADD, R0, 0),
2676 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2678 BPF_LD_IMM64(R0, 1),
2679 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2684 { { 0, 4294967295U } },
2687 "ALU_ADD_K: 4294967294 + 2 = 0",
2689 BPF_LD_IMM64(R0, 4294967294U),
2690 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2691 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2692 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2694 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2702 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2704 BPF_LD_IMM64(R2, 0x0),
2705 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2706 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2707 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2708 BPF_MOV32_IMM(R0, 2),
2710 BPF_MOV32_IMM(R0, 1),
2718 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2720 BPF_LD_IMM64(R2, 0x0),
2721 BPF_LD_IMM64(R3, 0xffff),
2722 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
2723 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2724 BPF_MOV32_IMM(R0, 2),
2726 BPF_MOV32_IMM(R0, 1),
2734 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2736 BPF_LD_IMM64(R2, 0x0),
2737 BPF_LD_IMM64(R3, 0x7fffffff),
2738 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
2739 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2740 BPF_MOV32_IMM(R0, 2),
2742 BPF_MOV32_IMM(R0, 1),
2750 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2752 BPF_LD_IMM64(R2, 0x0),
2753 BPF_LD_IMM64(R3, 0x80000000),
2754 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
2755 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2756 BPF_MOV32_IMM(R0, 2),
2758 BPF_MOV32_IMM(R0, 1),
2766 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2768 BPF_LD_IMM64(R2, 0x0),
2769 BPF_LD_IMM64(R3, 0x80008000),
2770 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2771 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2772 BPF_MOV32_IMM(R0, 2),
2774 BPF_MOV32_IMM(R0, 1),
2782 "ALU64_ADD_K: 1 + 2 = 3",
2784 BPF_LD_IMM64(R0, 1),
2785 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2793 "ALU64_ADD_K: 3 + 0 = 3",
2795 BPF_LD_IMM64(R0, 3),
2796 BPF_ALU64_IMM(BPF_ADD, R0, 0),
2804 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2806 BPF_LD_IMM64(R0, 1),
2807 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2812 { { 0, 2147483647 } },
2815 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2817 BPF_LD_IMM64(R0, 4294967294U),
2818 BPF_LD_IMM64(R1, 4294967296ULL),
2819 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2820 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2821 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2823 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2831 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2833 BPF_LD_IMM64(R0, 2147483646),
2834 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2842 "ALU64_ADD_K: 1 + 0 = 1",
2844 BPF_LD_IMM64(R2, 0x1),
2845 BPF_LD_IMM64(R3, 0x1),
2846 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2847 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2848 BPF_MOV32_IMM(R0, 2),
2850 BPF_MOV32_IMM(R0, 1),
2858 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2860 BPF_LD_IMM64(R2, 0x0),
2861 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2862 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2863 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2864 BPF_MOV32_IMM(R0, 2),
2866 BPF_MOV32_IMM(R0, 1),
2874 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2876 BPF_LD_IMM64(R2, 0x0),
2877 BPF_LD_IMM64(R3, 0xffff),
2878 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
2879 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2880 BPF_MOV32_IMM(R0, 2),
2882 BPF_MOV32_IMM(R0, 1),
2890 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2892 BPF_LD_IMM64(R2, 0x0),
2893 BPF_LD_IMM64(R3, 0x7fffffff),
2894 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
2895 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2896 BPF_MOV32_IMM(R0, 2),
2898 BPF_MOV32_IMM(R0, 1),
2906 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
2908 BPF_LD_IMM64(R2, 0x0),
2909 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
2910 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
2911 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2912 BPF_MOV32_IMM(R0, 2),
2914 BPF_MOV32_IMM(R0, 1),
2922 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
2924 BPF_LD_IMM64(R2, 0x0),
2925 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
2926 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
2927 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2928 BPF_MOV32_IMM(R0, 2),
2930 BPF_MOV32_IMM(R0, 1),
2937 /* BPF_ALU | BPF_SUB | BPF_X */
2939 "ALU_SUB_X: 3 - 1 = 2",
2941 BPF_LD_IMM64(R0, 3),
2942 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2943 BPF_ALU32_REG(BPF_SUB, R0, R1),
2951 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2953 BPF_LD_IMM64(R0, 4294967295U),
2954 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2955 BPF_ALU32_REG(BPF_SUB, R0, R1),
2963 "ALU64_SUB_X: 3 - 1 = 2",
2965 BPF_LD_IMM64(R0, 3),
2966 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2967 BPF_ALU64_REG(BPF_SUB, R0, R1),
2975 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2977 BPF_LD_IMM64(R0, 4294967295U),
2978 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2979 BPF_ALU64_REG(BPF_SUB, R0, R1),
2986 /* BPF_ALU | BPF_SUB | BPF_K */
2988 "ALU_SUB_K: 3 - 1 = 2",
2990 BPF_LD_IMM64(R0, 3),
2991 BPF_ALU32_IMM(BPF_SUB, R0, 1),
2999 "ALU_SUB_K: 3 - 0 = 3",
3001 BPF_LD_IMM64(R0, 3),
3002 BPF_ALU32_IMM(BPF_SUB, R0, 0),
3010 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
3012 BPF_LD_IMM64(R0, 4294967295U),
3013 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
3021 "ALU64_SUB_K: 3 - 1 = 2",
3023 BPF_LD_IMM64(R0, 3),
3024 BPF_ALU64_IMM(BPF_SUB, R0, 1),
3032 "ALU64_SUB_K: 3 - 0 = 3",
3034 BPF_LD_IMM64(R0, 3),
3035 BPF_ALU64_IMM(BPF_SUB, R0, 0),
3043 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
3045 BPF_LD_IMM64(R0, 4294967294U),
3046 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
3054 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
3056 BPF_LD_IMM64(R0, 2147483646),
3057 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
3064 /* BPF_ALU | BPF_MUL | BPF_X */
3066 "ALU_MUL_X: 2 * 3 = 6",
3068 BPF_LD_IMM64(R0, 2),
3069 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3070 BPF_ALU32_REG(BPF_MUL, R0, R1),
3078 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3080 BPF_LD_IMM64(R0, 2),
3081 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3082 BPF_ALU32_REG(BPF_MUL, R0, R1),
3087 { { 0, 0xFFFFFFF0 } },
3090 "ALU_MUL_X: -1 * -1 = 1",
3092 BPF_LD_IMM64(R0, -1),
3093 BPF_ALU32_IMM(BPF_MOV, R1, -1),
3094 BPF_ALU32_REG(BPF_MUL, R0, R1),
3102 "ALU64_MUL_X: 2 * 3 = 6",
3104 BPF_LD_IMM64(R0, 2),
3105 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3106 BPF_ALU64_REG(BPF_MUL, R0, R1),
3114 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3116 BPF_LD_IMM64(R0, 1),
3117 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3118 BPF_ALU64_REG(BPF_MUL, R0, R1),
3123 { { 0, 2147483647 } },
3125 /* BPF_ALU | BPF_MUL | BPF_K */
3127 "ALU_MUL_K: 2 * 3 = 6",
3129 BPF_LD_IMM64(R0, 2),
3130 BPF_ALU32_IMM(BPF_MUL, R0, 3),
3138 "ALU_MUL_K: 3 * 1 = 3",
3140 BPF_LD_IMM64(R0, 3),
3141 BPF_ALU32_IMM(BPF_MUL, R0, 1),
3149 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3151 BPF_LD_IMM64(R0, 2),
3152 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3157 { { 0, 0xFFFFFFF0 } },
3160 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3162 BPF_LD_IMM64(R2, 0x1),
3163 BPF_LD_IMM64(R3, 0x00000000ffffffff),
3164 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3165 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3166 BPF_MOV32_IMM(R0, 2),
3168 BPF_MOV32_IMM(R0, 1),
3176 "ALU64_MUL_K: 2 * 3 = 6",
3178 BPF_LD_IMM64(R0, 2),
3179 BPF_ALU64_IMM(BPF_MUL, R0, 3),
3187 "ALU64_MUL_K: 3 * 1 = 3",
3189 BPF_LD_IMM64(R0, 3),
3190 BPF_ALU64_IMM(BPF_MUL, R0, 1),
3198 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3200 BPF_LD_IMM64(R0, 1),
3201 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3206 { { 0, 2147483647 } },
3209 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3211 BPF_LD_IMM64(R0, 1),
3212 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3217 { { 0, -2147483647 } },
3220 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3222 BPF_LD_IMM64(R2, 0x1),
3223 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3224 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3225 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3226 BPF_MOV32_IMM(R0, 2),
3228 BPF_MOV32_IMM(R0, 1),
3235 /* BPF_ALU | BPF_DIV | BPF_X */
3237 "ALU_DIV_X: 6 / 2 = 3",
3239 BPF_LD_IMM64(R0, 6),
3240 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3241 BPF_ALU32_REG(BPF_DIV, R0, R1),
3249 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3251 BPF_LD_IMM64(R0, 4294967295U),
3252 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3253 BPF_ALU32_REG(BPF_DIV, R0, R1),
3261 "ALU64_DIV_X: 6 / 2 = 3",
3263 BPF_LD_IMM64(R0, 6),
3264 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3265 BPF_ALU64_REG(BPF_DIV, R0, R1),
3273 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3275 BPF_LD_IMM64(R0, 2147483647),
3276 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3277 BPF_ALU64_REG(BPF_DIV, R0, R1),
3285 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3287 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3288 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3289 BPF_LD_IMM64(R3, 0x0000000000000001LL),
3290 BPF_ALU64_REG(BPF_DIV, R2, R4),
3291 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3292 BPF_MOV32_IMM(R0, 2),
3294 BPF_MOV32_IMM(R0, 1),
3301 /* BPF_ALU | BPF_DIV | BPF_K */
3303 "ALU_DIV_K: 6 / 2 = 3",
3305 BPF_LD_IMM64(R0, 6),
3306 BPF_ALU32_IMM(BPF_DIV, R0, 2),
3314 "ALU_DIV_K: 3 / 1 = 3",
3316 BPF_LD_IMM64(R0, 3),
3317 BPF_ALU32_IMM(BPF_DIV, R0, 1),
3325 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3327 BPF_LD_IMM64(R0, 4294967295U),
3328 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3336 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3338 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3339 BPF_LD_IMM64(R3, 0x1UL),
3340 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3341 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3342 BPF_MOV32_IMM(R0, 2),
3344 BPF_MOV32_IMM(R0, 1),
3352 "ALU64_DIV_K: 6 / 2 = 3",
3354 BPF_LD_IMM64(R0, 6),
3355 BPF_ALU64_IMM(BPF_DIV, R0, 2),
3363 "ALU64_DIV_K: 3 / 1 = 3",
3365 BPF_LD_IMM64(R0, 3),
3366 BPF_ALU64_IMM(BPF_DIV, R0, 1),
3374 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3376 BPF_LD_IMM64(R0, 2147483647),
3377 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3385 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3387 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3388 BPF_LD_IMM64(R3, 0x0000000000000001LL),
3389 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3390 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3391 BPF_MOV32_IMM(R0, 2),
3393 BPF_MOV32_IMM(R0, 1),
3400 /* BPF_ALU | BPF_MOD | BPF_X */
3402 "ALU_MOD_X: 3 % 2 = 1",
3404 BPF_LD_IMM64(R0, 3),
3405 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3406 BPF_ALU32_REG(BPF_MOD, R0, R1),
3414 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3416 BPF_LD_IMM64(R0, 4294967295U),
3417 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3418 BPF_ALU32_REG(BPF_MOD, R0, R1),
3426 "ALU64_MOD_X: 3 % 2 = 1",
3428 BPF_LD_IMM64(R0, 3),
3429 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3430 BPF_ALU64_REG(BPF_MOD, R0, R1),
3438 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3440 BPF_LD_IMM64(R0, 2147483647),
3441 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3442 BPF_ALU64_REG(BPF_MOD, R0, R1),
3449 /* BPF_ALU | BPF_MOD | BPF_K */
3451 "ALU_MOD_K: 3 % 2 = 1",
3453 BPF_LD_IMM64(R0, 3),
3454 BPF_ALU32_IMM(BPF_MOD, R0, 2),
3462 "ALU_MOD_K: 3 % 1 = 0",
3464 BPF_LD_IMM64(R0, 3),
3465 BPF_ALU32_IMM(BPF_MOD, R0, 1),
3473 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3475 BPF_LD_IMM64(R0, 4294967295U),
3476 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3484 "ALU64_MOD_K: 3 % 2 = 1",
3486 BPF_LD_IMM64(R0, 3),
3487 BPF_ALU64_IMM(BPF_MOD, R0, 2),
3495 "ALU64_MOD_K: 3 % 1 = 0",
3497 BPF_LD_IMM64(R0, 3),
3498 BPF_ALU64_IMM(BPF_MOD, R0, 1),
3506 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3508 BPF_LD_IMM64(R0, 2147483647),
3509 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3516 /* BPF_ALU | BPF_AND | BPF_X */
3518 "ALU_AND_X: 3 & 2 = 2",
3520 BPF_LD_IMM64(R0, 3),
3521 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3522 BPF_ALU32_REG(BPF_AND, R0, R1),
3530 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3532 BPF_LD_IMM64(R0, 0xffffffff),
3533 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3534 BPF_ALU32_REG(BPF_AND, R0, R1),
3539 { { 0, 0xffffffff } },
3542 "ALU64_AND_X: 3 & 2 = 2",
3544 BPF_LD_IMM64(R0, 3),
3545 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3546 BPF_ALU64_REG(BPF_AND, R0, R1),
3554 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3556 BPF_LD_IMM64(R0, 0xffffffff),
3557 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3558 BPF_ALU64_REG(BPF_AND, R0, R1),
3563 { { 0, 0xffffffff } },
3565 /* BPF_ALU | BPF_AND | BPF_K */
3567 "ALU_AND_K: 3 & 2 = 2",
3569 BPF_LD_IMM64(R0, 3),
3570 BPF_ALU32_IMM(BPF_AND, R0, 2),
3578 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3580 BPF_LD_IMM64(R0, 0xffffffff),
3581 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3586 { { 0, 0xffffffff } },
3589 "ALU64_AND_K: 3 & 2 = 2",
3591 BPF_LD_IMM64(R0, 3),
3592 BPF_ALU64_IMM(BPF_AND, R0, 2),
3600 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3602 BPF_LD_IMM64(R0, 0xffffffff),
3603 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3608 { { 0, 0xffffffff } },
3611 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3613 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3614 BPF_LD_IMM64(R3, 0x0000000000000000LL),
3615 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3616 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3617 BPF_MOV32_IMM(R0, 2),
3619 BPF_MOV32_IMM(R0, 1),
3627 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3629 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3630 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3631 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3632 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3633 BPF_MOV32_IMM(R0, 2),
3635 BPF_MOV32_IMM(R0, 1),
3643 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3645 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3646 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3647 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3648 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3649 BPF_MOV32_IMM(R0, 2),
3651 BPF_MOV32_IMM(R0, 1),
3658 /* BPF_ALU | BPF_OR | BPF_X */
3660 "ALU_OR_X: 1 | 2 = 3",
3662 BPF_LD_IMM64(R0, 1),
3663 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3664 BPF_ALU32_REG(BPF_OR, R0, R1),
3672 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3674 BPF_LD_IMM64(R0, 0),
3675 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3676 BPF_ALU32_REG(BPF_OR, R0, R1),
3681 { { 0, 0xffffffff } },
3684 "ALU64_OR_X: 1 | 2 = 3",
3686 BPF_LD_IMM64(R0, 1),
3687 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3688 BPF_ALU64_REG(BPF_OR, R0, R1),
3696 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3698 BPF_LD_IMM64(R0, 0),
3699 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3700 BPF_ALU64_REG(BPF_OR, R0, R1),
3705 { { 0, 0xffffffff } },
3707 /* BPF_ALU | BPF_OR | BPF_K */
3709 "ALU_OR_K: 1 | 2 = 3",
3711 BPF_LD_IMM64(R0, 1),
3712 BPF_ALU32_IMM(BPF_OR, R0, 2),
3720 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3722 BPF_LD_IMM64(R0, 0),
3723 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3728 { { 0, 0xffffffff } },
3731 "ALU64_OR_K: 1 | 2 = 3",
3733 BPF_LD_IMM64(R0, 1),
3734 BPF_ALU64_IMM(BPF_OR, R0, 2),
3742 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3744 BPF_LD_IMM64(R0, 0),
3745 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3750 { { 0, 0xffffffff } },
3753 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3755 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3756 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3757 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3758 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3759 BPF_MOV32_IMM(R0, 2),
3761 BPF_MOV32_IMM(R0, 1),
3769 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3771 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3772 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3773 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3774 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3775 BPF_MOV32_IMM(R0, 2),
3777 BPF_MOV32_IMM(R0, 1),
3785 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3787 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3788 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3789 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3790 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3791 BPF_MOV32_IMM(R0, 2),
3793 BPF_MOV32_IMM(R0, 1),
3800 /* BPF_ALU | BPF_XOR | BPF_X */
3802 "ALU_XOR_X: 5 ^ 6 = 3",
3804 BPF_LD_IMM64(R0, 5),
3805 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3806 BPF_ALU32_REG(BPF_XOR, R0, R1),
3814 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3816 BPF_LD_IMM64(R0, 1),
3817 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3818 BPF_ALU32_REG(BPF_XOR, R0, R1),
3823 { { 0, 0xfffffffe } },
3826 "ALU64_XOR_X: 5 ^ 6 = 3",
3828 BPF_LD_IMM64(R0, 5),
3829 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3830 BPF_ALU64_REG(BPF_XOR, R0, R1),
3838 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3840 BPF_LD_IMM64(R0, 1),
3841 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3842 BPF_ALU64_REG(BPF_XOR, R0, R1),
3847 { { 0, 0xfffffffe } },
3849 /* BPF_ALU | BPF_XOR | BPF_K */
3851 "ALU_XOR_K: 5 ^ 6 = 3",
3853 BPF_LD_IMM64(R0, 5),
3854 BPF_ALU32_IMM(BPF_XOR, R0, 6),
3862 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3864 BPF_LD_IMM64(R0, 1),
3865 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3870 { { 0, 0xfffffffe } },
3873 "ALU64_XOR_K: 5 ^ 6 = 3",
3875 BPF_LD_IMM64(R0, 5),
3876 BPF_ALU64_IMM(BPF_XOR, R0, 6),
3884 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3886 BPF_LD_IMM64(R0, 1),
3887 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3892 { { 0, 0xfffffffe } },
3895 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3897 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3898 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3899 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
3900 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3901 BPF_MOV32_IMM(R0, 2),
3903 BPF_MOV32_IMM(R0, 1),
3911 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3913 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3914 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
3915 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3916 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3917 BPF_MOV32_IMM(R0, 2),
3919 BPF_MOV32_IMM(R0, 1),
3927 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3929 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3930 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3931 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3932 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3933 BPF_MOV32_IMM(R0, 2),
3935 BPF_MOV32_IMM(R0, 1),
3942 /* BPF_ALU | BPF_LSH | BPF_X */
3944 "ALU_LSH_X: 1 << 1 = 2",
3946 BPF_LD_IMM64(R0, 1),
3947 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3948 BPF_ALU32_REG(BPF_LSH, R0, R1),
3956 "ALU_LSH_X: 1 << 31 = 0x80000000",
3958 BPF_LD_IMM64(R0, 1),
3959 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3960 BPF_ALU32_REG(BPF_LSH, R0, R1),
3965 { { 0, 0x80000000 } },
3968 "ALU64_LSH_X: 1 << 1 = 2",
3970 BPF_LD_IMM64(R0, 1),
3971 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3972 BPF_ALU64_REG(BPF_LSH, R0, R1),
3980 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3982 BPF_LD_IMM64(R0, 1),
3983 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3984 BPF_ALU64_REG(BPF_LSH, R0, R1),
3989 { { 0, 0x80000000 } },
3991 /* BPF_ALU | BPF_LSH | BPF_K */
3993 "ALU_LSH_K: 1 << 1 = 2",
3995 BPF_LD_IMM64(R0, 1),
3996 BPF_ALU32_IMM(BPF_LSH, R0, 1),
4004 "ALU_LSH_K: 1 << 31 = 0x80000000",
4006 BPF_LD_IMM64(R0, 1),
4007 BPF_ALU32_IMM(BPF_LSH, R0, 31),
4012 { { 0, 0x80000000 } },
4015 "ALU64_LSH_K: 1 << 1 = 2",
4017 BPF_LD_IMM64(R0, 1),
4018 BPF_ALU64_IMM(BPF_LSH, R0, 1),
4026 "ALU64_LSH_K: 1 << 31 = 0x80000000",
4028 BPF_LD_IMM64(R0, 1),
4029 BPF_ALU64_IMM(BPF_LSH, R0, 31),
4034 { { 0, 0x80000000 } },
4036 /* BPF_ALU | BPF_RSH | BPF_X */
4038 "ALU_RSH_X: 2 >> 1 = 1",
4040 BPF_LD_IMM64(R0, 2),
4041 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4042 BPF_ALU32_REG(BPF_RSH, R0, R1),
4050 "ALU_RSH_X: 0x80000000 >> 31 = 1",
4052 BPF_LD_IMM64(R0, 0x80000000),
4053 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4054 BPF_ALU32_REG(BPF_RSH, R0, R1),
4062 "ALU64_RSH_X: 2 >> 1 = 1",
4064 BPF_LD_IMM64(R0, 2),
4065 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4066 BPF_ALU64_REG(BPF_RSH, R0, R1),
4074 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
4076 BPF_LD_IMM64(R0, 0x80000000),
4077 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4078 BPF_ALU64_REG(BPF_RSH, R0, R1),
4085 /* BPF_ALU | BPF_RSH | BPF_K */
4087 "ALU_RSH_K: 2 >> 1 = 1",
4089 BPF_LD_IMM64(R0, 2),
4090 BPF_ALU32_IMM(BPF_RSH, R0, 1),
4098 "ALU_RSH_K: 0x80000000 >> 31 = 1",
4100 BPF_LD_IMM64(R0, 0x80000000),
4101 BPF_ALU32_IMM(BPF_RSH, R0, 31),
4109 "ALU64_RSH_K: 2 >> 1 = 1",
4111 BPF_LD_IMM64(R0, 2),
4112 BPF_ALU64_IMM(BPF_RSH, R0, 1),
4120 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
4122 BPF_LD_IMM64(R0, 0x80000000),
4123 BPF_ALU64_IMM(BPF_RSH, R0, 31),
4130 /* BPF_ALU | BPF_ARSH | BPF_X */
4132 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4134 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4135 BPF_ALU32_IMM(BPF_MOV, R1, 40),
4136 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4141 { { 0, 0xffff00ff } },
4143 /* BPF_ALU | BPF_ARSH | BPF_K */
4145 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4147 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4148 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
4153 { { 0, 0xffff00ff } },
4155 /* BPF_ALU | BPF_NEG */
4157 "ALU_NEG: -(3) = -3",
4159 BPF_ALU32_IMM(BPF_MOV, R0, 3),
4160 BPF_ALU32_IMM(BPF_NEG, R0, 0),
4168 "ALU_NEG: -(-3) = 3",
4170 BPF_ALU32_IMM(BPF_MOV, R0, -3),
4171 BPF_ALU32_IMM(BPF_NEG, R0, 0),
4179 "ALU64_NEG: -(3) = -3",
4181 BPF_LD_IMM64(R0, 3),
4182 BPF_ALU64_IMM(BPF_NEG, R0, 0),
4190 "ALU64_NEG: -(-3) = 3",
4192 BPF_LD_IMM64(R0, -3),
4193 BPF_ALU64_IMM(BPF_NEG, R0, 0),
4200 /* BPF_ALU | BPF_END | BPF_FROM_BE */
4202 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
4204 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4205 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
4210 { { 0, cpu_to_be16(0xcdef) } },
4213 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
4215 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4216 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
4217 BPF_ALU64_REG(BPF_MOV, R1, R0),
4218 BPF_ALU64_IMM(BPF_RSH, R1, 32),
4219 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
4224 { { 0, cpu_to_be32(0x89abcdef) } },
4227 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
4229 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4230 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
4235 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
4237 /* BPF_ALU | BPF_END | BPF_FROM_LE */
4239 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
4241 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4242 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
4247 { { 0, cpu_to_le16(0xcdef) } },
4250 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
4252 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4253 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
4254 BPF_ALU64_REG(BPF_MOV, R1, R0),
4255 BPF_ALU64_IMM(BPF_RSH, R1, 32),
4256 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
4261 { { 0, cpu_to_le32(0x89abcdef) } },
4264 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
4266 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4267 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
4272 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
4274 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
4276 "ST_MEM_B: Store/Load byte: max negative",
4278 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4279 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
4280 BPF_LDX_MEM(BPF_B, R0, R10, -40),
4289 "ST_MEM_B: Store/Load byte: max positive",
4291 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4292 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
4293 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4302 "STX_MEM_B: Store/Load byte: max negative",
4304 BPF_LD_IMM64(R0, 0),
4305 BPF_LD_IMM64(R1, 0xffLL),
4306 BPF_STX_MEM(BPF_B, R10, R1, -40),
4307 BPF_LDX_MEM(BPF_B, R0, R10, -40),
4316 "ST_MEM_H: Store/Load half word: max negative",
4318 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4319 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
4320 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4329 "ST_MEM_H: Store/Load half word: max positive",
4331 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4332 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
4333 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4342 "STX_MEM_H: Store/Load half word: max negative",
4344 BPF_LD_IMM64(R0, 0),
4345 BPF_LD_IMM64(R1, 0xffffLL),
4346 BPF_STX_MEM(BPF_H, R10, R1, -40),
4347 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4356 "ST_MEM_W: Store/Load word: max negative",
4358 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4359 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
4360 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4365 { { 0, 0xffffffff } },
4369 "ST_MEM_W: Store/Load word: max positive",
4371 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4372 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
4373 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4378 { { 0, 0x7fffffff } },
4382 "STX_MEM_W: Store/Load word: max negative",
4384 BPF_LD_IMM64(R0, 0),
4385 BPF_LD_IMM64(R1, 0xffffffffLL),
4386 BPF_STX_MEM(BPF_W, R10, R1, -40),
4387 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4392 { { 0, 0xffffffff } },
4396 "ST_MEM_DW: Store/Load double word: max negative",
4398 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4399 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4400 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4405 { { 0, 0xffffffff } },
4409 "ST_MEM_DW: Store/Load double word: max negative 2",
4411 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
4412 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4413 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4414 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
4415 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4416 BPF_MOV32_IMM(R0, 2),
4418 BPF_MOV32_IMM(R0, 1),
4427 "ST_MEM_DW: Store/Load double word: max positive",
4429 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4430 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
4431 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4436 { { 0, 0x7fffffff } },
4440 "STX_MEM_DW: Store/Load double word: max negative",
4442 BPF_LD_IMM64(R0, 0),
4443 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4444 BPF_STX_MEM(BPF_DW, R10, R1, -40),
4445 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4450 { { 0, 0xffffffff } },
4453 /* BPF_STX | BPF_XADD | BPF_W/DW */
4455 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
4457 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4458 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4459 BPF_STX_XADD(BPF_W, R10, R0, -40),
4460 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4469 "STX_XADD_W: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4471 BPF_ALU64_REG(BPF_MOV, R1, R10),
4472 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4473 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4474 BPF_STX_XADD(BPF_W, R10, R0, -40),
4475 BPF_ALU64_REG(BPF_MOV, R0, R10),
4476 BPF_ALU64_REG(BPF_SUB, R0, R1),
4485 "STX_XADD_W: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4487 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4488 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4489 BPF_STX_XADD(BPF_W, R10, R0, -40),
4498 "STX_XADD_W: X + 1 + 1 + 1 + ...",
4503 .fill_helper = bpf_fill_stxw,
4506 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
4508 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4509 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4510 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4511 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4520 "STX_XADD_DW: Test side-effects, r10: 0x12 + 0x10 = 0x22",
4522 BPF_ALU64_REG(BPF_MOV, R1, R10),
4523 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4524 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4525 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4526 BPF_ALU64_REG(BPF_MOV, R0, R10),
4527 BPF_ALU64_REG(BPF_SUB, R0, R1),
4536 "STX_XADD_DW: Test side-effects, r0: 0x12 + 0x10 = 0x22",
4538 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4539 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4540 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4549 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
4554 .fill_helper = bpf_fill_stxdw,
4556 /* BPF_JMP | BPF_EXIT */
4560 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
4562 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
4568 /* BPF_JMP | BPF_JA */
4570 "JMP_JA: Unconditional jump: if (true) return 1",
4572 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4573 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
4575 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4582 /* BPF_JMP | BPF_JSLT | BPF_K */
4584 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
4586 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4587 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
4588 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
4590 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4598 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
4600 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4601 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4602 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
4604 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4611 /* BPF_JMP | BPF_JSGT | BPF_K */
4613 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4615 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4616 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4617 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
4619 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4627 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4629 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4630 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4631 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
4633 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4640 /* BPF_JMP | BPF_JSLE | BPF_K */
4642 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
4644 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4645 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
4646 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
4648 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4656 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
4658 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4659 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4660 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
4662 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4670 "JMP_JSLE_K: Signed jump: value walk 1",
4672 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4673 BPF_LD_IMM64(R1, 3),
4674 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
4675 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4676 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
4677 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4678 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
4679 BPF_ALU64_IMM(BPF_SUB, R1, 1),
4680 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
4681 BPF_EXIT_INSN(), /* bad exit */
4682 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4690 "JMP_JSLE_K: Signed jump: value walk 2",
4692 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4693 BPF_LD_IMM64(R1, 3),
4694 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
4695 BPF_ALU64_IMM(BPF_SUB, R1, 2),
4696 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
4697 BPF_ALU64_IMM(BPF_SUB, R1, 2),
4698 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
4699 BPF_EXIT_INSN(), /* bad exit */
4700 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4707 /* BPF_JMP | BPF_JSGE | BPF_K */
4709 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4711 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4712 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4713 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
4715 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4723 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4725 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4726 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4727 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
4729 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4737 "JMP_JSGE_K: Signed jump: value walk 1",
4739 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4740 BPF_LD_IMM64(R1, -3),
4741 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
4742 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4743 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
4744 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4745 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
4746 BPF_ALU64_IMM(BPF_ADD, R1, 1),
4747 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
4748 BPF_EXIT_INSN(), /* bad exit */
4749 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4757 "JMP_JSGE_K: Signed jump: value walk 2",
4759 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4760 BPF_LD_IMM64(R1, -3),
4761 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
4762 BPF_ALU64_IMM(BPF_ADD, R1, 2),
4763 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
4764 BPF_ALU64_IMM(BPF_ADD, R1, 2),
4765 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
4766 BPF_EXIT_INSN(), /* bad exit */
4767 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
4774 /* BPF_JMP | BPF_JGT | BPF_K */
4776 "JMP_JGT_K: if (3 > 2) return 1",
4778 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4779 BPF_LD_IMM64(R1, 3),
4780 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
4782 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4790 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
4792 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4793 BPF_LD_IMM64(R1, -1),
4794 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
4796 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4803 /* BPF_JMP | BPF_JLT | BPF_K */
4805 "JMP_JLT_K: if (2 < 3) return 1",
4807 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4808 BPF_LD_IMM64(R1, 2),
4809 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
4811 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4819 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
4821 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4822 BPF_LD_IMM64(R1, 1),
4823 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
4825 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4832 /* BPF_JMP | BPF_JGE | BPF_K */
4834 "JMP_JGE_K: if (3 >= 2) return 1",
4836 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4837 BPF_LD_IMM64(R1, 3),
4838 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
4840 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4847 /* BPF_JMP | BPF_JLE | BPF_K */
4849 "JMP_JLE_K: if (2 <= 3) return 1",
4851 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4852 BPF_LD_IMM64(R1, 2),
4853 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
4855 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4862 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4864 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4866 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4867 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4869 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4870 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
4871 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
4879 "JMP_JGE_K: if (3 >= 3) return 1",
4881 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4882 BPF_LD_IMM64(R1, 3),
4883 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
4885 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4892 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
4894 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
4896 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4897 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4899 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4900 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
4901 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
4909 "JMP_JLE_K: if (3 <= 3) return 1",
4911 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4912 BPF_LD_IMM64(R1, 3),
4913 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
4915 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4922 /* BPF_JMP | BPF_JNE | BPF_K */
4924 "JMP_JNE_K: if (3 != 2) return 1",
4926 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4927 BPF_LD_IMM64(R1, 3),
4928 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4930 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4937 /* BPF_JMP | BPF_JEQ | BPF_K */
4939 "JMP_JEQ_K: if (3 == 3) return 1",
4941 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4942 BPF_LD_IMM64(R1, 3),
4943 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
4945 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4952 /* BPF_JMP | BPF_JSET | BPF_K */
4954 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4956 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4957 BPF_LD_IMM64(R1, 3),
4958 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
4960 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4968 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4970 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4971 BPF_LD_IMM64(R1, 3),
4972 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
4974 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4981 /* BPF_JMP | BPF_JSGT | BPF_X */
4983 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4985 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4986 BPF_LD_IMM64(R1, -1),
4987 BPF_LD_IMM64(R2, -2),
4988 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4990 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4998 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
5000 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5001 BPF_LD_IMM64(R1, -1),
5002 BPF_LD_IMM64(R2, -1),
5003 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
5005 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5012 /* BPF_JMP | BPF_JSLT | BPF_X */
5014 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
5016 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5017 BPF_LD_IMM64(R1, -1),
5018 BPF_LD_IMM64(R2, -2),
5019 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
5021 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5029 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
5031 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5032 BPF_LD_IMM64(R1, -1),
5033 BPF_LD_IMM64(R2, -1),
5034 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
5036 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5043 /* BPF_JMP | BPF_JSGE | BPF_X */
5045 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
5047 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5048 BPF_LD_IMM64(R1, -1),
5049 BPF_LD_IMM64(R2, -2),
5050 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
5052 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5060 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
5062 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5063 BPF_LD_IMM64(R1, -1),
5064 BPF_LD_IMM64(R2, -1),
5065 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
5067 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5074 /* BPF_JMP | BPF_JSLE | BPF_X */
5076 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
5078 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5079 BPF_LD_IMM64(R1, -1),
5080 BPF_LD_IMM64(R2, -2),
5081 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
5083 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5091 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
5093 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5094 BPF_LD_IMM64(R1, -1),
5095 BPF_LD_IMM64(R2, -1),
5096 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
5098 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5105 /* BPF_JMP | BPF_JGT | BPF_X */
5107 "JMP_JGT_X: if (3 > 2) return 1",
5109 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5110 BPF_LD_IMM64(R1, 3),
5111 BPF_LD_IMM64(R2, 2),
5112 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
5114 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5122 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
5124 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5125 BPF_LD_IMM64(R1, -1),
5126 BPF_LD_IMM64(R2, 1),
5127 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
5129 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5136 /* BPF_JMP | BPF_JLT | BPF_X */
5138 "JMP_JLT_X: if (2 < 3) return 1",
5140 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5141 BPF_LD_IMM64(R1, 3),
5142 BPF_LD_IMM64(R2, 2),
5143 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
5145 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5153 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
5155 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5156 BPF_LD_IMM64(R1, -1),
5157 BPF_LD_IMM64(R2, 1),
5158 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
5160 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5167 /* BPF_JMP | BPF_JGE | BPF_X */
5169 "JMP_JGE_X: if (3 >= 2) return 1",
5171 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5172 BPF_LD_IMM64(R1, 3),
5173 BPF_LD_IMM64(R2, 2),
5174 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
5176 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5184 "JMP_JGE_X: if (3 >= 3) return 1",
5186 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5187 BPF_LD_IMM64(R1, 3),
5188 BPF_LD_IMM64(R2, 3),
5189 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
5191 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5198 /* BPF_JMP | BPF_JLE | BPF_X */
5200 "JMP_JLE_X: if (2 <= 3) return 1",
5202 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5203 BPF_LD_IMM64(R1, 3),
5204 BPF_LD_IMM64(R2, 2),
5205 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
5207 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5215 "JMP_JLE_X: if (3 <= 3) return 1",
5217 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5218 BPF_LD_IMM64(R1, 3),
5219 BPF_LD_IMM64(R2, 3),
5220 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
5222 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5230 /* Mainly testing JIT + imm64 here. */
5231 "JMP_JGE_X: ldimm64 test 1",
5233 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5234 BPF_LD_IMM64(R1, 3),
5235 BPF_LD_IMM64(R2, 2),
5236 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
5237 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5238 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5243 { { 0, 0xeeeeeeeeU } },
5246 "JMP_JGE_X: ldimm64 test 2",
5248 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5249 BPF_LD_IMM64(R1, 3),
5250 BPF_LD_IMM64(R2, 2),
5251 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
5252 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5257 { { 0, 0xffffffffU } },
5260 "JMP_JGE_X: ldimm64 test 3",
5262 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5263 BPF_LD_IMM64(R1, 3),
5264 BPF_LD_IMM64(R2, 2),
5265 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
5266 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5267 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5275 "JMP_JLE_X: ldimm64 test 1",
5277 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5278 BPF_LD_IMM64(R1, 3),
5279 BPF_LD_IMM64(R2, 2),
5280 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
5281 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5282 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5287 { { 0, 0xeeeeeeeeU } },
5290 "JMP_JLE_X: ldimm64 test 2",
5292 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5293 BPF_LD_IMM64(R1, 3),
5294 BPF_LD_IMM64(R2, 2),
5295 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
5296 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5301 { { 0, 0xffffffffU } },
5304 "JMP_JLE_X: ldimm64 test 3",
5306 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5307 BPF_LD_IMM64(R1, 3),
5308 BPF_LD_IMM64(R2, 2),
5309 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
5310 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
5311 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
5318 /* BPF_JMP | BPF_JNE | BPF_X */
5320 "JMP_JNE_X: if (3 != 2) return 1",
5322 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5323 BPF_LD_IMM64(R1, 3),
5324 BPF_LD_IMM64(R2, 2),
5325 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
5327 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5334 /* BPF_JMP | BPF_JEQ | BPF_X */
5336 "JMP_JEQ_X: if (3 == 3) return 1",
5338 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5339 BPF_LD_IMM64(R1, 3),
5340 BPF_LD_IMM64(R2, 3),
5341 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
5343 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5350 /* BPF_JMP | BPF_JSET | BPF_X */
5352 "JMP_JSET_X: if (0x3 & 0x2) return 1",
5354 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5355 BPF_LD_IMM64(R1, 3),
5356 BPF_LD_IMM64(R2, 2),
5357 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
5359 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5367 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
5369 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5370 BPF_LD_IMM64(R1, 3),
5371 BPF_LD_IMM64(R2, 0xffffffff),
5372 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
5374 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5382 "JMP_JA: Jump, gap, jump, ...",
5384 CLASSIC | FLAG_NO_DATA,
5386 { { 0, 0xababcbac } },
5387 .fill_helper = bpf_fill_ja,
5389 { /* Mainly checking JIT here. */
5390 "BPF_MAXINSNS: Maximum possible literals",
5392 CLASSIC | FLAG_NO_DATA,
5394 { { 0, 0xffffffff } },
5395 .fill_helper = bpf_fill_maxinsns1,
5397 { /* Mainly checking JIT here. */
5398 "BPF_MAXINSNS: Single literal",
5400 CLASSIC | FLAG_NO_DATA,
5402 { { 0, 0xfefefefe } },
5403 .fill_helper = bpf_fill_maxinsns2,
5405 { /* Mainly checking JIT here. */
5406 "BPF_MAXINSNS: Run/add until end",
5408 CLASSIC | FLAG_NO_DATA,
5410 { { 0, 0x947bf368 } },
5411 .fill_helper = bpf_fill_maxinsns3,
5414 "BPF_MAXINSNS: Too many instructions",
5416 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
5419 .fill_helper = bpf_fill_maxinsns4,
5420 .expected_errcode = -EINVAL,
5422 { /* Mainly checking JIT here. */
5423 "BPF_MAXINSNS: Very long jump",
5425 CLASSIC | FLAG_NO_DATA,
5427 { { 0, 0xabababab } },
5428 .fill_helper = bpf_fill_maxinsns5,
5430 { /* Mainly checking JIT here. */
5431 "BPF_MAXINSNS: Ctx heavy transformations",
5436 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
5437 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
5439 .fill_helper = bpf_fill_maxinsns6,
5441 { /* Mainly checking JIT here. */
5442 "BPF_MAXINSNS: Call heavy transformations",
5444 CLASSIC | FLAG_NO_DATA,
5446 { { 1, 0 }, { 10, 0 } },
5447 .fill_helper = bpf_fill_maxinsns7,
5449 { /* Mainly checking JIT here. */
5450 "BPF_MAXINSNS: Jump heavy test",
5452 CLASSIC | FLAG_NO_DATA,
5454 { { 0, 0xffffffff } },
5455 .fill_helper = bpf_fill_maxinsns8,
5457 { /* Mainly checking JIT here. */
5458 "BPF_MAXINSNS: Very long jump backwards",
5460 INTERNAL | FLAG_NO_DATA,
5462 { { 0, 0xcbababab } },
5463 .fill_helper = bpf_fill_maxinsns9,
5465 { /* Mainly checking JIT here. */
5466 "BPF_MAXINSNS: Edge hopping nuthouse",
5468 INTERNAL | FLAG_NO_DATA,
5470 { { 0, 0xabababac } },
5471 .fill_helper = bpf_fill_maxinsns10,
5474 "BPF_MAXINSNS: Jump, gap, jump, ...",
5476 #if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_X86)
5477 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
5479 CLASSIC | FLAG_NO_DATA,
5482 { { 0, 0xababcbac } },
5483 .fill_helper = bpf_fill_maxinsns11,
5484 .expected_errcode = -ENOTSUPP,
5487 "BPF_MAXINSNS: jump over MSH",
5489 CLASSIC | FLAG_EXPECTED_FAIL,
5490 { 0xfa, 0xfb, 0xfc, 0xfd, },
5491 { { 4, 0xabababab } },
5492 .fill_helper = bpf_fill_maxinsns12,
5493 .expected_errcode = -EINVAL,
5496 "BPF_MAXINSNS: exec all MSH",
5499 { 0xfa, 0xfb, 0xfc, 0xfd, },
5500 { { 4, 0xababab83 } },
5501 .fill_helper = bpf_fill_maxinsns13,
5504 "BPF_MAXINSNS: ld_abs+get_processor_id",
5509 .fill_helper = bpf_fill_ld_abs_get_processor_id,
5512 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
5516 { { ETH_HLEN, 0xbef } },
5517 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
5520 "BPF_MAXINSNS: jump around ld_abs",
5525 .fill_helper = bpf_fill_jump_around_ld_abs,
5528 * LD_IND / LD_ABS on fragmented SKBs
5533 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5534 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
5535 BPF_STMT(BPF_RET | BPF_A, 0x0),
5537 CLASSIC | FLAG_SKB_FRAG,
5541 0x42, 0x00, 0x00, 0x00,
5542 0x43, 0x44, 0x00, 0x00,
5543 0x21, 0x07, 0x19, 0x83,
5547 "LD_IND halfword frag",
5549 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5550 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
5551 BPF_STMT(BPF_RET | BPF_A, 0x0),
5553 CLASSIC | FLAG_SKB_FRAG,
5557 0x42, 0x00, 0x00, 0x00,
5558 0x43, 0x44, 0x00, 0x00,
5559 0x21, 0x07, 0x19, 0x83,
5565 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5566 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
5567 BPF_STMT(BPF_RET | BPF_A, 0x0),
5569 CLASSIC | FLAG_SKB_FRAG,
5571 { {0x40, 0x21071983} },
5573 0x42, 0x00, 0x00, 0x00,
5574 0x43, 0x44, 0x00, 0x00,
5575 0x21, 0x07, 0x19, 0x83,
5579 "LD_IND halfword mixed head/frag",
5581 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5582 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5583 BPF_STMT(BPF_RET | BPF_A, 0x0),
5585 CLASSIC | FLAG_SKB_FRAG,
5586 { [0x3e] = 0x25, [0x3f] = 0x05, },
5588 .frag_data = { 0x19, 0x82 },
5591 "LD_IND word mixed head/frag",
5593 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
5594 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5595 BPF_STMT(BPF_RET | BPF_A, 0x0),
5597 CLASSIC | FLAG_SKB_FRAG,
5598 { [0x3e] = 0x25, [0x3f] = 0x05, },
5599 { {0x40, 0x25051982} },
5600 .frag_data = { 0x19, 0x82 },
5605 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
5606 BPF_STMT(BPF_RET | BPF_A, 0x0),
5608 CLASSIC | FLAG_SKB_FRAG,
5612 0x42, 0x00, 0x00, 0x00,
5613 0x43, 0x44, 0x00, 0x00,
5614 0x21, 0x07, 0x19, 0x83,
5618 "LD_ABS halfword frag",
5620 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
5621 BPF_STMT(BPF_RET | BPF_A, 0x0),
5623 CLASSIC | FLAG_SKB_FRAG,
5627 0x42, 0x00, 0x00, 0x00,
5628 0x43, 0x44, 0x00, 0x00,
5629 0x21, 0x07, 0x19, 0x83,
5635 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
5636 BPF_STMT(BPF_RET | BPF_A, 0x0),
5638 CLASSIC | FLAG_SKB_FRAG,
5640 { {0x40, 0x21071983} },
5642 0x42, 0x00, 0x00, 0x00,
5643 0x43, 0x44, 0x00, 0x00,
5644 0x21, 0x07, 0x19, 0x83,
5648 "LD_ABS halfword mixed head/frag",
5650 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
5651 BPF_STMT(BPF_RET | BPF_A, 0x0),
5653 CLASSIC | FLAG_SKB_FRAG,
5654 { [0x3e] = 0x25, [0x3f] = 0x05, },
5656 .frag_data = { 0x19, 0x82 },
5659 "LD_ABS word mixed head/frag",
5661 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
5662 BPF_STMT(BPF_RET | BPF_A, 0x0),
5664 CLASSIC | FLAG_SKB_FRAG,
5665 { [0x3e] = 0x25, [0x3f] = 0x05, },
5666 { {0x40, 0x25051982} },
5667 .frag_data = { 0x19, 0x82 },
5670 * LD_IND / LD_ABS on non fragmented SKBs
5674 * this tests that the JIT/interpreter correctly resets X
5675 * before using it in an LD_IND instruction.
5677 "LD_IND byte default X",
5679 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5680 BPF_STMT(BPF_RET | BPF_A, 0x0),
5687 "LD_IND byte positive offset",
5689 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5690 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
5691 BPF_STMT(BPF_RET | BPF_A, 0x0),
5694 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5698 "LD_IND byte negative offset",
5700 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
5701 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
5702 BPF_STMT(BPF_RET | BPF_A, 0x0),
5705 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
5709 "LD_IND halfword positive offset",
5711 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5712 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
5713 BPF_STMT(BPF_RET | BPF_A, 0x0),
5717 [0x1c] = 0xaa, [0x1d] = 0x55,
5718 [0x1e] = 0xbb, [0x1f] = 0x66,
5719 [0x20] = 0xcc, [0x21] = 0x77,
5720 [0x22] = 0xdd, [0x23] = 0x88,
5722 { {0x40, 0xdd88 } },
5725 "LD_IND halfword negative offset",
5727 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5728 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
5729 BPF_STMT(BPF_RET | BPF_A, 0x0),
5733 [0x1c] = 0xaa, [0x1d] = 0x55,
5734 [0x1e] = 0xbb, [0x1f] = 0x66,
5735 [0x20] = 0xcc, [0x21] = 0x77,
5736 [0x22] = 0xdd, [0x23] = 0x88,
5738 { {0x40, 0xbb66 } },
5741 "LD_IND halfword unaligned",
5743 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5744 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
5745 BPF_STMT(BPF_RET | BPF_A, 0x0),
5749 [0x1c] = 0xaa, [0x1d] = 0x55,
5750 [0x1e] = 0xbb, [0x1f] = 0x66,
5751 [0x20] = 0xcc, [0x21] = 0x77,
5752 [0x22] = 0xdd, [0x23] = 0x88,
5754 { {0x40, 0x66cc } },
5757 "LD_IND word positive offset",
5759 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5760 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
5761 BPF_STMT(BPF_RET | BPF_A, 0x0),
5765 [0x1c] = 0xaa, [0x1d] = 0x55,
5766 [0x1e] = 0xbb, [0x1f] = 0x66,
5767 [0x20] = 0xcc, [0x21] = 0x77,
5768 [0x22] = 0xdd, [0x23] = 0x88,
5769 [0x24] = 0xee, [0x25] = 0x99,
5770 [0x26] = 0xff, [0x27] = 0xaa,
5772 { {0x40, 0xee99ffaa } },
5775 "LD_IND word negative offset",
5777 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5778 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
5779 BPF_STMT(BPF_RET | BPF_A, 0x0),
5783 [0x1c] = 0xaa, [0x1d] = 0x55,
5784 [0x1e] = 0xbb, [0x1f] = 0x66,
5785 [0x20] = 0xcc, [0x21] = 0x77,
5786 [0x22] = 0xdd, [0x23] = 0x88,
5787 [0x24] = 0xee, [0x25] = 0x99,
5788 [0x26] = 0xff, [0x27] = 0xaa,
5790 { {0x40, 0xaa55bb66 } },
5793 "LD_IND word unaligned (addr & 3 == 2)",
5795 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5796 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
5797 BPF_STMT(BPF_RET | BPF_A, 0x0),
5801 [0x1c] = 0xaa, [0x1d] = 0x55,
5802 [0x1e] = 0xbb, [0x1f] = 0x66,
5803 [0x20] = 0xcc, [0x21] = 0x77,
5804 [0x22] = 0xdd, [0x23] = 0x88,
5805 [0x24] = 0xee, [0x25] = 0x99,
5806 [0x26] = 0xff, [0x27] = 0xaa,
5808 { {0x40, 0xbb66cc77 } },
5811 "LD_IND word unaligned (addr & 3 == 1)",
5813 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5814 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
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, 0x55bb66cc } },
5829 "LD_IND word unaligned (addr & 3 == 3)",
5831 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
5832 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
5833 BPF_STMT(BPF_RET | BPF_A, 0x0),
5837 [0x1c] = 0xaa, [0x1d] = 0x55,
5838 [0x1e] = 0xbb, [0x1f] = 0x66,
5839 [0x20] = 0xcc, [0x21] = 0x77,
5840 [0x22] = 0xdd, [0x23] = 0x88,
5841 [0x24] = 0xee, [0x25] = 0x99,
5842 [0x26] = 0xff, [0x27] = 0xaa,
5844 { {0x40, 0x66cc77dd } },
5849 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
5850 BPF_STMT(BPF_RET | BPF_A, 0x0),
5854 [0x1c] = 0xaa, [0x1d] = 0x55,
5855 [0x1e] = 0xbb, [0x1f] = 0x66,
5856 [0x20] = 0xcc, [0x21] = 0x77,
5857 [0x22] = 0xdd, [0x23] = 0x88,
5858 [0x24] = 0xee, [0x25] = 0x99,
5859 [0x26] = 0xff, [0x27] = 0xaa,
5866 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
5867 BPF_STMT(BPF_RET | BPF_A, 0x0),
5871 [0x1c] = 0xaa, [0x1d] = 0x55,
5872 [0x1e] = 0xbb, [0x1f] = 0x66,
5873 [0x20] = 0xcc, [0x21] = 0x77,
5874 [0x22] = 0xdd, [0x23] = 0x88,
5875 [0x24] = 0xee, [0x25] = 0x99,
5876 [0x26] = 0xff, [0x27] = 0xaa,
5878 { {0x40, 0xdd88 } },
5881 "LD_ABS halfword unaligned",
5883 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
5884 BPF_STMT(BPF_RET | BPF_A, 0x0),
5888 [0x1c] = 0xaa, [0x1d] = 0x55,
5889 [0x1e] = 0xbb, [0x1f] = 0x66,
5890 [0x20] = 0xcc, [0x21] = 0x77,
5891 [0x22] = 0xdd, [0x23] = 0x88,
5892 [0x24] = 0xee, [0x25] = 0x99,
5893 [0x26] = 0xff, [0x27] = 0xaa,
5895 { {0x40, 0x99ff } },
5900 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
5901 BPF_STMT(BPF_RET | BPF_A, 0x0),
5905 [0x1c] = 0xaa, [0x1d] = 0x55,
5906 [0x1e] = 0xbb, [0x1f] = 0x66,
5907 [0x20] = 0xcc, [0x21] = 0x77,
5908 [0x22] = 0xdd, [0x23] = 0x88,
5909 [0x24] = 0xee, [0x25] = 0x99,
5910 [0x26] = 0xff, [0x27] = 0xaa,
5912 { {0x40, 0xaa55bb66 } },
5915 "LD_ABS word unaligned (addr & 3 == 2)",
5917 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
5918 BPF_STMT(BPF_RET | BPF_A, 0x0),
5922 [0x1c] = 0xaa, [0x1d] = 0x55,
5923 [0x1e] = 0xbb, [0x1f] = 0x66,
5924 [0x20] = 0xcc, [0x21] = 0x77,
5925 [0x22] = 0xdd, [0x23] = 0x88,
5926 [0x24] = 0xee, [0x25] = 0x99,
5927 [0x26] = 0xff, [0x27] = 0xaa,
5929 { {0x40, 0xdd88ee99 } },
5932 "LD_ABS word unaligned (addr & 3 == 1)",
5934 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
5935 BPF_STMT(BPF_RET | BPF_A, 0x0),
5939 [0x1c] = 0xaa, [0x1d] = 0x55,
5940 [0x1e] = 0xbb, [0x1f] = 0x66,
5941 [0x20] = 0xcc, [0x21] = 0x77,
5942 [0x22] = 0xdd, [0x23] = 0x88,
5943 [0x24] = 0xee, [0x25] = 0x99,
5944 [0x26] = 0xff, [0x27] = 0xaa,
5946 { {0x40, 0x77dd88ee } },
5949 "LD_ABS word unaligned (addr & 3 == 3)",
5951 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
5952 BPF_STMT(BPF_RET | BPF_A, 0x0),
5956 [0x1c] = 0xaa, [0x1d] = 0x55,
5957 [0x1e] = 0xbb, [0x1f] = 0x66,
5958 [0x20] = 0xcc, [0x21] = 0x77,
5959 [0x22] = 0xdd, [0x23] = 0x88,
5960 [0x24] = 0xee, [0x25] = 0x99,
5961 [0x26] = 0xff, [0x27] = 0xaa,
5963 { {0x40, 0x88ee99ff } },
5966 * verify that the interpreter or JIT correctly sets A and X
5977 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5978 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
5979 BPF_STMT(BPF_RET | BPF_A, 0x0),
5981 CLASSIC | FLAG_NO_DATA,
5992 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
5993 BPF_STMT(BPF_RET | BPF_A, 0x0),
5995 CLASSIC | FLAG_NO_DATA,
6007 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
6008 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
6009 BPF_STMT(BPF_RET | BPF_A, 0x0),
6011 CLASSIC | FLAG_NO_DATA,
6022 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
6023 BPF_STMT(BPF_RET | BPF_A, 0x0),
6025 CLASSIC | FLAG_NO_DATA,
6037 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6038 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
6039 BPF_STMT(BPF_RET | BPF_A, 0x0),
6041 CLASSIC | FLAG_NO_DATA,
6052 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
6053 BPF_STMT(BPF_RET | BPF_A, 0x0),
6055 CLASSIC | FLAG_NO_DATA,
6064 * A = A / X ; this halt the filter execution if X is 0
6067 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6068 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
6069 BPF_STMT(BPF_RET | BPF_K, 0x42),
6071 CLASSIC | FLAG_NO_DATA,
6082 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
6083 BPF_STMT(BPF_RET | BPF_A, 0x0),
6085 CLASSIC | FLAG_NO_DATA,
6094 * A = A mod X ; this halt the filter execution if X is 0
6097 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
6098 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
6099 BPF_STMT(BPF_RET | BPF_K, 0x42),
6101 CLASSIC | FLAG_NO_DATA,
6112 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
6113 BPF_STMT(BPF_RET | BPF_A, 0x0),
6115 CLASSIC | FLAG_NO_DATA,
6127 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
6128 BPF_STMT(BPF_RET | BPF_K, 0x42),
6129 BPF_STMT(BPF_RET | BPF_K, 0x66),
6131 CLASSIC | FLAG_NO_DATA,
6144 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
6145 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
6146 BPF_STMT(BPF_RET | BPF_K, 0x42),
6147 BPF_STMT(BPF_RET | BPF_K, 0x66),
6149 CLASSIC | FLAG_NO_DATA,
6155 static struct net_device dev;
6157 static struct sk_buff *populate_skb(char *buf, int size)
6159 struct sk_buff *skb;
6161 if (size >= MAX_DATA)
6164 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
6168 __skb_put_data(skb, buf, size);
6170 /* Initialize a fake skb with test pattern. */
6171 skb_reset_mac_header(skb);
6172 skb->protocol = htons(ETH_P_IP);
6173 skb->pkt_type = SKB_TYPE;
6174 skb->mark = SKB_MARK;
6175 skb->hash = SKB_HASH;
6176 skb->queue_mapping = SKB_QUEUE_MAP;
6177 skb->vlan_tci = SKB_VLAN_TCI;
6178 skb->vlan_proto = htons(ETH_P_IP);
6180 skb->dev->ifindex = SKB_DEV_IFINDEX;
6181 skb->dev->type = SKB_DEV_TYPE;
6182 skb_set_network_header(skb, min(size, ETH_HLEN));
6187 static void *generate_test_data(struct bpf_test *test, int sub)
6189 struct sk_buff *skb;
6192 if (test->aux & FLAG_NO_DATA)
6195 /* Test case expects an skb, so populate one. Various
6196 * subtests generate skbs of different sizes based on
6199 skb = populate_skb(test->data, test->test[sub].data_size);
6203 if (test->aux & FLAG_SKB_FRAG) {
6205 * when the test requires a fragmented skb, add a
6206 * single fragment to the skb, filled with
6211 page = alloc_page(GFP_KERNEL);
6219 memcpy(ptr, test->frag_data, MAX_DATA);
6221 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
6233 static void release_test_data(const struct bpf_test *test, void *data)
6235 if (test->aux & FLAG_NO_DATA)
6241 static int filter_length(int which)
6243 struct sock_filter *fp;
6246 if (tests[which].fill_helper)
6247 return tests[which].u.ptr.len;
6249 fp = tests[which].u.insns;
6250 for (len = MAX_INSNS - 1; len > 0; --len)
6251 if (fp[len].code != 0 || fp[len].k != 0)
6257 static void *filter_pointer(int which)
6259 if (tests[which].fill_helper)
6260 return tests[which].u.ptr.insns;
6262 return tests[which].u.insns;
6265 static struct bpf_prog *generate_filter(int which, int *err)
6267 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
6268 unsigned int flen = filter_length(which);
6269 void *fptr = filter_pointer(which);
6270 struct sock_fprog_kern fprog;
6271 struct bpf_prog *fp;
6273 switch (test_type) {
6275 fprog.filter = fptr;
6278 *err = bpf_prog_create(&fp, &fprog);
6279 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
6280 if (*err == tests[which].expected_errcode) {
6282 /* Verifier rejected filter as expected. */
6286 pr_cont("UNEXPECTED_PASS\n");
6287 /* Verifier didn't reject the test that's
6288 * bad enough, just return!
6295 pr_cont("FAIL to prog_create err=%d len=%d\n",
6302 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
6304 pr_cont("UNEXPECTED_FAIL no memory left\n");
6310 /* Type doesn't really matter here as long as it's not unspec. */
6311 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
6312 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
6313 fp->aux->stack_depth = tests[which].stack_depth;
6315 /* We cannot error here as we don't need type compatibility
6318 fp = bpf_prog_select_runtime(fp, err);
6320 pr_cont("FAIL to select_runtime err=%d\n", *err);
6330 static void release_filter(struct bpf_prog *fp, int which)
6332 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
6334 switch (test_type) {
6336 bpf_prog_destroy(fp);
6344 static int __run_one(const struct bpf_prog *fp, const void *data,
6345 int runs, u64 *duration)
6350 start = ktime_get_ns();
6352 for (i = 0; i < runs; i++)
6353 ret = BPF_PROG_RUN(fp, data);
6355 finish = ktime_get_ns();
6357 *duration = finish - start;
6358 do_div(*duration, runs);
6363 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
6365 int err_cnt = 0, i, runs = MAX_TESTRUNS;
6367 for (i = 0; i < MAX_SUBTESTS; i++) {
6373 * NOTE: Several sub-tests may be present, in which case
6374 * a zero {data_size, result} tuple indicates the end of
6375 * the sub-test array. The first test is always run,
6376 * even if both data_size and result happen to be zero.
6379 test->test[i].data_size == 0 &&
6380 test->test[i].result == 0)
6383 data = generate_test_data(test, i);
6384 if (!data && !(test->aux & FLAG_NO_DATA)) {
6385 pr_cont("data generation failed ");
6389 ret = __run_one(fp, data, runs, &duration);
6390 release_test_data(test, data);
6392 if (ret == test->test[i].result) {
6393 pr_cont("%lld ", duration);
6395 pr_cont("ret %d != %d ", ret,
6396 test->test[i].result);
6404 static char test_name[64];
6405 module_param_string(test_name, test_name, sizeof(test_name), 0);
6407 static int test_id = -1;
6408 module_param(test_id, int, 0);
6410 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
6411 module_param_array(test_range, int, NULL, 0);
6413 static __init int find_test_index(const char *test_name)
6417 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6418 if (!strcmp(tests[i].descr, test_name))
6424 static __init int prepare_bpf_tests(void)
6430 * if a test_id was specified, use test_range to
6431 * cover only that test.
6433 if (test_id >= ARRAY_SIZE(tests)) {
6434 pr_err("test_bpf: invalid test_id specified.\n");
6438 test_range[0] = test_id;
6439 test_range[1] = test_id;
6440 } else if (*test_name) {
6442 * if a test_name was specified, find it and setup
6443 * test_range to cover only that test.
6445 int idx = find_test_index(test_name);
6448 pr_err("test_bpf: no test named '%s' found.\n",
6452 test_range[0] = idx;
6453 test_range[1] = idx;
6456 * check that the supplied test_range is valid.
6458 if (test_range[0] >= ARRAY_SIZE(tests) ||
6459 test_range[1] >= ARRAY_SIZE(tests) ||
6460 test_range[0] < 0 || test_range[1] < 0) {
6461 pr_err("test_bpf: test_range is out of bound.\n");
6465 if (test_range[1] < test_range[0]) {
6466 pr_err("test_bpf: test_range is ending before it starts.\n");
6471 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6472 if (tests[i].fill_helper &&
6473 tests[i].fill_helper(&tests[i]) < 0)
6480 static __init void destroy_bpf_tests(void)
6484 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6485 if (tests[i].fill_helper)
6486 kfree(tests[i].u.ptr.insns);
6490 static bool exclude_test(int test_id)
6492 return test_id < test_range[0] || test_id > test_range[1];
6495 static __init int test_bpf(void)
6497 int i, err_cnt = 0, pass_cnt = 0;
6498 int jit_cnt = 0, run_cnt = 0;
6500 for (i = 0; i < ARRAY_SIZE(tests); i++) {
6501 struct bpf_prog *fp;
6504 if (exclude_test(i))
6507 pr_info("#%d %s ", i, tests[i].descr);
6509 fp = generate_filter(i, &err);
6519 pr_cont("jited:%u ", fp->jited);
6525 err = run_one(fp, &tests[i]);
6526 release_filter(fp, i);
6529 pr_cont("FAIL (%d times)\n", err);
6537 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
6538 pass_cnt, err_cnt, jit_cnt, run_cnt);
6540 return err_cnt ? -EINVAL : 0;
6543 static int __init test_bpf_init(void)
6547 ret = prepare_bpf_tests();
6553 destroy_bpf_tests();
6557 static void __exit test_bpf_exit(void)
6561 module_init(test_bpf_init);
6562 module_exit(test_bpf_exit);
6564 MODULE_LICENSE("GPL");