]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - lib/test_bpf.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib/test_bpf: Add tests for unsigned BPF_JGT
[mirror_ubuntu-artful-kernel.git] / lib / test_bpf.c
CommitLineData
64a8946b
AS		 1/*
2 * Testsuite for BPF interpreter and BPF JIT compiler
3 *
4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
5 *
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.
9 *
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.
14 */
15
16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18#include <linux/init.h>
19#include <linux/module.h>
20#include <linux/filter.h>
4d9c5c53 21#include <linux/bpf.h>
64a8946b
AS		 22#include <linux/skbuff.h>
23#include <linux/netdevice.h>
24#include <linux/if_vlan.h>
a4afd37b 25#include <linux/random.h>
bac142ac 26#include <linux/highmem.h>
64a8946b 27
10f18e0b 28/* General test specific settings */
64a8946b 29#define MAX_SUBTESTS 3
10f18e0b 30#define MAX_TESTRUNS 10000
64a8946b
AS		 31#define MAX_DATA 128
32#define MAX_INSNS 512
33#define MAX_K 0xffffFFFF
34
10f18e0b 35/* Few constants used to init test 'skb' */
64a8946b
AS		 36#define SKB_TYPE 3
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
43
10f18e0b
DB		 44/* Redefine REGs to make tests less verbose */
45#define R0 BPF_REG_0
46#define R1 BPF_REG_1
47#define R2 BPF_REG_2
48#define R3 BPF_REG_3
49#define R4 BPF_REG_4
50#define R5 BPF_REG_5
51#define R6 BPF_REG_6
52#define R7 BPF_REG_7
53#define R8 BPF_REG_8
54#define R9 BPF_REG_9
55#define R10 BPF_REG_10
56
57/* Flags that can be passed to test cases */
58#define FLAG_NO_DATA BIT(0)
59#define FLAG_EXPECTED_FAIL BIT(1)
bac142ac 60#define FLAG_SKB_FRAG BIT(2)
10f18e0b
DB		 61
62enum {
63 CLASSIC = BIT(6), /* Old BPF instructions only. */
64 INTERNAL = BIT(7), /* Extended instruction set. */
65};
66
67#define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64a8946b
AS		 68
69struct bpf_test {
70 const char *descr;
71 union {
72 struct sock_filter insns[MAX_INSNS];
2695fb55 73 struct bpf_insn insns_int[MAX_INSNS];
a4afd37b
DB		 74 struct {
75 void *insns;
76 unsigned int len;
77 } ptr;
ece80490 78 } u;
10f18e0b 79 __u8 aux;
64a8946b
AS		 80 __u8 data[MAX_DATA];
81 struct {
82 int data_size;
83 __u32 result;
84 } test[MAX_SUBTESTS];
a4afd37b 85 int (*fill_helper)(struct bpf_test *self);
bac142ac 86 __u8 frag_data[MAX_DATA];
64a8946b
AS		 87};
88
a4afd37b
DB		 89/* Large test cases need separate allocation and fill handler. */
90
91static int bpf_fill_maxinsns1(struct bpf_test *self)
92{
93 unsigned int len = BPF_MAXINSNS;
94 struct sock_filter *insn;
95 __u32 k = ~0;
96 int i;
97
98 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
99 if (!insn)
100 return -ENOMEM;
101
102 for (i = 0; i < len; i++, k--)
103 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
104
105 self->u.ptr.insns = insn;
106 self->u.ptr.len = len;
107
108 return 0;
109}
110
111static int bpf_fill_maxinsns2(struct bpf_test *self)
112{
113 unsigned int len = BPF_MAXINSNS;
114 struct sock_filter *insn;
115 int i;
116
117 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
118 if (!insn)
119 return -ENOMEM;
120
121 for (i = 0; i < len; i++)
122 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
123
124 self->u.ptr.insns = insn;
125 self->u.ptr.len = len;
126
127 return 0;
128}
129
130static int bpf_fill_maxinsns3(struct bpf_test *self)
131{
132 unsigned int len = BPF_MAXINSNS;
133 struct sock_filter *insn;
134 struct rnd_state rnd;
135 int i;
136
137 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
138 if (!insn)
139 return -ENOMEM;
140
141 prandom_seed_state(&rnd, 3141592653589793238ULL);
142
143 for (i = 0; i < len - 1; i++) {
144 __u32 k = prandom_u32_state(&rnd);
145
146 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
147 }
148
149 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
150
151 self->u.ptr.insns = insn;
152 self->u.ptr.len = len;
153
154 return 0;
155}
156
157static int bpf_fill_maxinsns4(struct bpf_test *self)
158{
159 unsigned int len = BPF_MAXINSNS + 1;
160 struct sock_filter *insn;
161 int i;
162
163 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
164 if (!insn)
165 return -ENOMEM;
166
167 for (i = 0; i < len; i++)
168 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
169
170 self->u.ptr.insns = insn;
171 self->u.ptr.len = len;
172
173 return 0;
174}
175
176static int bpf_fill_maxinsns5(struct bpf_test *self)
177{
178 unsigned int len = BPF_MAXINSNS;
179 struct sock_filter *insn;
180 int i;
181
182 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
183 if (!insn)
184 return -ENOMEM;
185
186 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
187
188 for (i = 1; i < len - 1; i++)
189 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
190
191 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
192
193 self->u.ptr.insns = insn;
194 self->u.ptr.len = len;
195
196 return 0;
197}
198
199static int bpf_fill_maxinsns6(struct bpf_test *self)
200{
201 unsigned int len = BPF_MAXINSNS;
202 struct sock_filter *insn;
203 int i;
204
205 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
206 if (!insn)
207 return -ENOMEM;
208
209 for (i = 0; i < len - 1; i++)
210 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
211 SKF_AD_VLAN_TAG_PRESENT);
212
213 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
214
215 self->u.ptr.insns = insn;
216 self->u.ptr.len = len;
217
218 return 0;
219}
220
221static int bpf_fill_maxinsns7(struct bpf_test *self)
222{
223 unsigned int len = BPF_MAXINSNS;
224 struct sock_filter *insn;
225 int i;
226
227 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
228 if (!insn)
229 return -ENOMEM;
230
231 for (i = 0; i < len - 4; i++)
232 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
233 SKF_AD_CPU);
234
235 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
236 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
237 SKF_AD_CPU);
238 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
239 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
240
241 self->u.ptr.insns = insn;
242 self->u.ptr.len = len;
243
244 return 0;
245}
246
247static int bpf_fill_maxinsns8(struct bpf_test *self)
248{
249 unsigned int len = BPF_MAXINSNS;
250 struct sock_filter *insn;
251 int i, jmp_off = len - 3;
252
253 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
254 if (!insn)
255 return -ENOMEM;
256
257 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
258
259 for (i = 1; i < len - 1; i++)
260 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
261
262 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
263
264 self->u.ptr.insns = insn;
265 self->u.ptr.len = len;
266
267 return 0;
268}
269
3b529602
DB		 270static int bpf_fill_maxinsns9(struct bpf_test *self)
271{
272 unsigned int len = BPF_MAXINSNS;
273 struct bpf_insn *insn;
274 int i;
275
276 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
277 if (!insn)
278 return -ENOMEM;
279
280 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
281 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
282 insn[2] = BPF_EXIT_INSN();
283
284 for (i = 3; i < len - 2; i++)
285 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
286
287 insn[len - 2] = BPF_EXIT_INSN();
288 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
289
290 self->u.ptr.insns = insn;
291 self->u.ptr.len = len;
292
293 return 0;
294}
295
296static int bpf_fill_maxinsns10(struct bpf_test *self)
297{
298 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
299 struct bpf_insn *insn;
300 int i;
301
302 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
303 if (!insn)
304 return -ENOMEM;
305
306 for (i = 0; i < hlen / 2; i++)
307 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
308 for (i = hlen - 1; i > hlen / 2; i--)
309 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
310
311 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
312 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
313 insn[hlen + 1] = BPF_EXIT_INSN();
314
315 self->u.ptr.insns = insn;
316 self->u.ptr.len = len;
317
318 return 0;
319}
320
bde28bc6
DB		 321static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
322 unsigned int plen)
323{
324 struct sock_filter *insn;
325 unsigned int rlen;
326 int i, j;
327
328 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
329 if (!insn)
330 return -ENOMEM;
331
332 rlen = (len % plen) - 1;
333
334 for (i = 0; i + plen < len; i += plen)
335 for (j = 0; j < plen; j++)
336 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
337 plen - 1 - j, 0, 0);
338 for (j = 0; j < rlen; j++)
339 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
340 0, 0);
341
342 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
343
344 self->u.ptr.insns = insn;
345 self->u.ptr.len = len;
346
347 return 0;
348}
349
350static int bpf_fill_maxinsns11(struct bpf_test *self)
351{
352 /* Hits 70 passes on x86_64, so cannot get JITed there. */
353 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
354}
355
356static int bpf_fill_ja(struct bpf_test *self)
357{
358 /* Hits exactly 11 passes on x86_64 JIT. */
359 return __bpf_fill_ja(self, 12, 9);
360}
361
4d9c5c53
AS		 362static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
363{
364 unsigned int len = BPF_MAXINSNS;
365 struct sock_filter *insn;
366 int i;
367
368 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
369 if (!insn)
370 return -ENOMEM;
371
372 for (i = 0; i < len - 1; i += 2) {
373 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
374 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
375 SKF_AD_OFF + SKF_AD_CPU);
376 }
377
378 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
379
380 self->u.ptr.insns = insn;
381 self->u.ptr.len = len;
382
383 return 0;
384}
385
386#define PUSH_CNT 68
387/* test: {skb->data[0], vlan_push} x 68 + {skb->data[0], vlan_pop} x 68 */
388static int bpf_fill_ld_abs_vlan_push_pop(struct bpf_test *self)
389{
390 unsigned int len = BPF_MAXINSNS;
391 struct bpf_insn *insn;
392 int i = 0, j, k = 0;
393
394 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
395 if (!insn)
396 return -ENOMEM;
397
398 insn[i++] = BPF_MOV64_REG(R6, R1);
399loop:
400 for (j = 0; j < PUSH_CNT; j++) {
401 insn[i++] = BPF_LD_ABS(BPF_B, 0);
402 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
403 i++;
404 insn[i++] = BPF_MOV64_REG(R1, R6);
405 insn[i++] = BPF_MOV64_IMM(R2, 1);
406 insn[i++] = BPF_MOV64_IMM(R3, 2);
407 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
408 bpf_skb_vlan_push_proto.func - __bpf_call_base);
409 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
410 i++;
411 }
412
413 for (j = 0; j < PUSH_CNT; j++) {
414 insn[i++] = BPF_LD_ABS(BPF_B, 0);
415 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0x34, len - i - 2);
416 i++;
417 insn[i++] = BPF_MOV64_REG(R1, R6);
418 insn[i++] = BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
419 bpf_skb_vlan_pop_proto.func - __bpf_call_base);
420 insn[i] = BPF_JMP_IMM(BPF_JNE, R0, 0, len - i - 2);
421 i++;
422 }
423 if (++k < 5)
424 goto loop;
425
426 for (; i < len - 1; i++)
427 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xbef);
428
429 insn[len - 1] = BPF_EXIT_INSN();
430
431 self->u.ptr.insns = insn;
432 self->u.ptr.len = len;
433
434 return 0;
435}
436
64a8946b
AS		 437static struct bpf_test tests[] = {
438 {
439 "TAX",
ece80490 440 .u.insns = {
64a8946b
AS		 441 BPF_STMT(BPF_LD | BPF_IMM, 1),
442 BPF_STMT(BPF_MISC | BPF_TAX, 0),
443 BPF_STMT(BPF_LD | BPF_IMM, 2),
444 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
445 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
446 BPF_STMT(BPF_MISC | BPF_TAX, 0),
447 BPF_STMT(BPF_LD | BPF_LEN, 0),
448 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
449 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
450 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
451 BPF_STMT(BPF_RET | BPF_A, 0)
452 },
10f18e0b 453 CLASSIC,
64a8946b
AS		 454 { 10, 20, 30, 40, 50 },
455 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
456 },
9def624a
AS		 457 {
458 "TXA",
ece80490 459 .u.insns = {
9def624a
AS		 460 BPF_STMT(BPF_LDX | BPF_LEN, 0),
461 BPF_STMT(BPF_MISC | BPF_TXA, 0),
462 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
463 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
464 },
10f18e0b 465 CLASSIC,
9def624a
AS		 466 { 10, 20, 30, 40, 50 },
467 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
468 },
469 {
470 "ADD_SUB_MUL_K",
ece80490 471 .u.insns = {
9def624a
AS		 472 BPF_STMT(BPF_LD | BPF_IMM, 1),
473 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
474 BPF_STMT(BPF_LDX | BPF_IMM, 3),
475 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
476 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
477 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
478 BPF_STMT(BPF_RET | BPF_A, 0)
479 },
10f18e0b 480 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 481 { },
482 { { 0, 0xfffffffd } }
483 },
484 {
6867b17b 485 "DIV_MOD_KX",
ece80490 486 .u.insns = {
9def624a
AS		 487 BPF_STMT(BPF_LD | BPF_IMM, 8),
488 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
489 BPF_STMT(BPF_MISC | BPF_TAX, 0),
490 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
491 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
492 BPF_STMT(BPF_MISC | BPF_TAX, 0),
493 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
494 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
6867b17b
DK		 495 BPF_STMT(BPF_MISC | BPF_TAX, 0),
496 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
497 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
498 BPF_STMT(BPF_MISC | BPF_TAX, 0),
499 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
500 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
9def624a
AS		 501 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
502 BPF_STMT(BPF_RET | BPF_A, 0)
503 },
10f18e0b 504 CLASSIC | FLAG_NO_DATA,
9def624a 505 { },
6867b17b 506 { { 0, 0x20000000 } }
9def624a
AS		 507 },
508 {
509 "AND_OR_LSH_K",
ece80490 510 .u.insns = {
9def624a
AS		 511 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
512 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
513 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
514 BPF_STMT(BPF_MISC | BPF_TAX, 0),
515 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
516 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
517 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
518 BPF_STMT(BPF_RET | BPF_A, 0)
519 },
10f18e0b 520 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 521 { },
522 { { 0, 0x800000ff }, { 1, 0x800000ff } },
523 },
e9d94504
CG		 524 {
525 "LD_IMM_0",
526 .u.insns = {
527 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
528 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
529 BPF_STMT(BPF_RET | BPF_K, 0),
530 BPF_STMT(BPF_RET | BPF_K, 1),
531 },
532 CLASSIC,
533 { },
534 { { 1, 1 } },
535 },
9def624a
AS		 536 {
537 "LD_IND",
ece80490 538 .u.insns = {
9def624a
AS		 539 BPF_STMT(BPF_LDX | BPF_LEN, 0),
540 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
541 BPF_STMT(BPF_RET | BPF_K, 1)
542 },
10f18e0b 543 CLASSIC,
9def624a
AS		 544 { },
545 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
546 },
547 {
548 "LD_ABS",
ece80490 549 .u.insns = {
9def624a
AS		 550 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
551 BPF_STMT(BPF_RET | BPF_K, 1)
552 },
10f18e0b 553 CLASSIC,
9def624a
AS		 554 { },
555 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
556 },
557 {
558 "LD_ABS_LL",
ece80490 559 .u.insns = {
9def624a
AS		 560 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
561 BPF_STMT(BPF_MISC | BPF_TAX, 0),
562 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
563 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
564 BPF_STMT(BPF_RET | BPF_A, 0)
565 },
10f18e0b 566 CLASSIC,
9def624a
AS		 567 { 1, 2, 3 },
568 { { 1, 0 }, { 2, 3 } },
569 },
570 {
571 "LD_IND_LL",
ece80490 572 .u.insns = {
9def624a
AS		 573 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
574 BPF_STMT(BPF_LDX | BPF_LEN, 0),
575 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
576 BPF_STMT(BPF_MISC | BPF_TAX, 0),
577 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
578 BPF_STMT(BPF_RET | BPF_A, 0)
579 },
10f18e0b 580 CLASSIC,
9def624a
AS		 581 { 1, 2, 3, 0xff },
582 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
583 },
584 {
585 "LD_ABS_NET",
ece80490 586 .u.insns = {
9def624a
AS		 587 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
588 BPF_STMT(BPF_MISC | BPF_TAX, 0),
589 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
590 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
591 BPF_STMT(BPF_RET | BPF_A, 0)
592 },
10f18e0b 593 CLASSIC,
9def624a
AS		 594 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
595 { { 15, 0 }, { 16, 3 } },
596 },
597 {
598 "LD_IND_NET",
ece80490 599 .u.insns = {
9def624a
AS		 600 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
601 BPF_STMT(BPF_LDX | BPF_LEN, 0),
602 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
603 BPF_STMT(BPF_MISC | BPF_TAX, 0),
604 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
605 BPF_STMT(BPF_RET | BPF_A, 0)
606 },
10f18e0b 607 CLASSIC,
9def624a
AS		 608 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
609 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
610 },
611 {
612 "LD_PKTTYPE",
ece80490 613 .u.insns = {
9def624a
AS		 614 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
615 SKF_AD_OFF + SKF_AD_PKTTYPE),
616 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
617 BPF_STMT(BPF_RET | BPF_K, 1),
618 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
619 SKF_AD_OFF + SKF_AD_PKTTYPE),
620 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
621 BPF_STMT(BPF_RET | BPF_K, 1),
622 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
623 SKF_AD_OFF + SKF_AD_PKTTYPE),
624 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
625 BPF_STMT(BPF_RET | BPF_K, 1),
626 BPF_STMT(BPF_RET | BPF_A, 0)
627 },
10f18e0b 628 CLASSIC,
9def624a
AS		 629 { },
630 { { 1, 3 }, { 10, 3 } },
631 },
632 {
633 "LD_MARK",
ece80490 634 .u.insns = {
9def624a
AS		 635 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
636 SKF_AD_OFF + SKF_AD_MARK),
637 BPF_STMT(BPF_RET | BPF_A, 0)
638 },
10f18e0b 639 CLASSIC,
9def624a
AS		 640 { },
641 { { 1, SKB_MARK}, { 10, SKB_MARK} },
642 },
643 {
644 "LD_RXHASH",
ece80490 645 .u.insns = {
9def624a
AS		 646 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
647 SKF_AD_OFF + SKF_AD_RXHASH),
648 BPF_STMT(BPF_RET | BPF_A, 0)
649 },
10f18e0b 650 CLASSIC,
9def624a
AS		 651 { },
652 { { 1, SKB_HASH}, { 10, SKB_HASH} },
653 },
654 {
655 "LD_QUEUE",
ece80490 656 .u.insns = {
9def624a
AS		 657 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
658 SKF_AD_OFF + SKF_AD_QUEUE),
659 BPF_STMT(BPF_RET | BPF_A, 0)
660 },
10f18e0b 661 CLASSIC,
9def624a
AS		 662 { },
663 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
664 },
665 {
666 "LD_PROTOCOL",
ece80490 667 .u.insns = {
9def624a
AS		 668 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
669 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
670 BPF_STMT(BPF_RET | BPF_K, 0),
671 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
672 SKF_AD_OFF + SKF_AD_PROTOCOL),
673 BPF_STMT(BPF_MISC | BPF_TAX, 0),
674 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
675 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
676 BPF_STMT(BPF_RET | BPF_K, 0),
677 BPF_STMT(BPF_MISC | BPF_TXA, 0),
678 BPF_STMT(BPF_RET | BPF_A, 0)
679 },
10f18e0b 680 CLASSIC,
9def624a
AS		 681 { 10, 20, 30 },
682 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
683 },
684 {
685 "LD_VLAN_TAG",
ece80490 686 .u.insns = {
9def624a
AS		 687 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
688 SKF_AD_OFF + SKF_AD_VLAN_TAG),
689 BPF_STMT(BPF_RET | BPF_A, 0)
690 },
10f18e0b 691 CLASSIC,
9def624a
AS		 692 { },
693 {
694 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
695 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
696 },
697 },
698 {
699 "LD_VLAN_TAG_PRESENT",
ece80490 700 .u.insns = {
9def624a
AS		 701 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
702 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
703 BPF_STMT(BPF_RET | BPF_A, 0)
704 },
10f18e0b 705 CLASSIC,
9def624a
AS		 706 { },
707 {
708 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
709 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
710 },
711 },
712 {
713 "LD_IFINDEX",
ece80490 714 .u.insns = {
9def624a
AS		 715 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
716 SKF_AD_OFF + SKF_AD_IFINDEX),
717 BPF_STMT(BPF_RET | BPF_A, 0)
718 },
10f18e0b 719 CLASSIC,
9def624a
AS		 720 { },
721 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
722 },
723 {
724 "LD_HATYPE",
ece80490 725 .u.insns = {
9def624a
AS		 726 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
727 SKF_AD_OFF + SKF_AD_HATYPE),
728 BPF_STMT(BPF_RET | BPF_A, 0)
729 },
10f18e0b 730 CLASSIC,
9def624a
AS		 731 { },
732 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
733 },
734 {
735 "LD_CPU",
ece80490 736 .u.insns = {
9def624a
AS		 737 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
738 SKF_AD_OFF + SKF_AD_CPU),
739 BPF_STMT(BPF_MISC | BPF_TAX, 0),
740 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
741 SKF_AD_OFF + SKF_AD_CPU),
742 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
743 BPF_STMT(BPF_RET | BPF_A, 0)
744 },
10f18e0b 745 CLASSIC,
9def624a
AS		 746 { },
747 { { 1, 0 }, { 10, 0 } },
748 },
749 {
750 "LD_NLATTR",
ece80490 751 .u.insns = {
df6d0f98 752 BPF_STMT(BPF_LDX | BPF_IMM, 2),
9def624a
AS		 753 BPF_STMT(BPF_MISC | BPF_TXA, 0),
754 BPF_STMT(BPF_LDX | BPF_IMM, 3),
755 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
756 SKF_AD_OFF + SKF_AD_NLATTR),
757 BPF_STMT(BPF_RET | BPF_A, 0)
758 },
10f18e0b 759 CLASSIC,
df6d0f98
AS		 760#ifdef __BIG_ENDIAN
761 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
762#else
763 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
764#endif
765 { { 4, 0 }, { 20, 6 } },
9def624a
AS		 766 },
767 {
768 "LD_NLATTR_NEST",
ece80490 769 .u.insns = {
df6d0f98 770 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 771 BPF_STMT(BPF_LDX | BPF_IMM, 3),
772 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
773 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 774 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 775 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
776 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 777 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 778 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
779 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 780 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 781 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
782 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 783 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 784 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
785 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 786 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 787 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
788 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 789 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 790 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
791 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
df6d0f98 792 BPF_STMT(BPF_LD | BPF_IMM, 2),
9def624a
AS		 793 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
794 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
795 BPF_STMT(BPF_RET | BPF_A, 0)
796 },
10f18e0b 797 CLASSIC,
df6d0f98
AS		 798#ifdef __BIG_ENDIAN
799 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
800#else
801 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
802#endif
803 { { 4, 0 }, { 20, 10 } },
9def624a
AS		 804 },
805 {
806 "LD_PAYLOAD_OFF",
ece80490 807 .u.insns = {
9def624a
AS		 808 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
809 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
810 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
811 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
812 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
813 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
814 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
815 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
816 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
817 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
818 BPF_STMT(BPF_RET | BPF_A, 0)
819 },
10f18e0b 820 CLASSIC,
9def624a
AS		 821 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
822 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
823 * id 9737, seq 1, length 64
824 */
825 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
826 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
827 0x08, 0x00,
828 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
829 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
830 { { 30, 0 }, { 100, 42 } },
831 },
832 {
833 "LD_ANC_XOR",
ece80490 834 .u.insns = {
9def624a
AS		 835 BPF_STMT(BPF_LD | BPF_IMM, 10),
836 BPF_STMT(BPF_LDX | BPF_IMM, 300),
837 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
838 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
839 BPF_STMT(BPF_RET | BPF_A, 0)
840 },
10f18e0b 841 CLASSIC,
9def624a
AS		 842 { },
843 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
844 },
845 {
846 "SPILL_FILL",
ece80490 847 .u.insns = {
9def624a
AS		 848 BPF_STMT(BPF_LDX | BPF_LEN, 0),
849 BPF_STMT(BPF_LD | BPF_IMM, 2),
850 BPF_STMT(BPF_ALU | BPF_RSH, 1),
851 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
852 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
853 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
854 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
855 BPF_STMT(BPF_STX, 15), /* M3 = len */
856 BPF_STMT(BPF_LDX | BPF_MEM, 1),
857 BPF_STMT(BPF_LD | BPF_MEM, 2),
858 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
859 BPF_STMT(BPF_LDX | BPF_MEM, 15),
860 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
861 BPF_STMT(BPF_RET | BPF_A, 0)
862 },
10f18e0b 863 CLASSIC,
9def624a
AS		 864 { },
865 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
866 },
867 {
868 "JEQ",
ece80490 869 .u.insns = {
9def624a
AS		 870 BPF_STMT(BPF_LDX | BPF_LEN, 0),
871 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
872 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
873 BPF_STMT(BPF_RET | BPF_K, 1),
874 BPF_STMT(BPF_RET | BPF_K, MAX_K)
875 },
10f18e0b 876 CLASSIC,
9def624a
AS		 877 { 3, 3, 3, 3, 3 },
878 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
879 },
880 {
881 "JGT",
ece80490 882 .u.insns = {
9def624a
AS		 883 BPF_STMT(BPF_LDX | BPF_LEN, 0),
884 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
885 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
886 BPF_STMT(BPF_RET | BPF_K, 1),
887 BPF_STMT(BPF_RET | BPF_K, MAX_K)
888 },
10f18e0b 889 CLASSIC,
9def624a
AS		 890 { 4, 4, 4, 3, 3 },
891 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
892 },
893 {
894 "JGE",
ece80490 895 .u.insns = {
9def624a
AS		 896 BPF_STMT(BPF_LDX | BPF_LEN, 0),
897 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
898 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
899 BPF_STMT(BPF_RET | BPF_K, 10),
900 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
901 BPF_STMT(BPF_RET | BPF_K, 20),
902 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
903 BPF_STMT(BPF_RET | BPF_K, 30),
904 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
905 BPF_STMT(BPF_RET | BPF_K, 40),
906 BPF_STMT(BPF_RET | BPF_K, MAX_K)
907 },
10f18e0b 908 CLASSIC,
9def624a
AS		 909 { 1, 2, 3, 4, 5 },
910 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
911 },
912 {
913 "JSET",
ece80490 914 .u.insns = {
9def624a
AS		 915 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
916 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
917 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
918 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
919 BPF_STMT(BPF_LDX | BPF_LEN, 0),
920 BPF_STMT(BPF_MISC | BPF_TXA, 0),
921 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
922 BPF_STMT(BPF_MISC | BPF_TAX, 0),
923 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
924 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
925 BPF_STMT(BPF_RET | BPF_K, 10),
926 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
927 BPF_STMT(BPF_RET | BPF_K, 20),
928 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
929 BPF_STMT(BPF_RET | BPF_K, 30),
930 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
931 BPF_STMT(BPF_RET | BPF_K, 30),
932 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
933 BPF_STMT(BPF_RET | BPF_K, 30),
934 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
935 BPF_STMT(BPF_RET | BPF_K, 30),
936 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
937 BPF_STMT(BPF_RET | BPF_K, 30),
938 BPF_STMT(BPF_RET | BPF_K, MAX_K)
939 },
10f18e0b 940 CLASSIC,
9def624a
AS		 941 { 0, 0xAA, 0x55, 1 },
942 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
943 },
64a8946b
AS		 944 {
945 "tcpdump port 22",
ece80490 946 .u.insns = {
ce25b68b
DB		 947 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
948 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
949 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
950 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
951 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
952 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
953 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
954 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
955 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
956 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
957 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
958 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
959 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
960 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
961 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
962 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
963 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
964 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
965 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
966 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
967 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
968 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
969 BPF_STMT(BPF_RET | BPF_K, 0xffff),
970 BPF_STMT(BPF_RET | BPF_K, 0),
64a8946b 971 },
10f18e0b 972 CLASSIC,
64a8946b
AS		 973 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
974 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
975 * seq 1305692979:1305693027, ack 3650467037, win 65535,
976 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
977 */
978 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
979 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
980 0x08, 0x00,
981 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
982 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
983 0x0a, 0x01, 0x01, 0x95, /* ip src */
984 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
985 0xc2, 0x24,
986 0x00, 0x16 /* dst port */ },
987 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
988 },
9def624a
AS		 989 {
990 "tcpdump complex",
ece80490 991 .u.insns = {
9def624a
AS		 992 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
993 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
994 * (len > 115 or len < 30000000000)' -d
995 */
ce25b68b
DB		 996 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
997 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
998 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
999 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1000 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1001 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1002 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1003 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1004 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1005 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1006 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1007 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1008 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1009 BPF_STMT(BPF_ST, 1),
1010 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1011 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1012 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1013 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1014 BPF_STMT(BPF_LD | BPF_MEM, 1),
1015 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1016 BPF_STMT(BPF_ST, 5),
1017 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1018 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1019 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1020 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1021 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1022 BPF_STMT(BPF_LD | BPF_MEM, 5),
1023 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1024 BPF_STMT(BPF_LD | BPF_LEN, 0),
1025 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1026 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1027 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1028 BPF_STMT(BPF_RET | BPF_K, 0),
9def624a 1029 },
10f18e0b 1030 CLASSIC,
9def624a
AS		 1031 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1032 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1033 0x08, 0x00,
1034 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1035 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1036 0x0a, 0x01, 0x01, 0x95, /* ip src */
1037 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1038 0xc2, 0x24,
1039 0x00, 0x16 /* dst port */ },
1040 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1041 },
1042 {
1043 "RET_A",
ece80490 1044 .u.insns = {
9def624a
AS		 1045 /* check that unitialized X and A contain zeros */
1046 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1047 BPF_STMT(BPF_RET | BPF_A, 0)
1048 },
10f18e0b
DB		 1049 CLASSIC,
1050 { },
9def624a
AS		 1051 { {1, 0}, {2, 0} },
1052 },
1053 {
1054 "INT: ADD trivial",
ece80490 1055 .u.insns_int = {
9def624a
AS		 1056 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1057 BPF_ALU64_IMM(BPF_ADD, R1, 2),
1058 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1059 BPF_ALU64_REG(BPF_SUB, R1, R2),
1060 BPF_ALU64_IMM(BPF_ADD, R1, -1),
1061 BPF_ALU64_IMM(BPF_MUL, R1, 3),
1062 BPF_ALU64_REG(BPF_MOV, R0, R1),
1063 BPF_EXIT_INSN(),
1064 },
10f18e0b 1065 INTERNAL,
9def624a
AS		 1066 { },
1067 { { 0, 0xfffffffd } }
1068 },
1069 {
1070 "INT: MUL_X",
ece80490 1071 .u.insns_int = {
9def624a
AS		 1072 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1073 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1074 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1075 BPF_ALU64_REG(BPF_MUL, R1, R2),
1076 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1077 BPF_EXIT_INSN(),
1078 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1079 BPF_EXIT_INSN(),
1080 },
10f18e0b 1081 INTERNAL,
9def624a
AS		 1082 { },
1083 { { 0, 1 } }
1084 },
1085 {
1086 "INT: MUL_X2",
ece80490 1087 .u.insns_int = {
9def624a
AS		 1088 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1089 BPF_ALU32_IMM(BPF_MOV, R1, -1),
1090 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1091 BPF_ALU64_REG(BPF_MUL, R1, R2),
1092 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1093 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1094 BPF_EXIT_INSN(),
1095 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1096 BPF_EXIT_INSN(),
1097 },
10f18e0b 1098 INTERNAL,
9def624a
AS		 1099 { },
1100 { { 0, 1 } }
1101 },
1102 {
1103 "INT: MUL32_X",
ece80490 1104 .u.insns_int = {
9def624a
AS		 1105 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1106 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1107 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1108 BPF_ALU32_REG(BPF_MUL, R1, R2),
1109 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1110 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1111 BPF_EXIT_INSN(),
1112 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1113 BPF_EXIT_INSN(),
1114 },
10f18e0b 1115 INTERNAL,
9def624a
AS		 1116 { },
1117 { { 0, 1 } }
1118 },
1119 {
1120 /* Have to test all register combinations, since
1121 * JITing of different registers will produce
1122 * different asm code.
1123 */
1124 "INT: ADD 64-bit",
ece80490 1125 .u.insns_int = {
9def624a
AS		 1126 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1127 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1128 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1129 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1130 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1131 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1132 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1133 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1134 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1135 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1136 BPF_ALU64_IMM(BPF_ADD, R0, 20),
1137 BPF_ALU64_IMM(BPF_ADD, R1, 20),
1138 BPF_ALU64_IMM(BPF_ADD, R2, 20),
1139 BPF_ALU64_IMM(BPF_ADD, R3, 20),
1140 BPF_ALU64_IMM(BPF_ADD, R4, 20),
1141 BPF_ALU64_IMM(BPF_ADD, R5, 20),
1142 BPF_ALU64_IMM(BPF_ADD, R6, 20),
1143 BPF_ALU64_IMM(BPF_ADD, R7, 20),
1144 BPF_ALU64_IMM(BPF_ADD, R8, 20),
1145 BPF_ALU64_IMM(BPF_ADD, R9, 20),
1146 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1147 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1148 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1149 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1150 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1151 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1152 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1153 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1154 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1155 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1156 BPF_ALU64_REG(BPF_ADD, R0, R0),
1157 BPF_ALU64_REG(BPF_ADD, R0, R1),
1158 BPF_ALU64_REG(BPF_ADD, R0, R2),
1159 BPF_ALU64_REG(BPF_ADD, R0, R3),
1160 BPF_ALU64_REG(BPF_ADD, R0, R4),
1161 BPF_ALU64_REG(BPF_ADD, R0, R5),
1162 BPF_ALU64_REG(BPF_ADD, R0, R6),
1163 BPF_ALU64_REG(BPF_ADD, R0, R7),
1164 BPF_ALU64_REG(BPF_ADD, R0, R8),
1165 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1166 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1167 BPF_EXIT_INSN(),
1168 BPF_ALU64_REG(BPF_ADD, R1, R0),
1169 BPF_ALU64_REG(BPF_ADD, R1, R1),
1170 BPF_ALU64_REG(BPF_ADD, R1, R2),
1171 BPF_ALU64_REG(BPF_ADD, R1, R3),
1172 BPF_ALU64_REG(BPF_ADD, R1, R4),
1173 BPF_ALU64_REG(BPF_ADD, R1, R5),
1174 BPF_ALU64_REG(BPF_ADD, R1, R6),
1175 BPF_ALU64_REG(BPF_ADD, R1, R7),
1176 BPF_ALU64_REG(BPF_ADD, R1, R8),
1177 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1178 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1179 BPF_EXIT_INSN(),
1180 BPF_ALU64_REG(BPF_ADD, R2, R0),
1181 BPF_ALU64_REG(BPF_ADD, R2, R1),
1182 BPF_ALU64_REG(BPF_ADD, R2, R2),
1183 BPF_ALU64_REG(BPF_ADD, R2, R3),
1184 BPF_ALU64_REG(BPF_ADD, R2, R4),
1185 BPF_ALU64_REG(BPF_ADD, R2, R5),
1186 BPF_ALU64_REG(BPF_ADD, R2, R6),
1187 BPF_ALU64_REG(BPF_ADD, R2, R7),
1188 BPF_ALU64_REG(BPF_ADD, R2, R8),
1189 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1190 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1191 BPF_EXIT_INSN(),
1192 BPF_ALU64_REG(BPF_ADD, R3, R0),
1193 BPF_ALU64_REG(BPF_ADD, R3, R1),
1194 BPF_ALU64_REG(BPF_ADD, R3, R2),
1195 BPF_ALU64_REG(BPF_ADD, R3, R3),
1196 BPF_ALU64_REG(BPF_ADD, R3, R4),
1197 BPF_ALU64_REG(BPF_ADD, R3, R5),
1198 BPF_ALU64_REG(BPF_ADD, R3, R6),
1199 BPF_ALU64_REG(BPF_ADD, R3, R7),
1200 BPF_ALU64_REG(BPF_ADD, R3, R8),
1201 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1202 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1203 BPF_EXIT_INSN(),
1204 BPF_ALU64_REG(BPF_ADD, R4, R0),
1205 BPF_ALU64_REG(BPF_ADD, R4, R1),
1206 BPF_ALU64_REG(BPF_ADD, R4, R2),
1207 BPF_ALU64_REG(BPF_ADD, R4, R3),
1208 BPF_ALU64_REG(BPF_ADD, R4, R4),
1209 BPF_ALU64_REG(BPF_ADD, R4, R5),
1210 BPF_ALU64_REG(BPF_ADD, R4, R6),
1211 BPF_ALU64_REG(BPF_ADD, R4, R7),
1212 BPF_ALU64_REG(BPF_ADD, R4, R8),
1213 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1214 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1215 BPF_EXIT_INSN(),
1216 BPF_ALU64_REG(BPF_ADD, R5, R0),
1217 BPF_ALU64_REG(BPF_ADD, R5, R1),
1218 BPF_ALU64_REG(BPF_ADD, R5, R2),
1219 BPF_ALU64_REG(BPF_ADD, R5, R3),
1220 BPF_ALU64_REG(BPF_ADD, R5, R4),
1221 BPF_ALU64_REG(BPF_ADD, R5, R5),
1222 BPF_ALU64_REG(BPF_ADD, R5, R6),
1223 BPF_ALU64_REG(BPF_ADD, R5, R7),
1224 BPF_ALU64_REG(BPF_ADD, R5, R8),
1225 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1226 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1227 BPF_EXIT_INSN(),
1228 BPF_ALU64_REG(BPF_ADD, R6, R0),
1229 BPF_ALU64_REG(BPF_ADD, R6, R1),
1230 BPF_ALU64_REG(BPF_ADD, R6, R2),
1231 BPF_ALU64_REG(BPF_ADD, R6, R3),
1232 BPF_ALU64_REG(BPF_ADD, R6, R4),
1233 BPF_ALU64_REG(BPF_ADD, R6, R5),
1234 BPF_ALU64_REG(BPF_ADD, R6, R6),
1235 BPF_ALU64_REG(BPF_ADD, R6, R7),
1236 BPF_ALU64_REG(BPF_ADD, R6, R8),
1237 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1238 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1239 BPF_EXIT_INSN(),
1240 BPF_ALU64_REG(BPF_ADD, R7, R0),
1241 BPF_ALU64_REG(BPF_ADD, R7, R1),
1242 BPF_ALU64_REG(BPF_ADD, R7, R2),
1243 BPF_ALU64_REG(BPF_ADD, R7, R3),
1244 BPF_ALU64_REG(BPF_ADD, R7, R4),
1245 BPF_ALU64_REG(BPF_ADD, R7, R5),
1246 BPF_ALU64_REG(BPF_ADD, R7, R6),
1247 BPF_ALU64_REG(BPF_ADD, R7, R7),
1248 BPF_ALU64_REG(BPF_ADD, R7, R8),
1249 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1250 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1251 BPF_EXIT_INSN(),
1252 BPF_ALU64_REG(BPF_ADD, R8, R0),
1253 BPF_ALU64_REG(BPF_ADD, R8, R1),
1254 BPF_ALU64_REG(BPF_ADD, R8, R2),
1255 BPF_ALU64_REG(BPF_ADD, R8, R3),
1256 BPF_ALU64_REG(BPF_ADD, R8, R4),
1257 BPF_ALU64_REG(BPF_ADD, R8, R5),
1258 BPF_ALU64_REG(BPF_ADD, R8, R6),
1259 BPF_ALU64_REG(BPF_ADD, R8, R7),
1260 BPF_ALU64_REG(BPF_ADD, R8, R8),
1261 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1262 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1263 BPF_EXIT_INSN(),
1264 BPF_ALU64_REG(BPF_ADD, R9, R0),
1265 BPF_ALU64_REG(BPF_ADD, R9, R1),
1266 BPF_ALU64_REG(BPF_ADD, R9, R2),
1267 BPF_ALU64_REG(BPF_ADD, R9, R3),
1268 BPF_ALU64_REG(BPF_ADD, R9, R4),
1269 BPF_ALU64_REG(BPF_ADD, R9, R5),
1270 BPF_ALU64_REG(BPF_ADD, R9, R6),
1271 BPF_ALU64_REG(BPF_ADD, R9, R7),
1272 BPF_ALU64_REG(BPF_ADD, R9, R8),
1273 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1274 BPF_ALU64_REG(BPF_MOV, R0, R9),
1275 BPF_EXIT_INSN(),
1276 },
10f18e0b 1277 INTERNAL,
9def624a
AS		 1278 { },
1279 { { 0, 2957380 } }
1280 },
1281 {
1282 "INT: ADD 32-bit",
ece80490 1283 .u.insns_int = {
9def624a
AS		 1284 BPF_ALU32_IMM(BPF_MOV, R0, 20),
1285 BPF_ALU32_IMM(BPF_MOV, R1, 1),
1286 BPF_ALU32_IMM(BPF_MOV, R2, 2),
1287 BPF_ALU32_IMM(BPF_MOV, R3, 3),
1288 BPF_ALU32_IMM(BPF_MOV, R4, 4),
1289 BPF_ALU32_IMM(BPF_MOV, R5, 5),
1290 BPF_ALU32_IMM(BPF_MOV, R6, 6),
1291 BPF_ALU32_IMM(BPF_MOV, R7, 7),
1292 BPF_ALU32_IMM(BPF_MOV, R8, 8),
1293 BPF_ALU32_IMM(BPF_MOV, R9, 9),
1294 BPF_ALU64_IMM(BPF_ADD, R1, 10),
1295 BPF_ALU64_IMM(BPF_ADD, R2, 10),
1296 BPF_ALU64_IMM(BPF_ADD, R3, 10),
1297 BPF_ALU64_IMM(BPF_ADD, R4, 10),
1298 BPF_ALU64_IMM(BPF_ADD, R5, 10),
1299 BPF_ALU64_IMM(BPF_ADD, R6, 10),
1300 BPF_ALU64_IMM(BPF_ADD, R7, 10),
1301 BPF_ALU64_IMM(BPF_ADD, R8, 10),
1302 BPF_ALU64_IMM(BPF_ADD, R9, 10),
1303 BPF_ALU32_REG(BPF_ADD, R0, R1),
1304 BPF_ALU32_REG(BPF_ADD, R0, R2),
1305 BPF_ALU32_REG(BPF_ADD, R0, R3),
1306 BPF_ALU32_REG(BPF_ADD, R0, R4),
1307 BPF_ALU32_REG(BPF_ADD, R0, R5),
1308 BPF_ALU32_REG(BPF_ADD, R0, R6),
1309 BPF_ALU32_REG(BPF_ADD, R0, R7),
1310 BPF_ALU32_REG(BPF_ADD, R0, R8),
1311 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1312 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1313 BPF_EXIT_INSN(),
1314 BPF_ALU32_REG(BPF_ADD, R1, R0),
1315 BPF_ALU32_REG(BPF_ADD, R1, R1),
1316 BPF_ALU32_REG(BPF_ADD, R1, R2),
1317 BPF_ALU32_REG(BPF_ADD, R1, R3),
1318 BPF_ALU32_REG(BPF_ADD, R1, R4),
1319 BPF_ALU32_REG(BPF_ADD, R1, R5),
1320 BPF_ALU32_REG(BPF_ADD, R1, R6),
1321 BPF_ALU32_REG(BPF_ADD, R1, R7),
1322 BPF_ALU32_REG(BPF_ADD, R1, R8),
1323 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1324 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1325 BPF_EXIT_INSN(),
1326 BPF_ALU32_REG(BPF_ADD, R2, R0),
1327 BPF_ALU32_REG(BPF_ADD, R2, R1),
1328 BPF_ALU32_REG(BPF_ADD, R2, R2),
1329 BPF_ALU32_REG(BPF_ADD, R2, R3),
1330 BPF_ALU32_REG(BPF_ADD, R2, R4),
1331 BPF_ALU32_REG(BPF_ADD, R2, R5),
1332 BPF_ALU32_REG(BPF_ADD, R2, R6),
1333 BPF_ALU32_REG(BPF_ADD, R2, R7),
1334 BPF_ALU32_REG(BPF_ADD, R2, R8),
1335 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1336 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1337 BPF_EXIT_INSN(),
1338 BPF_ALU32_REG(BPF_ADD, R3, R0),
1339 BPF_ALU32_REG(BPF_ADD, R3, R1),
1340 BPF_ALU32_REG(BPF_ADD, R3, R2),
1341 BPF_ALU32_REG(BPF_ADD, R3, R3),
1342 BPF_ALU32_REG(BPF_ADD, R3, R4),
1343 BPF_ALU32_REG(BPF_ADD, R3, R5),
1344 BPF_ALU32_REG(BPF_ADD, R3, R6),
1345 BPF_ALU32_REG(BPF_ADD, R3, R7),
1346 BPF_ALU32_REG(BPF_ADD, R3, R8),
1347 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1348 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1349 BPF_EXIT_INSN(),
1350 BPF_ALU32_REG(BPF_ADD, R4, R0),
1351 BPF_ALU32_REG(BPF_ADD, R4, R1),
1352 BPF_ALU32_REG(BPF_ADD, R4, R2),
1353 BPF_ALU32_REG(BPF_ADD, R4, R3),
1354 BPF_ALU32_REG(BPF_ADD, R4, R4),
1355 BPF_ALU32_REG(BPF_ADD, R4, R5),
1356 BPF_ALU32_REG(BPF_ADD, R4, R6),
1357 BPF_ALU32_REG(BPF_ADD, R4, R7),
1358 BPF_ALU32_REG(BPF_ADD, R4, R8),
1359 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1360 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1361 BPF_EXIT_INSN(),
1362 BPF_ALU32_REG(BPF_ADD, R5, R0),
1363 BPF_ALU32_REG(BPF_ADD, R5, R1),
1364 BPF_ALU32_REG(BPF_ADD, R5, R2),
1365 BPF_ALU32_REG(BPF_ADD, R5, R3),
1366 BPF_ALU32_REG(BPF_ADD, R5, R4),
1367 BPF_ALU32_REG(BPF_ADD, R5, R5),
1368 BPF_ALU32_REG(BPF_ADD, R5, R6),
1369 BPF_ALU32_REG(BPF_ADD, R5, R7),
1370 BPF_ALU32_REG(BPF_ADD, R5, R8),
1371 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1372 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1373 BPF_EXIT_INSN(),
1374 BPF_ALU32_REG(BPF_ADD, R6, R0),
1375 BPF_ALU32_REG(BPF_ADD, R6, R1),
1376 BPF_ALU32_REG(BPF_ADD, R6, R2),
1377 BPF_ALU32_REG(BPF_ADD, R6, R3),
1378 BPF_ALU32_REG(BPF_ADD, R6, R4),
1379 BPF_ALU32_REG(BPF_ADD, R6, R5),
1380 BPF_ALU32_REG(BPF_ADD, R6, R6),
1381 BPF_ALU32_REG(BPF_ADD, R6, R7),
1382 BPF_ALU32_REG(BPF_ADD, R6, R8),
1383 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1384 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1385 BPF_EXIT_INSN(),
1386 BPF_ALU32_REG(BPF_ADD, R7, R0),
1387 BPF_ALU32_REG(BPF_ADD, R7, R1),
1388 BPF_ALU32_REG(BPF_ADD, R7, R2),
1389 BPF_ALU32_REG(BPF_ADD, R7, R3),
1390 BPF_ALU32_REG(BPF_ADD, R7, R4),
1391 BPF_ALU32_REG(BPF_ADD, R7, R5),
1392 BPF_ALU32_REG(BPF_ADD, R7, R6),
1393 BPF_ALU32_REG(BPF_ADD, R7, R7),
1394 BPF_ALU32_REG(BPF_ADD, R7, R8),
1395 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1396 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1397 BPF_EXIT_INSN(),
1398 BPF_ALU32_REG(BPF_ADD, R8, R0),
1399 BPF_ALU32_REG(BPF_ADD, R8, R1),
1400 BPF_ALU32_REG(BPF_ADD, R8, R2),
1401 BPF_ALU32_REG(BPF_ADD, R8, R3),
1402 BPF_ALU32_REG(BPF_ADD, R8, R4),
1403 BPF_ALU32_REG(BPF_ADD, R8, R5),
1404 BPF_ALU32_REG(BPF_ADD, R8, R6),
1405 BPF_ALU32_REG(BPF_ADD, R8, R7),
1406 BPF_ALU32_REG(BPF_ADD, R8, R8),
1407 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1408 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1409 BPF_EXIT_INSN(),
1410 BPF_ALU32_REG(BPF_ADD, R9, R0),
1411 BPF_ALU32_REG(BPF_ADD, R9, R1),
1412 BPF_ALU32_REG(BPF_ADD, R9, R2),
1413 BPF_ALU32_REG(BPF_ADD, R9, R3),
1414 BPF_ALU32_REG(BPF_ADD, R9, R4),
1415 BPF_ALU32_REG(BPF_ADD, R9, R5),
1416 BPF_ALU32_REG(BPF_ADD, R9, R6),
1417 BPF_ALU32_REG(BPF_ADD, R9, R7),
1418 BPF_ALU32_REG(BPF_ADD, R9, R8),
1419 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1420 BPF_ALU32_REG(BPF_MOV, R0, R9),
1421 BPF_EXIT_INSN(),
1422 },
10f18e0b 1423 INTERNAL,
9def624a
AS		 1424 { },
1425 { { 0, 2957380 } }
1426 },
1427 { /* Mainly checking JIT here. */
1428 "INT: SUB",
ece80490 1429 .u.insns_int = {
9def624a
AS		 1430 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1431 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1432 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1433 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1434 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1435 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1436 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1437 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1438 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1439 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1440 BPF_ALU64_REG(BPF_SUB, R0, R0),
1441 BPF_ALU64_REG(BPF_SUB, R0, R1),
1442 BPF_ALU64_REG(BPF_SUB, R0, R2),
1443 BPF_ALU64_REG(BPF_SUB, R0, R3),
1444 BPF_ALU64_REG(BPF_SUB, R0, R4),
1445 BPF_ALU64_REG(BPF_SUB, R0, R5),
1446 BPF_ALU64_REG(BPF_SUB, R0, R6),
1447 BPF_ALU64_REG(BPF_SUB, R0, R7),
1448 BPF_ALU64_REG(BPF_SUB, R0, R8),
1449 BPF_ALU64_REG(BPF_SUB, R0, R9),
1450 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1451 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1452 BPF_EXIT_INSN(),
1453 BPF_ALU64_REG(BPF_SUB, R1, R0),
1454 BPF_ALU64_REG(BPF_SUB, R1, R2),
1455 BPF_ALU64_REG(BPF_SUB, R1, R3),
1456 BPF_ALU64_REG(BPF_SUB, R1, R4),
1457 BPF_ALU64_REG(BPF_SUB, R1, R5),
1458 BPF_ALU64_REG(BPF_SUB, R1, R6),
1459 BPF_ALU64_REG(BPF_SUB, R1, R7),
1460 BPF_ALU64_REG(BPF_SUB, R1, R8),
1461 BPF_ALU64_REG(BPF_SUB, R1, R9),
1462 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1463 BPF_ALU64_REG(BPF_SUB, R2, R0),
1464 BPF_ALU64_REG(BPF_SUB, R2, R1),
1465 BPF_ALU64_REG(BPF_SUB, R2, R3),
1466 BPF_ALU64_REG(BPF_SUB, R2, R4),
1467 BPF_ALU64_REG(BPF_SUB, R2, R5),
1468 BPF_ALU64_REG(BPF_SUB, R2, R6),
1469 BPF_ALU64_REG(BPF_SUB, R2, R7),
1470 BPF_ALU64_REG(BPF_SUB, R2, R8),
1471 BPF_ALU64_REG(BPF_SUB, R2, R9),
1472 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1473 BPF_ALU64_REG(BPF_SUB, R3, R0),
1474 BPF_ALU64_REG(BPF_SUB, R3, R1),
1475 BPF_ALU64_REG(BPF_SUB, R3, R2),
1476 BPF_ALU64_REG(BPF_SUB, R3, R4),
1477 BPF_ALU64_REG(BPF_SUB, R3, R5),
1478 BPF_ALU64_REG(BPF_SUB, R3, R6),
1479 BPF_ALU64_REG(BPF_SUB, R3, R7),
1480 BPF_ALU64_REG(BPF_SUB, R3, R8),
1481 BPF_ALU64_REG(BPF_SUB, R3, R9),
1482 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1483 BPF_ALU64_REG(BPF_SUB, R4, R0),
1484 BPF_ALU64_REG(BPF_SUB, R4, R1),
1485 BPF_ALU64_REG(BPF_SUB, R4, R2),
1486 BPF_ALU64_REG(BPF_SUB, R4, R3),
1487 BPF_ALU64_REG(BPF_SUB, R4, R5),
1488 BPF_ALU64_REG(BPF_SUB, R4, R6),
1489 BPF_ALU64_REG(BPF_SUB, R4, R7),
1490 BPF_ALU64_REG(BPF_SUB, R4, R8),
1491 BPF_ALU64_REG(BPF_SUB, R4, R9),
1492 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1493 BPF_ALU64_REG(BPF_SUB, R5, R0),
1494 BPF_ALU64_REG(BPF_SUB, R5, R1),
1495 BPF_ALU64_REG(BPF_SUB, R5, R2),
1496 BPF_ALU64_REG(BPF_SUB, R5, R3),
1497 BPF_ALU64_REG(BPF_SUB, R5, R4),
1498 BPF_ALU64_REG(BPF_SUB, R5, R6),
1499 BPF_ALU64_REG(BPF_SUB, R5, R7),
1500 BPF_ALU64_REG(BPF_SUB, R5, R8),
1501 BPF_ALU64_REG(BPF_SUB, R5, R9),
1502 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1503 BPF_ALU64_REG(BPF_SUB, R6, R0),
1504 BPF_ALU64_REG(BPF_SUB, R6, R1),
1505 BPF_ALU64_REG(BPF_SUB, R6, R2),
1506 BPF_ALU64_REG(BPF_SUB, R6, R3),
1507 BPF_ALU64_REG(BPF_SUB, R6, R4),
1508 BPF_ALU64_REG(BPF_SUB, R6, R5),
1509 BPF_ALU64_REG(BPF_SUB, R6, R7),
1510 BPF_ALU64_REG(BPF_SUB, R6, R8),
1511 BPF_ALU64_REG(BPF_SUB, R6, R9),
1512 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1513 BPF_ALU64_REG(BPF_SUB, R7, R0),
1514 BPF_ALU64_REG(BPF_SUB, R7, R1),
1515 BPF_ALU64_REG(BPF_SUB, R7, R2),
1516 BPF_ALU64_REG(BPF_SUB, R7, R3),
1517 BPF_ALU64_REG(BPF_SUB, R7, R4),
1518 BPF_ALU64_REG(BPF_SUB, R7, R5),
1519 BPF_ALU64_REG(BPF_SUB, R7, R6),
1520 BPF_ALU64_REG(BPF_SUB, R7, R8),
1521 BPF_ALU64_REG(BPF_SUB, R7, R9),
1522 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1523 BPF_ALU64_REG(BPF_SUB, R8, R0),
1524 BPF_ALU64_REG(BPF_SUB, R8, R1),
1525 BPF_ALU64_REG(BPF_SUB, R8, R2),
1526 BPF_ALU64_REG(BPF_SUB, R8, R3),
1527 BPF_ALU64_REG(BPF_SUB, R8, R4),
1528 BPF_ALU64_REG(BPF_SUB, R8, R5),
1529 BPF_ALU64_REG(BPF_SUB, R8, R6),
1530 BPF_ALU64_REG(BPF_SUB, R8, R7),
1531 BPF_ALU64_REG(BPF_SUB, R8, R9),
1532 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1533 BPF_ALU64_REG(BPF_SUB, R9, R0),
1534 BPF_ALU64_REG(BPF_SUB, R9, R1),
1535 BPF_ALU64_REG(BPF_SUB, R9, R2),
1536 BPF_ALU64_REG(BPF_SUB, R9, R3),
1537 BPF_ALU64_REG(BPF_SUB, R9, R4),
1538 BPF_ALU64_REG(BPF_SUB, R9, R5),
1539 BPF_ALU64_REG(BPF_SUB, R9, R6),
1540 BPF_ALU64_REG(BPF_SUB, R9, R7),
1541 BPF_ALU64_REG(BPF_SUB, R9, R8),
1542 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1543 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1544 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1545 BPF_ALU64_REG(BPF_SUB, R0, R1),
1546 BPF_ALU64_REG(BPF_SUB, R0, R2),
1547 BPF_ALU64_REG(BPF_SUB, R0, R3),
1548 BPF_ALU64_REG(BPF_SUB, R0, R4),
1549 BPF_ALU64_REG(BPF_SUB, R0, R5),
1550 BPF_ALU64_REG(BPF_SUB, R0, R6),
1551 BPF_ALU64_REG(BPF_SUB, R0, R7),
1552 BPF_ALU64_REG(BPF_SUB, R0, R8),
1553 BPF_ALU64_REG(BPF_SUB, R0, R9),
1554 BPF_EXIT_INSN(),
1555 },
10f18e0b 1556 INTERNAL,
9def624a
AS		 1557 { },
1558 { { 0, 11 } }
1559 },
1560 { /* Mainly checking JIT here. */
1561 "INT: XOR",
ece80490 1562 .u.insns_int = {
9def624a
AS		 1563 BPF_ALU64_REG(BPF_SUB, R0, R0),
1564 BPF_ALU64_REG(BPF_XOR, R1, R1),
1565 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1566 BPF_EXIT_INSN(),
1567 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1568 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1569 BPF_ALU64_REG(BPF_SUB, R1, R1),
1570 BPF_ALU64_REG(BPF_XOR, R2, R2),
1571 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1572 BPF_EXIT_INSN(),
1573 BPF_ALU64_REG(BPF_SUB, R2, R2),
1574 BPF_ALU64_REG(BPF_XOR, R3, R3),
1575 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1576 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1577 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1578 BPF_EXIT_INSN(),
1579 BPF_ALU64_REG(BPF_SUB, R3, R3),
1580 BPF_ALU64_REG(BPF_XOR, R4, R4),
1581 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1582 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1583 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1584 BPF_EXIT_INSN(),
1585 BPF_ALU64_REG(BPF_SUB, R4, R4),
1586 BPF_ALU64_REG(BPF_XOR, R5, R5),
1587 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1588 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1589 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1590 BPF_EXIT_INSN(),
1591 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1592 BPF_ALU64_REG(BPF_SUB, R5, R5),
1593 BPF_ALU64_REG(BPF_XOR, R6, R6),
1594 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1595 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1596 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1597 BPF_EXIT_INSN(),
1598 BPF_ALU64_REG(BPF_SUB, R6, R6),
1599 BPF_ALU64_REG(BPF_XOR, R7, R7),
1600 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1601 BPF_EXIT_INSN(),
1602 BPF_ALU64_REG(BPF_SUB, R7, R7),
1603 BPF_ALU64_REG(BPF_XOR, R8, R8),
1604 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1605 BPF_EXIT_INSN(),
1606 BPF_ALU64_REG(BPF_SUB, R8, R8),
1607 BPF_ALU64_REG(BPF_XOR, R9, R9),
1608 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1609 BPF_EXIT_INSN(),
1610 BPF_ALU64_REG(BPF_SUB, R9, R9),
1611 BPF_ALU64_REG(BPF_XOR, R0, R0),
1612 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1613 BPF_EXIT_INSN(),
1614 BPF_ALU64_REG(BPF_SUB, R1, R1),
1615 BPF_ALU64_REG(BPF_XOR, R0, R0),
1616 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1617 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1618 BPF_EXIT_INSN(),
1619 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1620 BPF_EXIT_INSN(),
1621 },
10f18e0b 1622 INTERNAL,
9def624a
AS		 1623 { },
1624 { { 0, 1 } }
1625 },
1626 { /* Mainly checking JIT here. */
1627 "INT: MUL",
ece80490 1628 .u.insns_int = {
9def624a
AS		 1629 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1630 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1631 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1632 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1633 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1634 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1635 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1636 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1637 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1638 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1639 BPF_ALU64_REG(BPF_MUL, R0, R0),
1640 BPF_ALU64_REG(BPF_MUL, R0, R1),
1641 BPF_ALU64_REG(BPF_MUL, R0, R2),
1642 BPF_ALU64_REG(BPF_MUL, R0, R3),
1643 BPF_ALU64_REG(BPF_MUL, R0, R4),
1644 BPF_ALU64_REG(BPF_MUL, R0, R5),
1645 BPF_ALU64_REG(BPF_MUL, R0, R6),
1646 BPF_ALU64_REG(BPF_MUL, R0, R7),
1647 BPF_ALU64_REG(BPF_MUL, R0, R8),
1648 BPF_ALU64_REG(BPF_MUL, R0, R9),
1649 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1650 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1651 BPF_EXIT_INSN(),
1652 BPF_ALU64_REG(BPF_MUL, R1, R0),
1653 BPF_ALU64_REG(BPF_MUL, R1, R2),
1654 BPF_ALU64_REG(BPF_MUL, R1, R3),
1655 BPF_ALU64_REG(BPF_MUL, R1, R4),
1656 BPF_ALU64_REG(BPF_MUL, R1, R5),
1657 BPF_ALU64_REG(BPF_MUL, R1, R6),
1658 BPF_ALU64_REG(BPF_MUL, R1, R7),
1659 BPF_ALU64_REG(BPF_MUL, R1, R8),
1660 BPF_ALU64_REG(BPF_MUL, R1, R9),
1661 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1662 BPF_ALU64_REG(BPF_MOV, R2, R1),
1663 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1664 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1665 BPF_EXIT_INSN(),
1666 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1667 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1668 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1669 BPF_EXIT_INSN(),
1670 BPF_ALU64_REG(BPF_MUL, R2, R0),
1671 BPF_ALU64_REG(BPF_MUL, R2, R1),
1672 BPF_ALU64_REG(BPF_MUL, R2, R3),
1673 BPF_ALU64_REG(BPF_MUL, R2, R4),
1674 BPF_ALU64_REG(BPF_MUL, R2, R5),
1675 BPF_ALU64_REG(BPF_MUL, R2, R6),
1676 BPF_ALU64_REG(BPF_MUL, R2, R7),
1677 BPF_ALU64_REG(BPF_MUL, R2, R8),
1678 BPF_ALU64_REG(BPF_MUL, R2, R9),
1679 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1680 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1681 BPF_ALU64_REG(BPF_MOV, R0, R2),
1682 BPF_EXIT_INSN(),
1683 },
10f18e0b 1684 INTERNAL,
9def624a
AS		 1685 { },
1686 { { 0, 0x35d97ef2 } }
1687 },
9dd2af83
DB		 1688 { /* Mainly checking JIT here. */
1689 "MOV REG64",
1690 .u.insns_int = {
1691 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1692 BPF_MOV64_REG(R1, R0),
1693 BPF_MOV64_REG(R2, R1),
1694 BPF_MOV64_REG(R3, R2),
1695 BPF_MOV64_REG(R4, R3),
1696 BPF_MOV64_REG(R5, R4),
1697 BPF_MOV64_REG(R6, R5),
1698 BPF_MOV64_REG(R7, R6),
1699 BPF_MOV64_REG(R8, R7),
1700 BPF_MOV64_REG(R9, R8),
1701 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1702 BPF_ALU64_IMM(BPF_MOV, R1, 0),
1703 BPF_ALU64_IMM(BPF_MOV, R2, 0),
1704 BPF_ALU64_IMM(BPF_MOV, R3, 0),
1705 BPF_ALU64_IMM(BPF_MOV, R4, 0),
1706 BPF_ALU64_IMM(BPF_MOV, R5, 0),
1707 BPF_ALU64_IMM(BPF_MOV, R6, 0),
1708 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1709 BPF_ALU64_IMM(BPF_MOV, R8, 0),
1710 BPF_ALU64_IMM(BPF_MOV, R9, 0),
1711 BPF_ALU64_REG(BPF_ADD, R0, R0),
1712 BPF_ALU64_REG(BPF_ADD, R0, R1),
1713 BPF_ALU64_REG(BPF_ADD, R0, R2),
1714 BPF_ALU64_REG(BPF_ADD, R0, R3),
1715 BPF_ALU64_REG(BPF_ADD, R0, R4),
1716 BPF_ALU64_REG(BPF_ADD, R0, R5),
1717 BPF_ALU64_REG(BPF_ADD, R0, R6),
1718 BPF_ALU64_REG(BPF_ADD, R0, R7),
1719 BPF_ALU64_REG(BPF_ADD, R0, R8),
1720 BPF_ALU64_REG(BPF_ADD, R0, R9),
1721 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1722 BPF_EXIT_INSN(),
1723 },
1724 INTERNAL,
1725 { },
1726 { { 0, 0xfefe } }
1727 },
1728 { /* Mainly checking JIT here. */
1729 "MOV REG32",
1730 .u.insns_int = {
1731 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1732 BPF_MOV64_REG(R1, R0),
1733 BPF_MOV64_REG(R2, R1),
1734 BPF_MOV64_REG(R3, R2),
1735 BPF_MOV64_REG(R4, R3),
1736 BPF_MOV64_REG(R5, R4),
1737 BPF_MOV64_REG(R6, R5),
1738 BPF_MOV64_REG(R7, R6),
1739 BPF_MOV64_REG(R8, R7),
1740 BPF_MOV64_REG(R9, R8),
1741 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1742 BPF_ALU32_IMM(BPF_MOV, R1, 0),
1743 BPF_ALU32_IMM(BPF_MOV, R2, 0),
1744 BPF_ALU32_IMM(BPF_MOV, R3, 0),
1745 BPF_ALU32_IMM(BPF_MOV, R4, 0),
1746 BPF_ALU32_IMM(BPF_MOV, R5, 0),
1747 BPF_ALU32_IMM(BPF_MOV, R6, 0),
1748 BPF_ALU32_IMM(BPF_MOV, R7, 0),
1749 BPF_ALU32_IMM(BPF_MOV, R8, 0),
1750 BPF_ALU32_IMM(BPF_MOV, R9, 0),
1751 BPF_ALU64_REG(BPF_ADD, R0, R0),
1752 BPF_ALU64_REG(BPF_ADD, R0, R1),
1753 BPF_ALU64_REG(BPF_ADD, R0, R2),
1754 BPF_ALU64_REG(BPF_ADD, R0, R3),
1755 BPF_ALU64_REG(BPF_ADD, R0, R4),
1756 BPF_ALU64_REG(BPF_ADD, R0, R5),
1757 BPF_ALU64_REG(BPF_ADD, R0, R6),
1758 BPF_ALU64_REG(BPF_ADD, R0, R7),
1759 BPF_ALU64_REG(BPF_ADD, R0, R8),
1760 BPF_ALU64_REG(BPF_ADD, R0, R9),
1761 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1762 BPF_EXIT_INSN(),
1763 },
1764 INTERNAL,
1765 { },
1766 { { 0, 0xfefe } }
1767 },
1768 { /* Mainly checking JIT here. */
1769 "LD IMM64",
1770 .u.insns_int = {
1771 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1772 BPF_MOV64_REG(R1, R0),
1773 BPF_MOV64_REG(R2, R1),
1774 BPF_MOV64_REG(R3, R2),
1775 BPF_MOV64_REG(R4, R3),
1776 BPF_MOV64_REG(R5, R4),
1777 BPF_MOV64_REG(R6, R5),
1778 BPF_MOV64_REG(R7, R6),
1779 BPF_MOV64_REG(R8, R7),
1780 BPF_MOV64_REG(R9, R8),
1781 BPF_LD_IMM64(R0, 0x0LL),
1782 BPF_LD_IMM64(R1, 0x0LL),
1783 BPF_LD_IMM64(R2, 0x0LL),
1784 BPF_LD_IMM64(R3, 0x0LL),
1785 BPF_LD_IMM64(R4, 0x0LL),
1786 BPF_LD_IMM64(R5, 0x0LL),
1787 BPF_LD_IMM64(R6, 0x0LL),
1788 BPF_LD_IMM64(R7, 0x0LL),
1789 BPF_LD_IMM64(R8, 0x0LL),
1790 BPF_LD_IMM64(R9, 0x0LL),
1791 BPF_ALU64_REG(BPF_ADD, R0, R0),
1792 BPF_ALU64_REG(BPF_ADD, R0, R1),
1793 BPF_ALU64_REG(BPF_ADD, R0, R2),
1794 BPF_ALU64_REG(BPF_ADD, R0, R3),
1795 BPF_ALU64_REG(BPF_ADD, R0, R4),
1796 BPF_ALU64_REG(BPF_ADD, R0, R5),
1797 BPF_ALU64_REG(BPF_ADD, R0, R6),
1798 BPF_ALU64_REG(BPF_ADD, R0, R7),
1799 BPF_ALU64_REG(BPF_ADD, R0, R8),
1800 BPF_ALU64_REG(BPF_ADD, R0, R9),
1801 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1802 BPF_EXIT_INSN(),
1803 },
1804 INTERNAL,
1805 { },
1806 { { 0, 0xfefe } }
1807 },
9def624a
AS		 1808 {
1809 "INT: ALU MIX",
ece80490 1810 .u.insns_int = {
9def624a
AS		 1811 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1812 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1813 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1814 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1815 BPF_ALU64_REG(BPF_DIV, R0, R2),
1816 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1817 BPF_EXIT_INSN(),
1818 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1819 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1820 BPF_EXIT_INSN(),
1821 BPF_ALU64_IMM(BPF_MOV, R0, -1),
72b603ee
AS		 1822 BPF_EXIT_INSN(),
1823 },
1824 INTERNAL,
1825 { },
1826 { { 0, -1 } }
1827 },
1828 {
1829 "INT: shifts by register",
1830 .u.insns_int = {
1831 BPF_MOV64_IMM(R0, -1234),
1832 BPF_MOV64_IMM(R1, 1),
1833 BPF_ALU32_REG(BPF_RSH, R0, R1),
1834 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1835 BPF_EXIT_INSN(),
1836 BPF_MOV64_IMM(R2, 1),
1837 BPF_ALU64_REG(BPF_LSH, R0, R2),
1838 BPF_MOV32_IMM(R4, -1234),
1839 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1840 BPF_EXIT_INSN(),
1841 BPF_ALU64_IMM(BPF_AND, R4, 63),
1842 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1843 BPF_MOV64_IMM(R3, 47),
1844 BPF_ALU64_REG(BPF_ARSH, R0, R3),
1845 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1846 BPF_EXIT_INSN(),
1847 BPF_MOV64_IMM(R2, 1),
1848 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1849 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1850 BPF_EXIT_INSN(),
1851 BPF_MOV64_IMM(R4, 4),
1852 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1853 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1854 BPF_EXIT_INSN(),
1855 BPF_MOV64_IMM(R4, 5),
1856 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1857 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1858 BPF_EXIT_INSN(),
1859 BPF_MOV64_IMM(R0, -1),
9def624a
AS		 1860 BPF_EXIT_INSN(),
1861 },
10f18e0b 1862 INTERNAL,
9def624a
AS		 1863 { },
1864 { { 0, -1 } }
1865 },
64a8946b
AS		 1866 {
1867 "INT: DIV + ABS",
ece80490 1868 .u.insns_int = {
64a8946b
AS		 1869 BPF_ALU64_REG(BPF_MOV, R6, R1),
1870 BPF_LD_ABS(BPF_B, 3),
1871 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1872 BPF_ALU32_REG(BPF_DIV, R0, R2),
1873 BPF_ALU64_REG(BPF_MOV, R8, R0),
1874 BPF_LD_ABS(BPF_B, 4),
1875 BPF_ALU64_REG(BPF_ADD, R8, R0),
1876 BPF_LD_IND(BPF_B, R8, -70),
1877 BPF_EXIT_INSN(),
1878 },
10f18e0b 1879 INTERNAL,
64a8946b
AS		 1880 { 10, 20, 30, 40, 50 },
1881 { { 4, 0 }, { 5, 10 } }
1882 },
9def624a
AS		 1883 {
1884 "INT: DIV by zero",
ece80490 1885 .u.insns_int = {
9def624a
AS		 1886 BPF_ALU64_REG(BPF_MOV, R6, R1),
1887 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1888 BPF_LD_ABS(BPF_B, 3),
1889 BPF_ALU32_REG(BPF_DIV, R0, R7),
1890 BPF_EXIT_INSN(),
1891 },
10f18e0b 1892 INTERNAL,
9def624a
AS		 1893 { 10, 20, 30, 40, 50 },
1894 { { 3, 0 }, { 4, 0 } }
1895 },
64a8946b
AS		 1896 {
1897 "check: missing ret",
ece80490 1898 .u.insns = {
64a8946b
AS		 1899 BPF_STMT(BPF_LD | BPF_IMM, 1),
1900 },
10f18e0b 1901 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
64a8946b
AS		 1902 { },
1903 { }
1904 },
9def624a
AS		 1905 {
1906 "check: div_k_0",
ece80490 1907 .u.insns = {
9def624a
AS		 1908 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1909 BPF_STMT(BPF_RET | BPF_K, 0)
1910 },
10f18e0b 1911 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a
AS		 1912 { },
1913 { }
1914 },
1915 {
1916 "check: unknown insn",
ece80490 1917 .u.insns = {
9def624a
AS		 1918 /* seccomp insn, rejected in socket filter */
1919 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1920 BPF_STMT(BPF_RET | BPF_K, 0)
1921 },
10f18e0b 1922 CLASSIC | FLAG_EXPECTED_FAIL,
9def624a
AS		 1923 { },
1924 { }
1925 },
1926 {
1927 "check: out of range spill/fill",
ece80490 1928 .u.insns = {
9def624a
AS		 1929 BPF_STMT(BPF_STX, 16),
1930 BPF_STMT(BPF_RET | BPF_K, 0)
1931 },
10f18e0b 1932 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a
AS		 1933 { },
1934 { }
1935 },
2e8a83c5
DB		 1936 {
1937 "JUMPS + HOLES",
1938 .u.insns = {
1939 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1940 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
1941 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1942 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1943 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1944 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1945 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1946 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1947 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1948 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1949 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1950 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1951 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1952 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1953 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1954 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
1955 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1956 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
1957 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1958 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1959 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1960 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1961 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1962 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1963 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1964 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1965 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1966 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1967 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1968 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1969 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1970 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1971 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1972 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1973 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
1974 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
1975 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1976 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1977 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1978 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1979 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1980 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1981 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1982 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1983 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1984 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1985 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1986 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1987 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1988 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1989 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1990 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1991 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
1992 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
1993 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1994 BPF_STMT(BPF_RET | BPF_A, 0),
1995 BPF_STMT(BPF_RET | BPF_A, 0),
1996 },
1997 CLASSIC,
ce25b68b
DB		 1998 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
1999 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2000 0x08, 0x00,
2001 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2002 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2003 0xc0, 0xa8, 0x33, 0x01,
2004 0xc0, 0xa8, 0x33, 0x02,
2005 0xbb, 0xb6,
2006 0xa9, 0xfa,
2007 0x00, 0x14, 0x00, 0x00,
2008 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2009 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2010 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2011 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2012 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2013 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2014 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2015 0xcc, 0xcc, 0xcc, 0xcc },
2e8a83c5
DB		 2016 { { 88, 0x001b } }
2017 },
2018 {
2019 "check: RET X",
2020 .u.insns = {
2021 BPF_STMT(BPF_RET | BPF_X, 0),
2022 },
2023 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2024 { },
2025 { },
2026 },
2027 {
2028 "check: LDX + RET X",
2029 .u.insns = {
2030 BPF_STMT(BPF_LDX | BPF_IMM, 42),
2031 BPF_STMT(BPF_RET | BPF_X, 0),
2032 },
2033 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2034 { },
2035 { },
2036 },
108cc22a 2037 { /* Mainly checking JIT here. */
9fe13baa 2038 "M[]: alt STX + LDX",
108cc22a
DB		 2039 .u.insns = {
2040 BPF_STMT(BPF_LDX | BPF_IMM, 100),
2041 BPF_STMT(BPF_STX, 0),
2042 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2043 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2044 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2045 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2046 BPF_STMT(BPF_STX, 1),
2047 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2048 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2049 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2050 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2051 BPF_STMT(BPF_STX, 2),
2052 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2053 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2054 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2055 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2056 BPF_STMT(BPF_STX, 3),
2057 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2058 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2059 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2060 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2061 BPF_STMT(BPF_STX, 4),
2062 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2063 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2064 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2065 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2066 BPF_STMT(BPF_STX, 5),
2067 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2068 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2069 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2070 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2071 BPF_STMT(BPF_STX, 6),
2072 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2073 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2074 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2075 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2076 BPF_STMT(BPF_STX, 7),
2077 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2078 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2079 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2080 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2081 BPF_STMT(BPF_STX, 8),
2082 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2083 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2084 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2085 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2086 BPF_STMT(BPF_STX, 9),
2087 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2088 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2089 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2090 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2091 BPF_STMT(BPF_STX, 10),
2092 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2093 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2094 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2095 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2096 BPF_STMT(BPF_STX, 11),
2097 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2098 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2099 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2100 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2101 BPF_STMT(BPF_STX, 12),
2102 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2103 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2104 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2105 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2106 BPF_STMT(BPF_STX, 13),
2107 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2108 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2109 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2110 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2111 BPF_STMT(BPF_STX, 14),
2112 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2113 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2114 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2115 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2116 BPF_STMT(BPF_STX, 15),
2117 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2118 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2119 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2120 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2121 BPF_STMT(BPF_RET | BPF_A, 0),
2122 },
2123 CLASSIC | FLAG_NO_DATA,
2124 { },
2125 { { 0, 116 } },
2126 },
9fe13baa
DB		 2127 { /* Mainly checking JIT here. */
2128 "M[]: full STX + full LDX",
2129 .u.insns = {
2130 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2131 BPF_STMT(BPF_STX, 0),
2132 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2133 BPF_STMT(BPF_STX, 1),
2134 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2135 BPF_STMT(BPF_STX, 2),
2136 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2137 BPF_STMT(BPF_STX, 3),
2138 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2139 BPF_STMT(BPF_STX, 4),
2140 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2141 BPF_STMT(BPF_STX, 5),
2142 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2143 BPF_STMT(BPF_STX, 6),
2144 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2145 BPF_STMT(BPF_STX, 7),
2146 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2147 BPF_STMT(BPF_STX, 8),
2148 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2149 BPF_STMT(BPF_STX, 9),
2150 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2151 BPF_STMT(BPF_STX, 10),
2152 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2153 BPF_STMT(BPF_STX, 11),
2154 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2155 BPF_STMT(BPF_STX, 12),
2156 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2157 BPF_STMT(BPF_STX, 13),
2158 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2159 BPF_STMT(BPF_STX, 14),
2160 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2161 BPF_STMT(BPF_STX, 15),
2162 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2163 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2164 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2165 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2166 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2167 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2168 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2169 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2170 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2171 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2172 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2173 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2174 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2175 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2176 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2177 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2178 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2179 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2180 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2181 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2182 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2183 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2184 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2185 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2186 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2187 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2188 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2189 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2190 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2191 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2192 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2193 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2194 BPF_STMT(BPF_RET | BPF_A, 0),
2195 },
2196 CLASSIC | FLAG_NO_DATA,
2197 { },
2198 { { 0, 0x2a5a5e5 } },
2199 },
d50bc157
DB		 2200 {
2201 "check: SKF_AD_MAX",
2202 .u.insns = {
2203 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2204 SKF_AD_OFF + SKF_AD_MAX),
2205 BPF_STMT(BPF_RET | BPF_A, 0),
2206 },
2207 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2208 { },
2209 { },
2210 },
2211 { /* Passes checker but fails during runtime. */
2212 "LD [SKF_AD_OFF-1]",
2213 .u.insns = {
2214 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2215 SKF_AD_OFF - 1),
2216 BPF_STMT(BPF_RET | BPF_K, 1),
2217 },
2218 CLASSIC,
2219 { },
2220 { { 1, 0 } },
2221 },
02ab695b
AS		 2222 {
2223 "load 64-bit immediate",
2224 .u.insns_int = {
25ee7327 2225 BPF_LD_IMM64(R1, 0x567800001234LL),
02ab695b
AS		 2226 BPF_MOV64_REG(R2, R1),
2227 BPF_MOV64_REG(R3, R2),
2228 BPF_ALU64_IMM(BPF_RSH, R2, 32),
2229 BPF_ALU64_IMM(BPF_LSH, R3, 32),
2230 BPF_ALU64_IMM(BPF_RSH, R3, 32),
2231 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2232 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2233 BPF_EXIT_INSN(),
2234 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2235 BPF_EXIT_INSN(),
986ccfdb
XW		 2236 BPF_LD_IMM64(R0, 0x1ffffffffLL),
2237 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
02ab695b
AS		 2238 BPF_EXIT_INSN(),
2239 },
2240 INTERNAL,
2241 { },
2242 { { 0, 1 } }
2243 },
e21ab36a
AS		 2244 {
2245 "nmap reduced",
2246 .u.insns_int = {
2247 BPF_MOV64_REG(R6, R1),
2248 BPF_LD_ABS(BPF_H, 12),
2249 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
2250 BPF_LD_ABS(BPF_H, 12),
2251 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
2252 BPF_MOV32_IMM(R0, 18),
2253 BPF_STX_MEM(BPF_W, R10, R0, -64),
2254 BPF_LDX_MEM(BPF_W, R7, R10, -64),
2255 BPF_LD_IND(BPF_W, R7, 14),
2256 BPF_STX_MEM(BPF_W, R10, R0, -60),
2257 BPF_MOV32_IMM(R0, 280971478),
2258 BPF_STX_MEM(BPF_W, R10, R0, -56),
2259 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2260 BPF_LDX_MEM(BPF_W, R0, R10, -60),
2261 BPF_ALU32_REG(BPF_SUB, R0, R7),
2262 BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
2263 BPF_LD_ABS(BPF_H, 12),
2264 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
2265 BPF_MOV32_IMM(R0, 22),
2266 BPF_STX_MEM(BPF_W, R10, R0, -56),
2267 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2268 BPF_LD_IND(BPF_H, R7, 14),
2269 BPF_STX_MEM(BPF_W, R10, R0, -52),
2270 BPF_MOV32_IMM(R0, 17366),
2271 BPF_STX_MEM(BPF_W, R10, R0, -48),
2272 BPF_LDX_MEM(BPF_W, R7, R10, -48),
2273 BPF_LDX_MEM(BPF_W, R0, R10, -52),
2274 BPF_ALU32_REG(BPF_SUB, R0, R7),
2275 BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
2276 BPF_MOV32_IMM(R0, 256),
2277 BPF_EXIT_INSN(),
2278 BPF_MOV32_IMM(R0, 0),
2279 BPF_EXIT_INSN(),
2280 },
2281 INTERNAL,
2282 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
2283 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2284 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
2285 { { 38, 256 } }
2286 },
cffc642d
MH		 2287 /* BPF_ALU | BPF_MOV | BPF_X */
2288 {
2289 "ALU_MOV_X: dst = 2",
2290 .u.insns_int = {
2291 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2292 BPF_ALU32_REG(BPF_MOV, R0, R1),
2293 BPF_EXIT_INSN(),
2294 },
2295 INTERNAL,
2296 { },
2297 { { 0, 2 } },
2298 },
2299 {
2300 "ALU_MOV_X: dst = 4294967295",
2301 .u.insns_int = {
56cbaa45 2302 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 2303 BPF_ALU32_REG(BPF_MOV, R0, R1),
2304 BPF_EXIT_INSN(),
2305 },
2306 INTERNAL,
2307 { },
56cbaa45 2308 { { 0, 4294967295U } },
cffc642d
MH		 2309 },
2310 {
2311 "ALU64_MOV_X: dst = 2",
2312 .u.insns_int = {
2313 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2314 BPF_ALU64_REG(BPF_MOV, R0, R1),
2315 BPF_EXIT_INSN(),
2316 },
2317 INTERNAL,
2318 { },
2319 { { 0, 2 } },
2320 },
2321 {
2322 "ALU64_MOV_X: dst = 4294967295",
2323 .u.insns_int = {
56cbaa45 2324 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 2325 BPF_ALU64_REG(BPF_MOV, R0, R1),
2326 BPF_EXIT_INSN(),
2327 },
2328 INTERNAL,
2329 { },
56cbaa45 2330 { { 0, 4294967295U } },
cffc642d
MH		 2331 },
2332 /* BPF_ALU | BPF_MOV | BPF_K */
2333 {
2334 "ALU_MOV_K: dst = 2",
2335 .u.insns_int = {
2336 BPF_ALU32_IMM(BPF_MOV, R0, 2),
2337 BPF_EXIT_INSN(),
2338 },
2339 INTERNAL,
2340 { },
2341 { { 0, 2 } },
2342 },
2343 {
2344 "ALU_MOV_K: dst = 4294967295",
2345 .u.insns_int = {
56cbaa45 2346 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
cffc642d
MH		 2347 BPF_EXIT_INSN(),
2348 },
2349 INTERNAL,
2350 { },
56cbaa45 2351 { { 0, 4294967295U } },
cffc642d
MH		 2352 },
2353 {
2354 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2355 .u.insns_int = {
56cbaa45
MH		 2356 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2357 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
cffc642d
MH		 2358 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2359 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2360 BPF_MOV32_IMM(R0, 2),
2361 BPF_EXIT_INSN(),
2362 BPF_MOV32_IMM(R0, 1),
2363 BPF_EXIT_INSN(),
2364 },
2365 INTERNAL,
2366 { },
2367 { { 0, 0x1 } },
2368 },
2369 {
2370 "ALU64_MOV_K: dst = 2",
2371 .u.insns_int = {
2372 BPF_ALU64_IMM(BPF_MOV, R0, 2),
2373 BPF_EXIT_INSN(),
2374 },
2375 INTERNAL,
2376 { },
2377 { { 0, 2 } },
2378 },
2379 {
2380 "ALU64_MOV_K: dst = 2147483647",
2381 .u.insns_int = {
2382 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2383 BPF_EXIT_INSN(),
2384 },
2385 INTERNAL,
2386 { },
2387 { { 0, 2147483647 } },
2388 },
2389 {
2390 "ALU64_OR_K: dst = 0x0",
2391 .u.insns_int = {
56cbaa45 2392 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
cffc642d
MH		 2393 BPF_LD_IMM64(R3, 0x0),
2394 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2395 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2396 BPF_MOV32_IMM(R0, 2),
2397 BPF_EXIT_INSN(),
2398 BPF_MOV32_IMM(R0, 1),
2399 BPF_EXIT_INSN(),
2400 },
2401 INTERNAL,
2402 { },
2403 { { 0, 0x1 } },
2404 },
2405 {
2406 "ALU64_MOV_K: dst = -1",
2407 .u.insns_int = {
56cbaa45
MH		 2408 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2409 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 2410 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2411 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2412 BPF_MOV32_IMM(R0, 2),
2413 BPF_EXIT_INSN(),
2414 BPF_MOV32_IMM(R0, 1),
2415 BPF_EXIT_INSN(),
2416 },
2417 INTERNAL,
2418 { },
2419 { { 0, 0x1 } },
2420 },
2421 /* BPF_ALU | BPF_ADD | BPF_X */
2422 {
2423 "ALU_ADD_X: 1 + 2 = 3",
2424 .u.insns_int = {
2425 BPF_LD_IMM64(R0, 1),
2426 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2427 BPF_ALU32_REG(BPF_ADD, R0, R1),
2428 BPF_EXIT_INSN(),
2429 },
2430 INTERNAL,
2431 { },
2432 { { 0, 3 } },
2433 },
2434 {
2435 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2436 .u.insns_int = {
2437 BPF_LD_IMM64(R0, 1),
56cbaa45 2438 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2439 BPF_ALU32_REG(BPF_ADD, R0, R1),
2440 BPF_EXIT_INSN(),
2441 },
2442 INTERNAL,
2443 { },
56cbaa45 2444 { { 0, 4294967295U } },
cffc642d
MH		 2445 },
2446 {
2447 "ALU64_ADD_X: 1 + 2 = 3",
2448 .u.insns_int = {
2449 BPF_LD_IMM64(R0, 1),
2450 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2451 BPF_ALU64_REG(BPF_ADD, R0, R1),
2452 BPF_EXIT_INSN(),
2453 },
2454 INTERNAL,
2455 { },
2456 { { 0, 3 } },
2457 },
2458 {
2459 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2460 .u.insns_int = {
2461 BPF_LD_IMM64(R0, 1),
56cbaa45 2462 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2463 BPF_ALU64_REG(BPF_ADD, R0, R1),
2464 BPF_EXIT_INSN(),
2465 },
2466 INTERNAL,
2467 { },
56cbaa45 2468 { { 0, 4294967295U } },
cffc642d
MH		 2469 },
2470 /* BPF_ALU | BPF_ADD | BPF_K */
2471 {
2472 "ALU_ADD_K: 1 + 2 = 3",
2473 .u.insns_int = {
2474 BPF_LD_IMM64(R0, 1),
2475 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2476 BPF_EXIT_INSN(),
2477 },
2478 INTERNAL,
2479 { },
2480 { { 0, 3 } },
2481 },
2482 {
2483 "ALU_ADD_K: 3 + 0 = 3",
2484 .u.insns_int = {
2485 BPF_LD_IMM64(R0, 3),
2486 BPF_ALU32_IMM(BPF_ADD, R0, 0),
2487 BPF_EXIT_INSN(),
2488 },
2489 INTERNAL,
2490 { },
2491 { { 0, 3 } },
2492 },
2493 {
2494 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2495 .u.insns_int = {
2496 BPF_LD_IMM64(R0, 1),
56cbaa45 2497 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
cffc642d
MH		 2498 BPF_EXIT_INSN(),
2499 },
2500 INTERNAL,
2501 { },
56cbaa45 2502 { { 0, 4294967295U } },
cffc642d
MH		 2503 },
2504 {
2505 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2506 .u.insns_int = {
2507 BPF_LD_IMM64(R2, 0x0),
2508 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2509 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2510 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2511 BPF_MOV32_IMM(R0, 2),
2512 BPF_EXIT_INSN(),
2513 BPF_MOV32_IMM(R0, 1),
2514 BPF_EXIT_INSN(),
2515 },
2516 INTERNAL,
2517 { },
2518 { { 0, 0x1 } },
2519 },
2520 {
2521 "ALU64_ADD_K: 1 + 2 = 3",
2522 .u.insns_int = {
2523 BPF_LD_IMM64(R0, 1),
2524 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2525 BPF_EXIT_INSN(),
2526 },
2527 INTERNAL,
2528 { },
2529 { { 0, 3 } },
2530 },
2531 {
2532 "ALU64_ADD_K: 3 + 0 = 3",
2533 .u.insns_int = {
2534 BPF_LD_IMM64(R0, 3),
2535 BPF_ALU64_IMM(BPF_ADD, R0, 0),
2536 BPF_EXIT_INSN(),
2537 },
2538 INTERNAL,
2539 { },
2540 { { 0, 3 } },
2541 },
2542 {
2543 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2544 .u.insns_int = {
2545 BPF_LD_IMM64(R0, 1),
2546 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2547 BPF_EXIT_INSN(),
2548 },
2549 INTERNAL,
2550 { },
2551 { { 0, 2147483647 } },
2552 },
2553 {
2554 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2555 .u.insns_int = {
2556 BPF_LD_IMM64(R0, 2147483646),
2557 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2558 BPF_EXIT_INSN(),
2559 },
2560 INTERNAL,
2561 { },
2562 { { 0, -1 } },
2563 },
2564 {
2565 "ALU64_ADD_K: 1 + 0 = 1",
2566 .u.insns_int = {
2567 BPF_LD_IMM64(R2, 0x1),
2568 BPF_LD_IMM64(R3, 0x1),
2569 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2570 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2571 BPF_MOV32_IMM(R0, 2),
2572 BPF_EXIT_INSN(),
2573 BPF_MOV32_IMM(R0, 1),
2574 BPF_EXIT_INSN(),
2575 },
2576 INTERNAL,
2577 { },
2578 { { 0, 0x1 } },
2579 },
2580 {
2581 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2582 .u.insns_int = {
2583 BPF_LD_IMM64(R2, 0x0),
56cbaa45 2584 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 2585 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2586 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2587 BPF_MOV32_IMM(R0, 2),
2588 BPF_EXIT_INSN(),
2589 BPF_MOV32_IMM(R0, 1),
2590 BPF_EXIT_INSN(),
2591 },
2592 INTERNAL,
2593 { },
2594 { { 0, 0x1 } },
2595 },
2596 /* BPF_ALU | BPF_SUB | BPF_X */
2597 {
2598 "ALU_SUB_X: 3 - 1 = 2",
2599 .u.insns_int = {
2600 BPF_LD_IMM64(R0, 3),
2601 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2602 BPF_ALU32_REG(BPF_SUB, R0, R1),
2603 BPF_EXIT_INSN(),
2604 },
2605 INTERNAL,
2606 { },
2607 { { 0, 2 } },
2608 },
2609 {
2610 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2611 .u.insns_int = {
56cbaa45
MH		 2612 BPF_LD_IMM64(R0, 4294967295U),
2613 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2614 BPF_ALU32_REG(BPF_SUB, R0, R1),
2615 BPF_EXIT_INSN(),
2616 },
2617 INTERNAL,
2618 { },
2619 { { 0, 1 } },
2620 },
2621 {
2622 "ALU64_SUB_X: 3 - 1 = 2",
2623 .u.insns_int = {
2624 BPF_LD_IMM64(R0, 3),
2625 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2626 BPF_ALU64_REG(BPF_SUB, R0, R1),
2627 BPF_EXIT_INSN(),
2628 },
2629 INTERNAL,
2630 { },
2631 { { 0, 2 } },
2632 },
2633 {
2634 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2635 .u.insns_int = {
56cbaa45
MH		 2636 BPF_LD_IMM64(R0, 4294967295U),
2637 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
cffc642d
MH		 2638 BPF_ALU64_REG(BPF_SUB, R0, R1),
2639 BPF_EXIT_INSN(),
2640 },
2641 INTERNAL,
2642 { },
2643 { { 0, 1 } },
2644 },
2645 /* BPF_ALU | BPF_SUB | BPF_K */
2646 {
2647 "ALU_SUB_K: 3 - 1 = 2",
2648 .u.insns_int = {
2649 BPF_LD_IMM64(R0, 3),
2650 BPF_ALU32_IMM(BPF_SUB, R0, 1),
2651 BPF_EXIT_INSN(),
2652 },
2653 INTERNAL,
2654 { },
2655 { { 0, 2 } },
2656 },
2657 {
2658 "ALU_SUB_K: 3 - 0 = 3",
2659 .u.insns_int = {
2660 BPF_LD_IMM64(R0, 3),
2661 BPF_ALU32_IMM(BPF_SUB, R0, 0),
2662 BPF_EXIT_INSN(),
2663 },
2664 INTERNAL,
2665 { },
2666 { { 0, 3 } },
2667 },
2668 {
2669 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
2670 .u.insns_int = {
56cbaa45
MH		 2671 BPF_LD_IMM64(R0, 4294967295U),
2672 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
cffc642d
MH		 2673 BPF_EXIT_INSN(),
2674 },
2675 INTERNAL,
2676 { },
2677 { { 0, 1 } },
2678 },
2679 {
2680 "ALU64_SUB_K: 3 - 1 = 2",
2681 .u.insns_int = {
2682 BPF_LD_IMM64(R0, 3),
2683 BPF_ALU64_IMM(BPF_SUB, R0, 1),
2684 BPF_EXIT_INSN(),
2685 },
2686 INTERNAL,
2687 { },
2688 { { 0, 2 } },
2689 },
2690 {
2691 "ALU64_SUB_K: 3 - 0 = 3",
2692 .u.insns_int = {
2693 BPF_LD_IMM64(R0, 3),
2694 BPF_ALU64_IMM(BPF_SUB, R0, 0),
2695 BPF_EXIT_INSN(),
2696 },
2697 INTERNAL,
2698 { },
2699 { { 0, 3 } },
2700 },
2701 {
2702 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
2703 .u.insns_int = {
56cbaa45
MH		 2704 BPF_LD_IMM64(R0, 4294967294U),
2705 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
cffc642d
MH		 2706 BPF_EXIT_INSN(),
2707 },
2708 INTERNAL,
2709 { },
2710 { { 0, -1 } },
2711 },
2712 {
2713 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
2714 .u.insns_int = {
2715 BPF_LD_IMM64(R0, 2147483646),
2716 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
2717 BPF_EXIT_INSN(),
2718 },
2719 INTERNAL,
2720 { },
2721 { { 0, -1 } },
2722 },
2723 /* BPF_ALU | BPF_MUL | BPF_X */
2724 {
2725 "ALU_MUL_X: 2 * 3 = 6",
2726 .u.insns_int = {
2727 BPF_LD_IMM64(R0, 2),
2728 BPF_ALU32_IMM(BPF_MOV, R1, 3),
2729 BPF_ALU32_REG(BPF_MUL, R0, R1),
2730 BPF_EXIT_INSN(),
2731 },
2732 INTERNAL,
2733 { },
2734 { { 0, 6 } },
2735 },
2736 {
2737 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2738 .u.insns_int = {
2739 BPF_LD_IMM64(R0, 2),
2740 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
2741 BPF_ALU32_REG(BPF_MUL, R0, R1),
2742 BPF_EXIT_INSN(),
2743 },
2744 INTERNAL,
2745 { },
2746 { { 0, 0xFFFFFFF0 } },
2747 },
2748 {
2749 "ALU_MUL_X: -1 * -1 = 1",
2750 .u.insns_int = {
2751 BPF_LD_IMM64(R0, -1),
2752 BPF_ALU32_IMM(BPF_MOV, R1, -1),
2753 BPF_ALU32_REG(BPF_MUL, R0, R1),
2754 BPF_EXIT_INSN(),
2755 },
2756 INTERNAL,
2757 { },
2758 { { 0, 1 } },
2759 },
2760 {
2761 "ALU64_MUL_X: 2 * 3 = 6",
2762 .u.insns_int = {
2763 BPF_LD_IMM64(R0, 2),
2764 BPF_ALU32_IMM(BPF_MOV, R1, 3),
2765 BPF_ALU64_REG(BPF_MUL, R0, R1),
2766 BPF_EXIT_INSN(),
2767 },
2768 INTERNAL,
2769 { },
2770 { { 0, 6 } },
2771 },
2772 {
2773 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
2774 .u.insns_int = {
2775 BPF_LD_IMM64(R0, 1),
2776 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
2777 BPF_ALU64_REG(BPF_MUL, R0, R1),
2778 BPF_EXIT_INSN(),
2779 },
2780 INTERNAL,
2781 { },
2782 { { 0, 2147483647 } },
2783 },
2784 /* BPF_ALU | BPF_MUL | BPF_K */
2785 {
2786 "ALU_MUL_K: 2 * 3 = 6",
2787 .u.insns_int = {
2788 BPF_LD_IMM64(R0, 2),
2789 BPF_ALU32_IMM(BPF_MUL, R0, 3),
2790 BPF_EXIT_INSN(),
2791 },
2792 INTERNAL,
2793 { },
2794 { { 0, 6 } },
2795 },
2796 {
2797 "ALU_MUL_K: 3 * 1 = 3",
2798 .u.insns_int = {
2799 BPF_LD_IMM64(R0, 3),
2800 BPF_ALU32_IMM(BPF_MUL, R0, 1),
2801 BPF_EXIT_INSN(),
2802 },
2803 INTERNAL,
2804 { },
2805 { { 0, 3 } },
2806 },
2807 {
2808 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2809 .u.insns_int = {
2810 BPF_LD_IMM64(R0, 2),
2811 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
2812 BPF_EXIT_INSN(),
2813 },
2814 INTERNAL,
2815 { },
2816 { { 0, 0xFFFFFFF0 } },
2817 },
2818 {
2819 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
2820 .u.insns_int = {
2821 BPF_LD_IMM64(R2, 0x1),
2822 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2823 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
2824 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2825 BPF_MOV32_IMM(R0, 2),
2826 BPF_EXIT_INSN(),
2827 BPF_MOV32_IMM(R0, 1),
2828 BPF_EXIT_INSN(),
2829 },
2830 INTERNAL,
2831 { },
2832 { { 0, 0x1 } },
2833 },
2834 {
2835 "ALU64_MUL_K: 2 * 3 = 6",
2836 .u.insns_int = {
2837 BPF_LD_IMM64(R0, 2),
2838 BPF_ALU64_IMM(BPF_MUL, R0, 3),
2839 BPF_EXIT_INSN(),
2840 },
2841 INTERNAL,
2842 { },
2843 { { 0, 6 } },
2844 },
2845 {
2846 "ALU64_MUL_K: 3 * 1 = 3",
2847 .u.insns_int = {
2848 BPF_LD_IMM64(R0, 3),
2849 BPF_ALU64_IMM(BPF_MUL, R0, 1),
2850 BPF_EXIT_INSN(),
2851 },
2852 INTERNAL,
2853 { },
2854 { { 0, 3 } },
2855 },
2856 {
2857 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
2858 .u.insns_int = {
2859 BPF_LD_IMM64(R0, 1),
2860 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
2861 BPF_EXIT_INSN(),
2862 },
2863 INTERNAL,
2864 { },
2865 { { 0, 2147483647 } },
2866 },
2867 {
2868 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
2869 .u.insns_int = {
2870 BPF_LD_IMM64(R0, 1),
2871 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
2872 BPF_EXIT_INSN(),
2873 },
2874 INTERNAL,
2875 { },
2876 { { 0, -2147483647 } },
2877 },
2878 {
2879 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
2880 .u.insns_int = {
2881 BPF_LD_IMM64(R2, 0x1),
56cbaa45 2882 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 2883 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
2884 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2885 BPF_MOV32_IMM(R0, 2),
2886 BPF_EXIT_INSN(),
2887 BPF_MOV32_IMM(R0, 1),
2888 BPF_EXIT_INSN(),
2889 },
2890 INTERNAL,
2891 { },
2892 { { 0, 0x1 } },
2893 },
2894 /* BPF_ALU | BPF_DIV | BPF_X */
2895 {
2896 "ALU_DIV_X: 6 / 2 = 3",
2897 .u.insns_int = {
2898 BPF_LD_IMM64(R0, 6),
2899 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2900 BPF_ALU32_REG(BPF_DIV, R0, R1),
2901 BPF_EXIT_INSN(),
2902 },
2903 INTERNAL,
2904 { },
2905 { { 0, 3 } },
2906 },
2907 {
2908 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
2909 .u.insns_int = {
56cbaa45
MH		 2910 BPF_LD_IMM64(R0, 4294967295U),
2911 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
cffc642d
MH		 2912 BPF_ALU32_REG(BPF_DIV, R0, R1),
2913 BPF_EXIT_INSN(),
2914 },
2915 INTERNAL,
2916 { },
2917 { { 0, 1 } },
2918 },
2919 {
2920 "ALU64_DIV_X: 6 / 2 = 3",
2921 .u.insns_int = {
2922 BPF_LD_IMM64(R0, 6),
2923 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2924 BPF_ALU64_REG(BPF_DIV, R0, R1),
2925 BPF_EXIT_INSN(),
2926 },
2927 INTERNAL,
2928 { },
2929 { { 0, 3 } },
2930 },
2931 {
2932 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
2933 .u.insns_int = {
2934 BPF_LD_IMM64(R0, 2147483647),
2935 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
2936 BPF_ALU64_REG(BPF_DIV, R0, R1),
2937 BPF_EXIT_INSN(),
2938 },
2939 INTERNAL,
2940 { },
2941 { { 0, 1 } },
2942 },
2943 {
2944 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
2945 .u.insns_int = {
56cbaa45
MH		 2946 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
2947 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
2948 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 2949 BPF_ALU64_REG(BPF_DIV, R2, R4),
2950 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2951 BPF_MOV32_IMM(R0, 2),
2952 BPF_EXIT_INSN(),
2953 BPF_MOV32_IMM(R0, 1),
2954 BPF_EXIT_INSN(),
2955 },
2956 INTERNAL,
2957 { },
2958 { { 0, 0x1 } },
2959 },
2960 /* BPF_ALU | BPF_DIV | BPF_K */
2961 {
2962 "ALU_DIV_K: 6 / 2 = 3",
2963 .u.insns_int = {
2964 BPF_LD_IMM64(R0, 6),
2965 BPF_ALU32_IMM(BPF_DIV, R0, 2),
2966 BPF_EXIT_INSN(),
2967 },
2968 INTERNAL,
2969 { },
2970 { { 0, 3 } },
2971 },
2972 {
2973 "ALU_DIV_K: 3 / 1 = 3",
2974 .u.insns_int = {
2975 BPF_LD_IMM64(R0, 3),
2976 BPF_ALU32_IMM(BPF_DIV, R0, 1),
2977 BPF_EXIT_INSN(),
2978 },
2979 INTERNAL,
2980 { },
2981 { { 0, 3 } },
2982 },
2983 {
2984 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
2985 .u.insns_int = {
56cbaa45
MH		 2986 BPF_LD_IMM64(R0, 4294967295U),
2987 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
cffc642d
MH		 2988 BPF_EXIT_INSN(),
2989 },
2990 INTERNAL,
2991 { },
2992 { { 0, 1 } },
2993 },
2994 {
2995 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
2996 .u.insns_int = {
56cbaa45 2997 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
cffc642d
MH		 2998 BPF_LD_IMM64(R3, 0x1UL),
2999 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3000 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3001 BPF_MOV32_IMM(R0, 2),
3002 BPF_EXIT_INSN(),
3003 BPF_MOV32_IMM(R0, 1),
3004 BPF_EXIT_INSN(),
3005 },
3006 INTERNAL,
3007 { },
3008 { { 0, 0x1 } },
3009 },
3010 {
3011 "ALU64_DIV_K: 6 / 2 = 3",
3012 .u.insns_int = {
3013 BPF_LD_IMM64(R0, 6),
3014 BPF_ALU64_IMM(BPF_DIV, R0, 2),
3015 BPF_EXIT_INSN(),
3016 },
3017 INTERNAL,
3018 { },
3019 { { 0, 3 } },
3020 },
3021 {
3022 "ALU64_DIV_K: 3 / 1 = 3",
3023 .u.insns_int = {
3024 BPF_LD_IMM64(R0, 3),
3025 BPF_ALU64_IMM(BPF_DIV, R0, 1),
3026 BPF_EXIT_INSN(),
3027 },
3028 INTERNAL,
3029 { },
3030 { { 0, 3 } },
3031 },
3032 {
3033 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3034 .u.insns_int = {
3035 BPF_LD_IMM64(R0, 2147483647),
3036 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3037 BPF_EXIT_INSN(),
3038 },
3039 INTERNAL,
3040 { },
3041 { { 0, 1 } },
3042 },
3043 {
3044 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3045 .u.insns_int = {
56cbaa45
MH		 3046 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3047 BPF_LD_IMM64(R3, 0x0000000000000001LL),
cffc642d
MH		 3048 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3049 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3050 BPF_MOV32_IMM(R0, 2),
3051 BPF_EXIT_INSN(),
3052 BPF_MOV32_IMM(R0, 1),
3053 BPF_EXIT_INSN(),
3054 },
3055 INTERNAL,
3056 { },
3057 { { 0, 0x1 } },
3058 },
3059 /* BPF_ALU | BPF_MOD | BPF_X */
3060 {
3061 "ALU_MOD_X: 3 % 2 = 1",
3062 .u.insns_int = {
3063 BPF_LD_IMM64(R0, 3),
3064 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3065 BPF_ALU32_REG(BPF_MOD, R0, R1),
3066 BPF_EXIT_INSN(),
3067 },
3068 INTERNAL,
3069 { },
3070 { { 0, 1 } },
3071 },
3072 {
3073 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3074 .u.insns_int = {
56cbaa45
MH		 3075 BPF_LD_IMM64(R0, 4294967295U),
3076 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
cffc642d
MH		 3077 BPF_ALU32_REG(BPF_MOD, R0, R1),
3078 BPF_EXIT_INSN(),
3079 },
3080 INTERNAL,
3081 { },
3082 { { 0, 2 } },
3083 },
3084 {
3085 "ALU64_MOD_X: 3 % 2 = 1",
3086 .u.insns_int = {
3087 BPF_LD_IMM64(R0, 3),
3088 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3089 BPF_ALU64_REG(BPF_MOD, R0, R1),
3090 BPF_EXIT_INSN(),
3091 },
3092 INTERNAL,
3093 { },
3094 { { 0, 1 } },
3095 },
3096 {
3097 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3098 .u.insns_int = {
3099 BPF_LD_IMM64(R0, 2147483647),
3100 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3101 BPF_ALU64_REG(BPF_MOD, R0, R1),
3102 BPF_EXIT_INSN(),
3103 },
3104 INTERNAL,
3105 { },
3106 { { 0, 2 } },
3107 },
3108 /* BPF_ALU | BPF_MOD | BPF_K */
3109 {
3110 "ALU_MOD_K: 3 % 2 = 1",
3111 .u.insns_int = {
3112 BPF_LD_IMM64(R0, 3),
3113 BPF_ALU32_IMM(BPF_MOD, R0, 2),
3114 BPF_EXIT_INSN(),
3115 },
3116 INTERNAL,
3117 { },
3118 { { 0, 1 } },
3119 },
3120 {
3121 "ALU_MOD_K: 3 % 1 = 0",
3122 .u.insns_int = {
3123 BPF_LD_IMM64(R0, 3),
3124 BPF_ALU32_IMM(BPF_MOD, R0, 1),
3125 BPF_EXIT_INSN(),
3126 },
3127 INTERNAL,
3128 { },
3129 { { 0, 0 } },
3130 },
3131 {
3132 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3133 .u.insns_int = {
56cbaa45
MH		 3134 BPF_LD_IMM64(R0, 4294967295U),
3135 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
cffc642d
MH		 3136 BPF_EXIT_INSN(),
3137 },
3138 INTERNAL,
3139 { },
3140 { { 0, 2 } },
3141 },
3142 {
3143 "ALU64_MOD_K: 3 % 2 = 1",
3144 .u.insns_int = {
3145 BPF_LD_IMM64(R0, 3),
3146 BPF_ALU64_IMM(BPF_MOD, R0, 2),
3147 BPF_EXIT_INSN(),
3148 },
3149 INTERNAL,
3150 { },
3151 { { 0, 1 } },
3152 },
3153 {
3154 "ALU64_MOD_K: 3 % 1 = 0",
3155 .u.insns_int = {
3156 BPF_LD_IMM64(R0, 3),
3157 BPF_ALU64_IMM(BPF_MOD, R0, 1),
3158 BPF_EXIT_INSN(),
3159 },
3160 INTERNAL,
3161 { },
3162 { { 0, 0 } },
3163 },
3164 {
3165 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3166 .u.insns_int = {
3167 BPF_LD_IMM64(R0, 2147483647),
3168 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3169 BPF_EXIT_INSN(),
3170 },
3171 INTERNAL,
3172 { },
3173 { { 0, 2 } },
3174 },
3175 /* BPF_ALU | BPF_AND | BPF_X */
3176 {
3177 "ALU_AND_X: 3 & 2 = 2",
3178 .u.insns_int = {
3179 BPF_LD_IMM64(R0, 3),
3180 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3181 BPF_ALU32_REG(BPF_AND, R0, R1),
3182 BPF_EXIT_INSN(),
3183 },
3184 INTERNAL,
3185 { },
3186 { { 0, 2 } },
3187 },
3188 {
3189 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3190 .u.insns_int = {
3191 BPF_LD_IMM64(R0, 0xffffffff),
3192 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3193 BPF_ALU32_REG(BPF_AND, R0, R1),
3194 BPF_EXIT_INSN(),
3195 },
3196 INTERNAL,
3197 { },
3198 { { 0, 0xffffffff } },
3199 },
3200 {
3201 "ALU64_AND_X: 3 & 2 = 2",
3202 .u.insns_int = {
3203 BPF_LD_IMM64(R0, 3),
3204 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3205 BPF_ALU64_REG(BPF_AND, R0, R1),
3206 BPF_EXIT_INSN(),
3207 },
3208 INTERNAL,
3209 { },
3210 { { 0, 2 } },
3211 },
3212 {
3213 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3214 .u.insns_int = {
3215 BPF_LD_IMM64(R0, 0xffffffff),
3216 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3217 BPF_ALU64_REG(BPF_AND, R0, R1),
3218 BPF_EXIT_INSN(),
3219 },
3220 INTERNAL,
3221 { },
3222 { { 0, 0xffffffff } },
3223 },
3224 /* BPF_ALU | BPF_AND | BPF_K */
3225 {
3226 "ALU_AND_K: 3 & 2 = 2",
3227 .u.insns_int = {
3228 BPF_LD_IMM64(R0, 3),
3229 BPF_ALU32_IMM(BPF_AND, R0, 2),
3230 BPF_EXIT_INSN(),
3231 },
3232 INTERNAL,
3233 { },
3234 { { 0, 2 } },
3235 },
3236 {
3237 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3238 .u.insns_int = {
3239 BPF_LD_IMM64(R0, 0xffffffff),
3240 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3241 BPF_EXIT_INSN(),
3242 },
3243 INTERNAL,
3244 { },
3245 { { 0, 0xffffffff } },
3246 },
3247 {
3248 "ALU64_AND_K: 3 & 2 = 2",
3249 .u.insns_int = {
3250 BPF_LD_IMM64(R0, 3),
3251 BPF_ALU64_IMM(BPF_AND, R0, 2),
3252 BPF_EXIT_INSN(),
3253 },
3254 INTERNAL,
3255 { },
3256 { { 0, 2 } },
3257 },
3258 {
3259 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3260 .u.insns_int = {
3261 BPF_LD_IMM64(R0, 0xffffffff),
3262 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3263 BPF_EXIT_INSN(),
3264 },
3265 INTERNAL,
3266 { },
3267 { { 0, 0xffffffff } },
3268 },
3269 {
3270 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3271 .u.insns_int = {
56cbaa45
MH		 3272 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3273 BPF_LD_IMM64(R3, 0x0000000000000000LL),
cffc642d
MH		 3274 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3275 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3276 BPF_MOV32_IMM(R0, 2),
3277 BPF_EXIT_INSN(),
3278 BPF_MOV32_IMM(R0, 1),
3279 BPF_EXIT_INSN(),
3280 },
3281 INTERNAL,
3282 { },
3283 { { 0, 0x1 } },
3284 },
3285 {
3286 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3287 .u.insns_int = {
56cbaa45
MH		 3288 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3289 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3290 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3291 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3292 BPF_MOV32_IMM(R0, 2),
3293 BPF_EXIT_INSN(),
3294 BPF_MOV32_IMM(R0, 1),
3295 BPF_EXIT_INSN(),
3296 },
3297 INTERNAL,
3298 { },
3299 { { 0, 0x1 } },
3300 },
3301 {
3302 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3303 .u.insns_int = {
56cbaa45
MH		 3304 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3305 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3306 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3307 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3308 BPF_MOV32_IMM(R0, 2),
3309 BPF_EXIT_INSN(),
3310 BPF_MOV32_IMM(R0, 1),
3311 BPF_EXIT_INSN(),
3312 },
3313 INTERNAL,
3314 { },
3315 { { 0, 0x1 } },
3316 },
3317 /* BPF_ALU | BPF_OR | BPF_X */
3318 {
3319 "ALU_OR_X: 1 | 2 = 3",
3320 .u.insns_int = {
3321 BPF_LD_IMM64(R0, 1),
3322 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3323 BPF_ALU32_REG(BPF_OR, R0, R1),
3324 BPF_EXIT_INSN(),
3325 },
3326 INTERNAL,
3327 { },
3328 { { 0, 3 } },
3329 },
3330 {
3331 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3332 .u.insns_int = {
3333 BPF_LD_IMM64(R0, 0),
3334 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3335 BPF_ALU32_REG(BPF_OR, R0, R1),
3336 BPF_EXIT_INSN(),
3337 },
3338 INTERNAL,
3339 { },
3340 { { 0, 0xffffffff } },
3341 },
3342 {
3343 "ALU64_OR_X: 1 | 2 = 3",
3344 .u.insns_int = {
3345 BPF_LD_IMM64(R0, 1),
3346 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3347 BPF_ALU64_REG(BPF_OR, R0, R1),
3348 BPF_EXIT_INSN(),
3349 },
3350 INTERNAL,
3351 { },
3352 { { 0, 3 } },
3353 },
3354 {
3355 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3356 .u.insns_int = {
3357 BPF_LD_IMM64(R0, 0),
3358 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3359 BPF_ALU64_REG(BPF_OR, R0, R1),
3360 BPF_EXIT_INSN(),
3361 },
3362 INTERNAL,
3363 { },
3364 { { 0, 0xffffffff } },
3365 },
3366 /* BPF_ALU | BPF_OR | BPF_K */
3367 {
3368 "ALU_OR_K: 1 | 2 = 3",
3369 .u.insns_int = {
3370 BPF_LD_IMM64(R0, 1),
3371 BPF_ALU32_IMM(BPF_OR, R0, 2),
3372 BPF_EXIT_INSN(),
3373 },
3374 INTERNAL,
3375 { },
3376 { { 0, 3 } },
3377 },
3378 {
3379 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3380 .u.insns_int = {
3381 BPF_LD_IMM64(R0, 0),
3382 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3383 BPF_EXIT_INSN(),
3384 },
3385 INTERNAL,
3386 { },
3387 { { 0, 0xffffffff } },
3388 },
3389 {
3390 "ALU64_OR_K: 1 | 2 = 3",
3391 .u.insns_int = {
3392 BPF_LD_IMM64(R0, 1),
3393 BPF_ALU64_IMM(BPF_OR, R0, 2),
3394 BPF_EXIT_INSN(),
3395 },
3396 INTERNAL,
3397 { },
3398 { { 0, 3 } },
3399 },
3400 {
3401 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3402 .u.insns_int = {
3403 BPF_LD_IMM64(R0, 0),
3404 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3405 BPF_EXIT_INSN(),
3406 },
3407 INTERNAL,
3408 { },
3409 { { 0, 0xffffffff } },
3410 },
3411 {
3412 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3413 .u.insns_int = {
56cbaa45
MH		 3414 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3415 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3416 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3417 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3418 BPF_MOV32_IMM(R0, 2),
3419 BPF_EXIT_INSN(),
3420 BPF_MOV32_IMM(R0, 1),
3421 BPF_EXIT_INSN(),
3422 },
3423 INTERNAL,
3424 { },
3425 { { 0, 0x1 } },
3426 },
3427 {
3428 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3429 .u.insns_int = {
56cbaa45
MH		 3430 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3431 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3432 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3433 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3434 BPF_MOV32_IMM(R0, 2),
3435 BPF_EXIT_INSN(),
3436 BPF_MOV32_IMM(R0, 1),
3437 BPF_EXIT_INSN(),
3438 },
3439 INTERNAL,
3440 { },
3441 { { 0, 0x1 } },
3442 },
3443 {
3444 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3445 .u.insns_int = {
56cbaa45
MH		 3446 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3447 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3448 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3449 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3450 BPF_MOV32_IMM(R0, 2),
3451 BPF_EXIT_INSN(),
3452 BPF_MOV32_IMM(R0, 1),
3453 BPF_EXIT_INSN(),
3454 },
3455 INTERNAL,
3456 { },
3457 { { 0, 0x1 } },
3458 },
3459 /* BPF_ALU | BPF_XOR | BPF_X */
3460 {
3461 "ALU_XOR_X: 5 ^ 6 = 3",
3462 .u.insns_int = {
3463 BPF_LD_IMM64(R0, 5),
3464 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3465 BPF_ALU32_REG(BPF_XOR, R0, R1),
3466 BPF_EXIT_INSN(),
3467 },
3468 INTERNAL,
3469 { },
3470 { { 0, 3 } },
3471 },
3472 {
3473 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3474 .u.insns_int = {
3475 BPF_LD_IMM64(R0, 1),
3476 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3477 BPF_ALU32_REG(BPF_XOR, R0, R1),
3478 BPF_EXIT_INSN(),
3479 },
3480 INTERNAL,
3481 { },
3482 { { 0, 0xfffffffe } },
3483 },
3484 {
3485 "ALU64_XOR_X: 5 ^ 6 = 3",
3486 .u.insns_int = {
3487 BPF_LD_IMM64(R0, 5),
3488 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3489 BPF_ALU64_REG(BPF_XOR, R0, R1),
3490 BPF_EXIT_INSN(),
3491 },
3492 INTERNAL,
3493 { },
3494 { { 0, 3 } },
3495 },
3496 {
3497 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3498 .u.insns_int = {
3499 BPF_LD_IMM64(R0, 1),
3500 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3501 BPF_ALU64_REG(BPF_XOR, R0, R1),
3502 BPF_EXIT_INSN(),
3503 },
3504 INTERNAL,
3505 { },
3506 { { 0, 0xfffffffe } },
3507 },
3508 /* BPF_ALU | BPF_XOR | BPF_K */
3509 {
3510 "ALU_XOR_K: 5 ^ 6 = 3",
3511 .u.insns_int = {
3512 BPF_LD_IMM64(R0, 5),
3513 BPF_ALU32_IMM(BPF_XOR, R0, 6),
3514 BPF_EXIT_INSN(),
3515 },
3516 INTERNAL,
3517 { },
3518 { { 0, 3 } },
3519 },
3520 {
3521 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3522 .u.insns_int = {
3523 BPF_LD_IMM64(R0, 1),
3524 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3525 BPF_EXIT_INSN(),
3526 },
3527 INTERNAL,
3528 { },
3529 { { 0, 0xfffffffe } },
3530 },
3531 {
3532 "ALU64_XOR_K: 5 ^ 6 = 3",
3533 .u.insns_int = {
3534 BPF_LD_IMM64(R0, 5),
3535 BPF_ALU64_IMM(BPF_XOR, R0, 6),
3536 BPF_EXIT_INSN(),
3537 },
3538 INTERNAL,
3539 { },
3540 { { 0, 3 } },
3541 },
3542 {
3543 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3544 .u.insns_int = {
3545 BPF_LD_IMM64(R0, 1),
3546 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3547 BPF_EXIT_INSN(),
3548 },
3549 INTERNAL,
3550 { },
3551 { { 0, 0xfffffffe } },
3552 },
3553 {
3554 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3555 .u.insns_int = {
56cbaa45
MH		 3556 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3557 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
cffc642d
MH		 3558 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
3559 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3560 BPF_MOV32_IMM(R0, 2),
3561 BPF_EXIT_INSN(),
3562 BPF_MOV32_IMM(R0, 1),
3563 BPF_EXIT_INSN(),
3564 },
3565 INTERNAL,
3566 { },
3567 { { 0, 0x1 } },
3568 },
3569 {
3570 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3571 .u.insns_int = {
56cbaa45
MH		 3572 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3573 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
cffc642d
MH		 3574 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3575 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3576 BPF_MOV32_IMM(R0, 2),
3577 BPF_EXIT_INSN(),
3578 BPF_MOV32_IMM(R0, 1),
3579 BPF_EXIT_INSN(),
3580 },
3581 INTERNAL,
3582 { },
3583 { { 0, 0x1 } },
3584 },
3585 {
3586 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3587 .u.insns_int = {
56cbaa45
MH		 3588 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3589 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 3590 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3591 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3592 BPF_MOV32_IMM(R0, 2),
3593 BPF_EXIT_INSN(),
3594 BPF_MOV32_IMM(R0, 1),
3595 BPF_EXIT_INSN(),
3596 },
3597 INTERNAL,
3598 { },
3599 { { 0, 0x1 } },
3600 },
3601 /* BPF_ALU | BPF_LSH | BPF_X */
3602 {
3603 "ALU_LSH_X: 1 << 1 = 2",
3604 .u.insns_int = {
3605 BPF_LD_IMM64(R0, 1),
3606 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3607 BPF_ALU32_REG(BPF_LSH, R0, R1),
3608 BPF_EXIT_INSN(),
3609 },
3610 INTERNAL,
3611 { },
3612 { { 0, 2 } },
3613 },
3614 {
3615 "ALU_LSH_X: 1 << 31 = 0x80000000",
3616 .u.insns_int = {
3617 BPF_LD_IMM64(R0, 1),
3618 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3619 BPF_ALU32_REG(BPF_LSH, R0, R1),
3620 BPF_EXIT_INSN(),
3621 },
3622 INTERNAL,
3623 { },
3624 { { 0, 0x80000000 } },
3625 },
3626 {
3627 "ALU64_LSH_X: 1 << 1 = 2",
3628 .u.insns_int = {
3629 BPF_LD_IMM64(R0, 1),
3630 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3631 BPF_ALU64_REG(BPF_LSH, R0, R1),
3632 BPF_EXIT_INSN(),
3633 },
3634 INTERNAL,
3635 { },
3636 { { 0, 2 } },
3637 },
3638 {
3639 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3640 .u.insns_int = {
3641 BPF_LD_IMM64(R0, 1),
3642 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3643 BPF_ALU64_REG(BPF_LSH, R0, R1),
3644 BPF_EXIT_INSN(),
3645 },
3646 INTERNAL,
3647 { },
3648 { { 0, 0x80000000 } },
3649 },
3650 /* BPF_ALU | BPF_LSH | BPF_K */
3651 {
3652 "ALU_LSH_K: 1 << 1 = 2",
3653 .u.insns_int = {
3654 BPF_LD_IMM64(R0, 1),
3655 BPF_ALU32_IMM(BPF_LSH, R0, 1),
3656 BPF_EXIT_INSN(),
3657 },
3658 INTERNAL,
3659 { },
3660 { { 0, 2 } },
3661 },
3662 {
3663 "ALU_LSH_K: 1 << 31 = 0x80000000",
3664 .u.insns_int = {
3665 BPF_LD_IMM64(R0, 1),
3666 BPF_ALU32_IMM(BPF_LSH, R0, 31),
3667 BPF_EXIT_INSN(),
3668 },
3669 INTERNAL,
3670 { },
3671 { { 0, 0x80000000 } },
3672 },
3673 {
3674 "ALU64_LSH_K: 1 << 1 = 2",
3675 .u.insns_int = {
3676 BPF_LD_IMM64(R0, 1),
3677 BPF_ALU64_IMM(BPF_LSH, R0, 1),
3678 BPF_EXIT_INSN(),
3679 },
3680 INTERNAL,
3681 { },
3682 { { 0, 2 } },
3683 },
3684 {
3685 "ALU64_LSH_K: 1 << 31 = 0x80000000",
3686 .u.insns_int = {
3687 BPF_LD_IMM64(R0, 1),
3688 BPF_ALU64_IMM(BPF_LSH, R0, 31),
3689 BPF_EXIT_INSN(),
3690 },
3691 INTERNAL,
3692 { },
3693 { { 0, 0x80000000 } },
3694 },
3695 /* BPF_ALU | BPF_RSH | BPF_X */
3696 {
3697 "ALU_RSH_X: 2 >> 1 = 1",
3698 .u.insns_int = {
3699 BPF_LD_IMM64(R0, 2),
3700 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3701 BPF_ALU32_REG(BPF_RSH, R0, R1),
3702 BPF_EXIT_INSN(),
3703 },
3704 INTERNAL,
3705 { },
3706 { { 0, 1 } },
3707 },
3708 {
3709 "ALU_RSH_X: 0x80000000 >> 31 = 1",
3710 .u.insns_int = {
3711 BPF_LD_IMM64(R0, 0x80000000),
3712 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3713 BPF_ALU32_REG(BPF_RSH, R0, R1),
3714 BPF_EXIT_INSN(),
3715 },
3716 INTERNAL,
3717 { },
3718 { { 0, 1 } },
3719 },
3720 {
3721 "ALU64_RSH_X: 2 >> 1 = 1",
3722 .u.insns_int = {
3723 BPF_LD_IMM64(R0, 2),
3724 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3725 BPF_ALU64_REG(BPF_RSH, R0, R1),
3726 BPF_EXIT_INSN(),
3727 },
3728 INTERNAL,
3729 { },
3730 { { 0, 1 } },
3731 },
3732 {
3733 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
3734 .u.insns_int = {
3735 BPF_LD_IMM64(R0, 0x80000000),
3736 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3737 BPF_ALU64_REG(BPF_RSH, R0, R1),
3738 BPF_EXIT_INSN(),
3739 },
3740 INTERNAL,
3741 { },
3742 { { 0, 1 } },
3743 },
3744 /* BPF_ALU | BPF_RSH | BPF_K */
3745 {
3746 "ALU_RSH_K: 2 >> 1 = 1",
3747 .u.insns_int = {
3748 BPF_LD_IMM64(R0, 2),
3749 BPF_ALU32_IMM(BPF_RSH, R0, 1),
3750 BPF_EXIT_INSN(),
3751 },
3752 INTERNAL,
3753 { },
3754 { { 0, 1 } },
3755 },
3756 {
3757 "ALU_RSH_K: 0x80000000 >> 31 = 1",
3758 .u.insns_int = {
3759 BPF_LD_IMM64(R0, 0x80000000),
3760 BPF_ALU32_IMM(BPF_RSH, R0, 31),
3761 BPF_EXIT_INSN(),
3762 },
3763 INTERNAL,
3764 { },
3765 { { 0, 1 } },
3766 },
3767 {
3768 "ALU64_RSH_K: 2 >> 1 = 1",
3769 .u.insns_int = {
3770 BPF_LD_IMM64(R0, 2),
3771 BPF_ALU64_IMM(BPF_RSH, R0, 1),
3772 BPF_EXIT_INSN(),
3773 },
3774 INTERNAL,
3775 { },
3776 { { 0, 1 } },
3777 },
3778 {
3779 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
3780 .u.insns_int = {
3781 BPF_LD_IMM64(R0, 0x80000000),
3782 BPF_ALU64_IMM(BPF_RSH, R0, 31),
3783 BPF_EXIT_INSN(),
3784 },
3785 INTERNAL,
3786 { },
3787 { { 0, 1 } },
3788 },
3789 /* BPF_ALU | BPF_ARSH | BPF_X */
3790 {
3791 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3792 .u.insns_int = {
3793 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3794 BPF_ALU32_IMM(BPF_MOV, R1, 40),
3795 BPF_ALU64_REG(BPF_ARSH, R0, R1),
3796 BPF_EXIT_INSN(),
3797 },
3798 INTERNAL,
3799 { },
3800 { { 0, 0xffff00ff } },
3801 },
3802 /* BPF_ALU | BPF_ARSH | BPF_K */
3803 {
3804 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3805 .u.insns_int = {
3806 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3807 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
3808 BPF_EXIT_INSN(),
3809 },
3810 INTERNAL,
3811 { },
3812 { { 0, 0xffff00ff } },
3813 },
3814 /* BPF_ALU | BPF_NEG */
3815 {
3816 "ALU_NEG: -(3) = -3",
3817 .u.insns_int = {
3818 BPF_ALU32_IMM(BPF_MOV, R0, 3),
3819 BPF_ALU32_IMM(BPF_NEG, R0, 0),
3820 BPF_EXIT_INSN(),
3821 },
3822 INTERNAL,
3823 { },
3824 { { 0, -3 } },
3825 },
3826 {
3827 "ALU_NEG: -(-3) = 3",
3828 .u.insns_int = {
3829 BPF_ALU32_IMM(BPF_MOV, R0, -3),
3830 BPF_ALU32_IMM(BPF_NEG, R0, 0),
3831 BPF_EXIT_INSN(),
3832 },
3833 INTERNAL,
3834 { },
3835 { { 0, 3 } },
3836 },
3837 {
3838 "ALU64_NEG: -(3) = -3",
3839 .u.insns_int = {
3840 BPF_LD_IMM64(R0, 3),
3841 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3842 BPF_EXIT_INSN(),
3843 },
3844 INTERNAL,
3845 { },
3846 { { 0, -3 } },
3847 },
3848 {
3849 "ALU64_NEG: -(-3) = 3",
3850 .u.insns_int = {
3851 BPF_LD_IMM64(R0, -3),
3852 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3853 BPF_EXIT_INSN(),
3854 },
3855 INTERNAL,
3856 { },
3857 { { 0, 3 } },
3858 },
3859 /* BPF_ALU | BPF_END | BPF_FROM_BE */
3860 {
3861 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
3862 .u.insns_int = {
3863 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3864 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
3865 BPF_EXIT_INSN(),
3866 },
3867 INTERNAL,
3868 { },
3869 { { 0, cpu_to_be16(0xcdef) } },
3870 },
3871 {
3872 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
3873 .u.insns_int = {
3874 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3875 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
ba29becd
XW		 3876 BPF_ALU64_REG(BPF_MOV, R1, R0),
3877 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3878 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 3879 BPF_EXIT_INSN(),
3880 },
3881 INTERNAL,
3882 { },
3883 { { 0, cpu_to_be32(0x89abcdef) } },
3884 },
3885 {
3886 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
3887 .u.insns_int = {
3888 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3889 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
3890 BPF_EXIT_INSN(),
3891 },
3892 INTERNAL,
3893 { },
3894 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
3895 },
3896 /* BPF_ALU | BPF_END | BPF_FROM_LE */
3897 {
3898 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
3899 .u.insns_int = {
3900 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3901 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
3902 BPF_EXIT_INSN(),
3903 },
3904 INTERNAL,
3905 { },
3906 { { 0, cpu_to_le16(0xcdef) } },
3907 },
3908 {
3909 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
3910 .u.insns_int = {
3911 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3912 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
ba29becd
XW		 3913 BPF_ALU64_REG(BPF_MOV, R1, R0),
3914 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3915 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
cffc642d
MH		 3916 BPF_EXIT_INSN(),
3917 },
3918 INTERNAL,
3919 { },
3920 { { 0, cpu_to_le32(0x89abcdef) } },
3921 },
3922 {
3923 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
3924 .u.insns_int = {
3925 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3926 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
3927 BPF_EXIT_INSN(),
3928 },
3929 INTERNAL,
3930 { },
3931 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
3932 },
3933 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
3934 {
3935 "ST_MEM_B: Store/Load byte: max negative",
3936 .u.insns_int = {
3937 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3938 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
3939 BPF_LDX_MEM(BPF_B, R0, R10, -40),
3940 BPF_EXIT_INSN(),
3941 },
3942 INTERNAL,
3943 { },
3944 { { 0, 0xff } },
3945 },
3946 {
3947 "ST_MEM_B: Store/Load byte: max positive",
3948 .u.insns_int = {
3949 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3950 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
3951 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3952 BPF_EXIT_INSN(),
3953 },
3954 INTERNAL,
3955 { },
3956 { { 0, 0x7f } },
3957 },
3958 {
3959 "STX_MEM_B: Store/Load byte: max negative",
3960 .u.insns_int = {
3961 BPF_LD_IMM64(R0, 0),
3962 BPF_LD_IMM64(R1, 0xffLL),
3963 BPF_STX_MEM(BPF_B, R10, R1, -40),
3964 BPF_LDX_MEM(BPF_B, R0, R10, -40),
3965 BPF_EXIT_INSN(),
3966 },
3967 INTERNAL,
3968 { },
3969 { { 0, 0xff } },
3970 },
3971 {
3972 "ST_MEM_H: Store/Load half word: max negative",
3973 .u.insns_int = {
3974 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3975 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
3976 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3977 BPF_EXIT_INSN(),
3978 },
3979 INTERNAL,
3980 { },
3981 { { 0, 0xffff } },
3982 },
3983 {
3984 "ST_MEM_H: Store/Load half word: max positive",
3985 .u.insns_int = {
3986 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3987 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
3988 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3989 BPF_EXIT_INSN(),
3990 },
3991 INTERNAL,
3992 { },
3993 { { 0, 0x7fff } },
3994 },
3995 {
3996 "STX_MEM_H: Store/Load half word: max negative",
3997 .u.insns_int = {
3998 BPF_LD_IMM64(R0, 0),
3999 BPF_LD_IMM64(R1, 0xffffLL),
4000 BPF_STX_MEM(BPF_H, R10, R1, -40),
4001 BPF_LDX_MEM(BPF_H, R0, R10, -40),
4002 BPF_EXIT_INSN(),
4003 },
4004 INTERNAL,
4005 { },
4006 { { 0, 0xffff } },
4007 },
4008 {
4009 "ST_MEM_W: Store/Load word: max negative",
4010 .u.insns_int = {
4011 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4012 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
4013 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4014 BPF_EXIT_INSN(),
4015 },
4016 INTERNAL,
4017 { },
4018 { { 0, 0xffffffff } },
4019 },
4020 {
4021 "ST_MEM_W: Store/Load word: max positive",
4022 .u.insns_int = {
4023 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4024 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
4025 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4026 BPF_EXIT_INSN(),
4027 },
4028 INTERNAL,
4029 { },
4030 { { 0, 0x7fffffff } },
4031 },
4032 {
4033 "STX_MEM_W: Store/Load word: max negative",
4034 .u.insns_int = {
4035 BPF_LD_IMM64(R0, 0),
4036 BPF_LD_IMM64(R1, 0xffffffffLL),
4037 BPF_STX_MEM(BPF_W, R10, R1, -40),
4038 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4039 BPF_EXIT_INSN(),
4040 },
4041 INTERNAL,
4042 { },
4043 { { 0, 0xffffffff } },
4044 },
4045 {
4046 "ST_MEM_DW: Store/Load double word: max negative",
4047 .u.insns_int = {
4048 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4049 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4050 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4051 BPF_EXIT_INSN(),
4052 },
4053 INTERNAL,
4054 { },
4055 { { 0, 0xffffffff } },
4056 },
4057 {
4058 "ST_MEM_DW: Store/Load double word: max negative 2",
4059 .u.insns_int = {
56cbaa45
MH		 4060 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
4061 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
cffc642d
MH		 4062 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
4063 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
4064 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4065 BPF_MOV32_IMM(R0, 2),
4066 BPF_EXIT_INSN(),
4067 BPF_MOV32_IMM(R0, 1),
4068 BPF_EXIT_INSN(),
4069 },
4070 INTERNAL,
4071 { },
4072 { { 0, 0x1 } },
4073 },
4074 {
4075 "ST_MEM_DW: Store/Load double word: max positive",
4076 .u.insns_int = {
4077 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4078 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
4079 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4080 BPF_EXIT_INSN(),
4081 },
4082 INTERNAL,
4083 { },
4084 { { 0, 0x7fffffff } },
4085 },
4086 {
4087 "STX_MEM_DW: Store/Load double word: max negative",
4088 .u.insns_int = {
4089 BPF_LD_IMM64(R0, 0),
4090 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4091 BPF_STX_MEM(BPF_W, R10, R1, -40),
4092 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4093 BPF_EXIT_INSN(),
4094 },
4095 INTERNAL,
4096 { },
4097 { { 0, 0xffffffff } },
4098 },
4099 /* BPF_STX | BPF_XADD | BPF_W/DW */
4100 {
4101 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
4102 .u.insns_int = {
4103 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4104 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
4105 BPF_STX_XADD(BPF_W, R10, R0, -40),
4106 BPF_LDX_MEM(BPF_W, R0, R10, -40),
4107 BPF_EXIT_INSN(),
4108 },
4109 INTERNAL,
4110 { },
4111 { { 0, 0x22 } },
4112 },
4113 {
4114 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
4115 .u.insns_int = {
4116 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
4117 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
4118 BPF_STX_XADD(BPF_DW, R10, R0, -40),
4119 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4120 BPF_EXIT_INSN(),
4121 },
4122 INTERNAL,
4123 { },
4124 { { 0, 0x22 } },
4125 },
4126 /* BPF_JMP | BPF_EXIT */
4127 {
4128 "JMP_EXIT",
4129 .u.insns_int = {
4130 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
4131 BPF_EXIT_INSN(),
4132 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
4133 },
4134 INTERNAL,
4135 { },
4136 { { 0, 0x4711 } },
4137 },
4138 /* BPF_JMP | BPF_JA */
4139 {
4140 "JMP_JA: Unconditional jump: if (true) return 1",
4141 .u.insns_int = {
4142 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4143 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
4144 BPF_EXIT_INSN(),
4145 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4146 BPF_EXIT_INSN(),
4147 },
4148 INTERNAL,
4149 { },
4150 { { 0, 1 } },
4151 },
4152 /* BPF_JMP | BPF_JSGT | BPF_K */
4153 {
4154 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4155 .u.insns_int = {
4156 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4157 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4158 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
4159 BPF_EXIT_INSN(),
4160 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4161 BPF_EXIT_INSN(),
4162 },
4163 INTERNAL,
4164 { },
4165 { { 0, 1 } },
4166 },
4167 {
4168 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4169 .u.insns_int = {
4170 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4171 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4172 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
4173 BPF_EXIT_INSN(),
4174 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4175 BPF_EXIT_INSN(),
4176 },
4177 INTERNAL,
4178 { },
4179 { { 0, 1 } },
4180 },
4181 /* BPF_JMP | BPF_JSGE | BPF_K */
4182 {
4183 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4184 .u.insns_int = {
4185 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4186 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4187 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
4188 BPF_EXIT_INSN(),
4189 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4190 BPF_EXIT_INSN(),
4191 },
4192 INTERNAL,
4193 { },
4194 { { 0, 1 } },
4195 },
4196 {
4197 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4198 .u.insns_int = {
4199 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4200 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4201 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
4202 BPF_EXIT_INSN(),
4203 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4204 BPF_EXIT_INSN(),
4205 },
4206 INTERNAL,
4207 { },
4208 { { 0, 1 } },
4209 },
4210 /* BPF_JMP | BPF_JGT | BPF_K */
4211 {
4212 "JMP_JGT_K: if (3 > 2) return 1",
4213 .u.insns_int = {
4214 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4215 BPF_LD_IMM64(R1, 3),
4216 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
4217 BPF_EXIT_INSN(),
4218 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4219 BPF_EXIT_INSN(),
4220 },
4221 INTERNAL,
4222 { },
4223 { { 0, 1 } },
4224 },
c7395d6b
NR		 4225 {
4226 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
4227 .u.insns_int = {
4228 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4229 BPF_LD_IMM64(R1, -1),
4230 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
4231 BPF_EXIT_INSN(),
4232 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4233 BPF_EXIT_INSN(),
4234 },
4235 INTERNAL,
4236 { },
4237 { { 0, 1 } },
4238 },
cffc642d
MH		 4239 /* BPF_JMP | BPF_JGE | BPF_K */
4240 {
4241 "JMP_JGE_K: if (3 >= 2) return 1",
4242 .u.insns_int = {
4243 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4244 BPF_LD_IMM64(R1, 3),
4245 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
4246 BPF_EXIT_INSN(),
4247 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4248 BPF_EXIT_INSN(),
4249 },
4250 INTERNAL,
4251 { },
4252 { { 0, 1 } },
4253 },
fe593844
MH		 4254 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4255 {
4256 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4257 .u.insns_int = {
4258 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4259 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4260 BPF_EXIT_INSN(),
4261 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4262 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
4263 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
4264 BPF_EXIT_INSN(),
4265 },
4266 INTERNAL,
4267 { },
4268 { { 0, 1 } },
4269 },
cffc642d
MH		 4270 {
4271 "JMP_JGE_K: if (3 >= 3) return 1",
4272 .u.insns_int = {
4273 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4274 BPF_LD_IMM64(R1, 3),
4275 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
4276 BPF_EXIT_INSN(),
4277 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4278 BPF_EXIT_INSN(),
4279 },
4280 INTERNAL,
4281 { },
4282 { { 0, 1 } },
4283 },
4284 /* BPF_JMP | BPF_JNE | BPF_K */
4285 {
4286 "JMP_JNE_K: if (3 != 2) return 1",
4287 .u.insns_int = {
4288 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4289 BPF_LD_IMM64(R1, 3),
4290 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4291 BPF_EXIT_INSN(),
4292 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4293 BPF_EXIT_INSN(),
4294 },
4295 INTERNAL,
4296 { },
4297 { { 0, 1 } },
4298 },
4299 /* BPF_JMP | BPF_JEQ | BPF_K */
4300 {
4301 "JMP_JEQ_K: if (3 == 3) return 1",
4302 .u.insns_int = {
4303 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4304 BPF_LD_IMM64(R1, 3),
4305 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
4306 BPF_EXIT_INSN(),
4307 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4308 BPF_EXIT_INSN(),
4309 },
4310 INTERNAL,
4311 { },
4312 { { 0, 1 } },
4313 },
4314 /* BPF_JMP | BPF_JSET | BPF_K */
4315 {
4316 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4317 .u.insns_int = {
4318 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4319 BPF_LD_IMM64(R1, 3),
9f134c34 4320 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
cffc642d
MH		 4321 BPF_EXIT_INSN(),
4322 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4323 BPF_EXIT_INSN(),
4324 },
4325 INTERNAL,
4326 { },
4327 { { 0, 1 } },
4328 },
4329 {
4330 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4331 .u.insns_int = {
4332 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4333 BPF_LD_IMM64(R1, 3),
9f134c34 4334 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
cffc642d
MH		 4335 BPF_EXIT_INSN(),
4336 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4337 BPF_EXIT_INSN(),
4338 },
4339 INTERNAL,
4340 { },
4341 { { 0, 1 } },
4342 },
4343 /* BPF_JMP | BPF_JSGT | BPF_X */
4344 {
4345 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4346 .u.insns_int = {
4347 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4348 BPF_LD_IMM64(R1, -1),
4349 BPF_LD_IMM64(R2, -2),
4350 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4351 BPF_EXIT_INSN(),
4352 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4353 BPF_EXIT_INSN(),
4354 },
4355 INTERNAL,
4356 { },
4357 { { 0, 1 } },
4358 },
4359 {
4360 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
4361 .u.insns_int = {
4362 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4363 BPF_LD_IMM64(R1, -1),
4364 BPF_LD_IMM64(R2, -1),
4365 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4366 BPF_EXIT_INSN(),
4367 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4368 BPF_EXIT_INSN(),
4369 },
4370 INTERNAL,
4371 { },
4372 { { 0, 1 } },
4373 },
4374 /* BPF_JMP | BPF_JSGE | BPF_X */
4375 {
4376 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
4377 .u.insns_int = {
4378 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4379 BPF_LD_IMM64(R1, -1),
4380 BPF_LD_IMM64(R2, -2),
4381 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4382 BPF_EXIT_INSN(),
4383 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4384 BPF_EXIT_INSN(),
4385 },
4386 INTERNAL,
4387 { },
4388 { { 0, 1 } },
4389 },
4390 {
4391 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
4392 .u.insns_int = {
4393 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4394 BPF_LD_IMM64(R1, -1),
4395 BPF_LD_IMM64(R2, -1),
4396 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4397 BPF_EXIT_INSN(),
4398 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4399 BPF_EXIT_INSN(),
4400 },
4401 INTERNAL,
4402 { },
4403 { { 0, 1 } },
4404 },
4405 /* BPF_JMP | BPF_JGT | BPF_X */
4406 {
4407 "JMP_JGT_X: if (3 > 2) return 1",
4408 .u.insns_int = {
4409 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4410 BPF_LD_IMM64(R1, 3),
4411 BPF_LD_IMM64(R2, 2),
4412 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
4413 BPF_EXIT_INSN(),
4414 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4415 BPF_EXIT_INSN(),
4416 },
4417 INTERNAL,
4418 { },
4419 { { 0, 1 } },
4420 },
c7395d6b
NR		 4421 {
4422 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
4423 .u.insns_int = {
4424 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4425 BPF_LD_IMM64(R1, -1),
4426 BPF_LD_IMM64(R2, 1),
4427 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
4428 BPF_EXIT_INSN(),
4429 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4430 BPF_EXIT_INSN(),
4431 },
4432 INTERNAL,
4433 { },
4434 { { 0, 1 } },
4435 },
cffc642d
MH		 4436 /* BPF_JMP | BPF_JGE | BPF_X */
4437 {
4438 "JMP_JGE_X: if (3 >= 2) return 1",
4439 .u.insns_int = {
4440 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4441 BPF_LD_IMM64(R1, 3),
4442 BPF_LD_IMM64(R2, 2),
4443 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
4444 BPF_EXIT_INSN(),
4445 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4446 BPF_EXIT_INSN(),
4447 },
4448 INTERNAL,
4449 { },
4450 { { 0, 1 } },
4451 },
4452 {
4453 "JMP_JGE_X: if (3 >= 3) return 1",
4454 .u.insns_int = {
4455 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4456 BPF_LD_IMM64(R1, 3),
4457 BPF_LD_IMM64(R2, 3),
4458 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
4459 BPF_EXIT_INSN(),
4460 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4461 BPF_EXIT_INSN(),
4462 },
4463 INTERNAL,
4464 { },
4465 { { 0, 1 } },
4466 },
4467 /* BPF_JMP | BPF_JNE | BPF_X */
4468 {
4469 "JMP_JNE_X: if (3 != 2) return 1",
4470 .u.insns_int = {
4471 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4472 BPF_LD_IMM64(R1, 3),
4473 BPF_LD_IMM64(R2, 2),
4474 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
4475 BPF_EXIT_INSN(),
4476 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4477 BPF_EXIT_INSN(),
4478 },
4479 INTERNAL,
4480 { },
4481 { { 0, 1 } },
4482 },
4483 /* BPF_JMP | BPF_JEQ | BPF_X */
4484 {
4485 "JMP_JEQ_X: if (3 == 3) return 1",
4486 .u.insns_int = {
4487 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4488 BPF_LD_IMM64(R1, 3),
4489 BPF_LD_IMM64(R2, 3),
4490 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4491 BPF_EXIT_INSN(),
4492 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4493 BPF_EXIT_INSN(),
4494 },
4495 INTERNAL,
4496 { },
4497 { { 0, 1 } },
4498 },
4499 /* BPF_JMP | BPF_JSET | BPF_X */
4500 {
4501 "JMP_JSET_X: if (0x3 & 0x2) return 1",
4502 .u.insns_int = {
4503 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4504 BPF_LD_IMM64(R1, 3),
4505 BPF_LD_IMM64(R2, 2),
9f134c34 4506 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 4507 BPF_EXIT_INSN(),
4508 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4509 BPF_EXIT_INSN(),
4510 },
4511 INTERNAL,
4512 { },
4513 { { 0, 1 } },
4514 },
4515 {
4516 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
4517 .u.insns_int = {
4518 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4519 BPF_LD_IMM64(R1, 3),
4520 BPF_LD_IMM64(R2, 0xffffffff),
9f134c34 4521 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
cffc642d
MH		 4522 BPF_EXIT_INSN(),
4523 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4524 BPF_EXIT_INSN(),
4525 },
4526 INTERNAL,
4527 { },
4528 { { 0, 1 } },
4529 },
bde28bc6
DB		 4530 {
4531 "JMP_JA: Jump, gap, jump, ...",
4532 { },
4533 CLASSIC | FLAG_NO_DATA,
4534 { },
4535 { { 0, 0xababcbac } },
4536 .fill_helper = bpf_fill_ja,
4537 },
a4afd37b
DB		 4538 { /* Mainly checking JIT here. */
4539 "BPF_MAXINSNS: Maximum possible literals",
4540 { },
4541 CLASSIC | FLAG_NO_DATA,
4542 { },
4543 { { 0, 0xffffffff } },
4544 .fill_helper = bpf_fill_maxinsns1,
4545 },
4546 { /* Mainly checking JIT here. */
4547 "BPF_MAXINSNS: Single literal",
4548 { },
4549 CLASSIC | FLAG_NO_DATA,
4550 { },
4551 { { 0, 0xfefefefe } },
4552 .fill_helper = bpf_fill_maxinsns2,
4553 },
4554 { /* Mainly checking JIT here. */
4555 "BPF_MAXINSNS: Run/add until end",
4556 { },
4557 CLASSIC | FLAG_NO_DATA,
4558 { },
4559 { { 0, 0x947bf368 } },
4560 .fill_helper = bpf_fill_maxinsns3,
4561 },
4562 {
4563 "BPF_MAXINSNS: Too many instructions",
4564 { },
4565 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4566 { },
4567 { },
4568 .fill_helper = bpf_fill_maxinsns4,
4569 },
4570 { /* Mainly checking JIT here. */
4571 "BPF_MAXINSNS: Very long jump",
4572 { },
4573 CLASSIC | FLAG_NO_DATA,
4574 { },
4575 { { 0, 0xabababab } },
4576 .fill_helper = bpf_fill_maxinsns5,
4577 },
4578 { /* Mainly checking JIT here. */
4579 "BPF_MAXINSNS: Ctx heavy transformations",
4580 { },
4581 CLASSIC,
4582 { },
4583 {
4584 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
4585 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
4586 },
4587 .fill_helper = bpf_fill_maxinsns6,
4588 },
4589 { /* Mainly checking JIT here. */
4590 "BPF_MAXINSNS: Call heavy transformations",
4591 { },
4592 CLASSIC | FLAG_NO_DATA,
4593 { },
4594 { { 1, 0 }, { 10, 0 } },
4595 .fill_helper = bpf_fill_maxinsns7,
4596 },
4597 { /* Mainly checking JIT here. */
4598 "BPF_MAXINSNS: Jump heavy test",
4599 { },
4600 CLASSIC | FLAG_NO_DATA,
4601 { },
4602 { { 0, 0xffffffff } },
4603 .fill_helper = bpf_fill_maxinsns8,
4604 },
3b529602
DB		 4605 { /* Mainly checking JIT here. */
4606 "BPF_MAXINSNS: Very long jump backwards",
4607 { },
4608 INTERNAL | FLAG_NO_DATA,
4609 { },
4610 { { 0, 0xcbababab } },
4611 .fill_helper = bpf_fill_maxinsns9,
4612 },
4613 { /* Mainly checking JIT here. */
4614 "BPF_MAXINSNS: Edge hopping nuthouse",
4615 { },
4616 INTERNAL | FLAG_NO_DATA,
4617 { },
4618 { { 0, 0xabababac } },
4619 .fill_helper = bpf_fill_maxinsns10,
4620 },
bde28bc6
DB		 4621 {
4622 "BPF_MAXINSNS: Jump, gap, jump, ...",
4623 { },
4624 CLASSIC | FLAG_NO_DATA,
4625 { },
4626 { { 0, 0xababcbac } },
4627 .fill_helper = bpf_fill_maxinsns11,
4628 },
4d9c5c53
AS		 4629 {
4630 "BPF_MAXINSNS: ld_abs+get_processor_id",
4631 { },
4632 CLASSIC,
4633 { },
4634 { { 1, 0xbee } },
4635 .fill_helper = bpf_fill_ld_abs_get_processor_id,
4636 },
4637 {
4638 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
4639 { },
4640 INTERNAL,
4641 { 0x34 },
4642 { { 1, 0xbef } },
4643 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
4644 },
2cf1ad75
NS		 4645 /*
4646 * LD_IND / LD_ABS on fragmented SKBs
4647 */
4648 {
4649 "LD_IND byte frag",
4650 .u.insns = {
4651 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4652 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
4653 BPF_STMT(BPF_RET | BPF_A, 0x0),
4654 },
4655 CLASSIC | FLAG_SKB_FRAG,
4656 { },
4657 { {0x40, 0x42} },
4658 .frag_data = {
4659 0x42, 0x00, 0x00, 0x00,
4660 0x43, 0x44, 0x00, 0x00,
4661 0x21, 0x07, 0x19, 0x83,
4662 },
4663 },
4664 {
4665 "LD_IND halfword frag",
4666 .u.insns = {
4667 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4668 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
4669 BPF_STMT(BPF_RET | BPF_A, 0x0),
4670 },
4671 CLASSIC | FLAG_SKB_FRAG,
4672 { },
4673 { {0x40, 0x4344} },
4674 .frag_data = {
4675 0x42, 0x00, 0x00, 0x00,
4676 0x43, 0x44, 0x00, 0x00,
4677 0x21, 0x07, 0x19, 0x83,
4678 },
4679 },
4680 {
4681 "LD_IND word frag",
4682 .u.insns = {
4683 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4684 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
4685 BPF_STMT(BPF_RET | BPF_A, 0x0),
4686 },
4687 CLASSIC | FLAG_SKB_FRAG,
4688 { },
4689 { {0x40, 0x21071983} },
4690 .frag_data = {
4691 0x42, 0x00, 0x00, 0x00,
4692 0x43, 0x44, 0x00, 0x00,
4693 0x21, 0x07, 0x19, 0x83,
4694 },
4695 },
4696 {
4697 "LD_IND halfword mixed head/frag",
4698 .u.insns = {
4699 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4700 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4701 BPF_STMT(BPF_RET | BPF_A, 0x0),
4702 },
4703 CLASSIC | FLAG_SKB_FRAG,
4704 { [0x3e] = 0x25, [0x3f] = 0x05, },
4705 { {0x40, 0x0519} },
4706 .frag_data = { 0x19, 0x82 },
4707 },
4708 {
4709 "LD_IND word mixed head/frag",
4710 .u.insns = {
4711 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4712 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4713 BPF_STMT(BPF_RET | BPF_A, 0x0),
4714 },
4715 CLASSIC | FLAG_SKB_FRAG,
4716 { [0x3e] = 0x25, [0x3f] = 0x05, },
4717 { {0x40, 0x25051982} },
4718 .frag_data = { 0x19, 0x82 },
4719 },
4720 {
4721 "LD_ABS byte frag",
4722 .u.insns = {
4723 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
4724 BPF_STMT(BPF_RET | BPF_A, 0x0),
4725 },
4726 CLASSIC | FLAG_SKB_FRAG,
4727 { },
4728 { {0x40, 0x42} },
4729 .frag_data = {
4730 0x42, 0x00, 0x00, 0x00,
4731 0x43, 0x44, 0x00, 0x00,
4732 0x21, 0x07, 0x19, 0x83,
4733 },
4734 },
4735 {
4736 "LD_ABS halfword frag",
4737 .u.insns = {
4738 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
4739 BPF_STMT(BPF_RET | BPF_A, 0x0),
4740 },
4741 CLASSIC | FLAG_SKB_FRAG,
4742 { },
4743 { {0x40, 0x4344} },
4744 .frag_data = {
4745 0x42, 0x00, 0x00, 0x00,
4746 0x43, 0x44, 0x00, 0x00,
4747 0x21, 0x07, 0x19, 0x83,
4748 },
4749 },
4750 {
4751 "LD_ABS word frag",
4752 .u.insns = {
4753 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
4754 BPF_STMT(BPF_RET | BPF_A, 0x0),
4755 },
4756 CLASSIC | FLAG_SKB_FRAG,
4757 { },
4758 { {0x40, 0x21071983} },
4759 .frag_data = {
4760 0x42, 0x00, 0x00, 0x00,
4761 0x43, 0x44, 0x00, 0x00,
4762 0x21, 0x07, 0x19, 0x83,
4763 },
4764 },
4765 {
4766 "LD_ABS halfword mixed head/frag",
4767 .u.insns = {
4768 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
4769 BPF_STMT(BPF_RET | BPF_A, 0x0),
4770 },
4771 CLASSIC | FLAG_SKB_FRAG,
4772 { [0x3e] = 0x25, [0x3f] = 0x05, },
4773 { {0x40, 0x0519} },
4774 .frag_data = { 0x19, 0x82 },
4775 },
4776 {
4777 "LD_ABS word mixed head/frag",
4778 .u.insns = {
4779 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
4780 BPF_STMT(BPF_RET | BPF_A, 0x0),
4781 },
4782 CLASSIC | FLAG_SKB_FRAG,
4783 { [0x3e] = 0x25, [0x3f] = 0x05, },
4784 { {0x40, 0x25051982} },
4785 .frag_data = { 0x19, 0x82 },
4786 },
08fcb08f
NS		 4787 /*
4788 * LD_IND / LD_ABS on non fragmented SKBs
4789 */
4790 {
4791 /*
4792 * this tests that the JIT/interpreter correctly resets X
4793 * before using it in an LD_IND instruction.
4794 */
4795 "LD_IND byte default X",
4796 .u.insns = {
4797 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
4798 BPF_STMT(BPF_RET | BPF_A, 0x0),
4799 },
4800 CLASSIC,
4801 { [0x1] = 0x42 },
4802 { {0x40, 0x42 } },
4803 },
4804 {
4805 "LD_IND byte positive offset",
4806 .u.insns = {
4807 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
4808 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
4809 BPF_STMT(BPF_RET | BPF_A, 0x0),
4810 },
4811 CLASSIC,
4812 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
4813 { {0x40, 0x82 } },
4814 },
4815 {
4816 "LD_IND byte negative offset",
4817 .u.insns = {
4818 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
4819 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
4820 BPF_STMT(BPF_RET | BPF_A, 0x0),
4821 },
4822 CLASSIC,
4823 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
4824 { {0x40, 0x05 } },
4825 },
4826 {
4827 "LD_IND halfword positive offset",
4828 .u.insns = {
4829 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4830 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
4831 BPF_STMT(BPF_RET | BPF_A, 0x0),
4832 },
4833 CLASSIC,
4834 {
4835 [0x1c] = 0xaa, [0x1d] = 0x55,
4836 [0x1e] = 0xbb, [0x1f] = 0x66,
4837 [0x20] = 0xcc, [0x21] = 0x77,
4838 [0x22] = 0xdd, [0x23] = 0x88,
4839 },
4840 { {0x40, 0xdd88 } },
4841 },
4842 {
4843 "LD_IND halfword negative offset",
4844 .u.insns = {
4845 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4846 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
4847 BPF_STMT(BPF_RET | BPF_A, 0x0),
4848 },
4849 CLASSIC,
4850 {
4851 [0x1c] = 0xaa, [0x1d] = 0x55,
4852 [0x1e] = 0xbb, [0x1f] = 0x66,
4853 [0x20] = 0xcc, [0x21] = 0x77,
4854 [0x22] = 0xdd, [0x23] = 0x88,
4855 },
4856 { {0x40, 0xbb66 } },
4857 },
4858 {
4859 "LD_IND halfword unaligned",
4860 .u.insns = {
4861 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4862 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4863 BPF_STMT(BPF_RET | BPF_A, 0x0),
4864 },
4865 CLASSIC,
4866 {
4867 [0x1c] = 0xaa, [0x1d] = 0x55,
4868 [0x1e] = 0xbb, [0x1f] = 0x66,
4869 [0x20] = 0xcc, [0x21] = 0x77,
4870 [0x22] = 0xdd, [0x23] = 0x88,
4871 },
4872 { {0x40, 0x66cc } },
4873 },
4874 {
4875 "LD_IND word positive offset",
4876 .u.insns = {
4877 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4878 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
4879 BPF_STMT(BPF_RET | BPF_A, 0x0),
4880 },
4881 CLASSIC,
4882 {
4883 [0x1c] = 0xaa, [0x1d] = 0x55,
4884 [0x1e] = 0xbb, [0x1f] = 0x66,
4885 [0x20] = 0xcc, [0x21] = 0x77,
4886 [0x22] = 0xdd, [0x23] = 0x88,
4887 [0x24] = 0xee, [0x25] = 0x99,
4888 [0x26] = 0xff, [0x27] = 0xaa,
4889 },
4890 { {0x40, 0xee99ffaa } },
4891 },
4892 {
4893 "LD_IND word negative offset",
4894 .u.insns = {
4895 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4896 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
4897 BPF_STMT(BPF_RET | BPF_A, 0x0),
4898 },
4899 CLASSIC,
4900 {
4901 [0x1c] = 0xaa, [0x1d] = 0x55,
4902 [0x1e] = 0xbb, [0x1f] = 0x66,
4903 [0x20] = 0xcc, [0x21] = 0x77,
4904 [0x22] = 0xdd, [0x23] = 0x88,
4905 [0x24] = 0xee, [0x25] = 0x99,
4906 [0x26] = 0xff, [0x27] = 0xaa,
4907 },
4908 { {0x40, 0xaa55bb66 } },
4909 },
4910 {
4911 "LD_IND word unaligned (addr & 3 == 2)",
4912 .u.insns = {
4913 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4914 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4915 BPF_STMT(BPF_RET | BPF_A, 0x0),
4916 },
4917 CLASSIC,
4918 {
4919 [0x1c] = 0xaa, [0x1d] = 0x55,
4920 [0x1e] = 0xbb, [0x1f] = 0x66,
4921 [0x20] = 0xcc, [0x21] = 0x77,
4922 [0x22] = 0xdd, [0x23] = 0x88,
4923 [0x24] = 0xee, [0x25] = 0x99,
4924 [0x26] = 0xff, [0x27] = 0xaa,
4925 },
4926 { {0x40, 0xbb66cc77 } },
4927 },
4928 {
4929 "LD_IND word unaligned (addr & 3 == 1)",
4930 .u.insns = {
4931 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4932 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
4933 BPF_STMT(BPF_RET | BPF_A, 0x0),
4934 },
4935 CLASSIC,
4936 {
4937 [0x1c] = 0xaa, [0x1d] = 0x55,
4938 [0x1e] = 0xbb, [0x1f] = 0x66,
4939 [0x20] = 0xcc, [0x21] = 0x77,
4940 [0x22] = 0xdd, [0x23] = 0x88,
4941 [0x24] = 0xee, [0x25] = 0x99,
4942 [0x26] = 0xff, [0x27] = 0xaa,
4943 },
4944 { {0x40, 0x55bb66cc } },
4945 },
4946 {
4947 "LD_IND word unaligned (addr & 3 == 3)",
4948 .u.insns = {
4949 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4950 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
4951 BPF_STMT(BPF_RET | BPF_A, 0x0),
4952 },
4953 CLASSIC,
4954 {
4955 [0x1c] = 0xaa, [0x1d] = 0x55,
4956 [0x1e] = 0xbb, [0x1f] = 0x66,
4957 [0x20] = 0xcc, [0x21] = 0x77,
4958 [0x22] = 0xdd, [0x23] = 0x88,
4959 [0x24] = 0xee, [0x25] = 0x99,
4960 [0x26] = 0xff, [0x27] = 0xaa,
4961 },
4962 { {0x40, 0x66cc77dd } },
4963 },
4964 {
4965 "LD_ABS byte",
4966 .u.insns = {
4967 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
4968 BPF_STMT(BPF_RET | BPF_A, 0x0),
4969 },
4970 CLASSIC,
4971 {
4972 [0x1c] = 0xaa, [0x1d] = 0x55,
4973 [0x1e] = 0xbb, [0x1f] = 0x66,
4974 [0x20] = 0xcc, [0x21] = 0x77,
4975 [0x22] = 0xdd, [0x23] = 0x88,
4976 [0x24] = 0xee, [0x25] = 0x99,
4977 [0x26] = 0xff, [0x27] = 0xaa,
4978 },
4979 { {0x40, 0xcc } },
4980 },
4981 {
4982 "LD_ABS halfword",
4983 .u.insns = {
4984 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
4985 BPF_STMT(BPF_RET | BPF_A, 0x0),
4986 },
4987 CLASSIC,
4988 {
4989 [0x1c] = 0xaa, [0x1d] = 0x55,
4990 [0x1e] = 0xbb, [0x1f] = 0x66,
4991 [0x20] = 0xcc, [0x21] = 0x77,
4992 [0x22] = 0xdd, [0x23] = 0x88,
4993 [0x24] = 0xee, [0x25] = 0x99,
4994 [0x26] = 0xff, [0x27] = 0xaa,
4995 },
4996 { {0x40, 0xdd88 } },
4997 },
4998 {
4999 "LD_ABS halfword unaligned",
5000 .u.insns = {
5001 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
5002 BPF_STMT(BPF_RET | BPF_A, 0x0),
5003 },
5004 CLASSIC,
5005 {
5006 [0x1c] = 0xaa, [0x1d] = 0x55,
5007 [0x1e] = 0xbb, [0x1f] = 0x66,
5008 [0x20] = 0xcc, [0x21] = 0x77,
5009 [0x22] = 0xdd, [0x23] = 0x88,
5010 [0x24] = 0xee, [0x25] = 0x99,
5011 [0x26] = 0xff, [0x27] = 0xaa,
5012 },
5013 { {0x40, 0x99ff } },
5014 },
5015 {
5016 "LD_ABS word",
5017 .u.insns = {
5018 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
5019 BPF_STMT(BPF_RET | BPF_A, 0x0),
5020 },
5021 CLASSIC,
5022 {
5023 [0x1c] = 0xaa, [0x1d] = 0x55,
5024 [0x1e] = 0xbb, [0x1f] = 0x66,
5025 [0x20] = 0xcc, [0x21] = 0x77,
5026 [0x22] = 0xdd, [0x23] = 0x88,
5027 [0x24] = 0xee, [0x25] = 0x99,
5028 [0x26] = 0xff, [0x27] = 0xaa,
5029 },
5030 { {0x40, 0xaa55bb66 } },
5031 },
5032 {
5033 "LD_ABS word unaligned (addr & 3 == 2)",
5034 .u.insns = {
5035 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
5036 BPF_STMT(BPF_RET | BPF_A, 0x0),
5037 },
5038 CLASSIC,
5039 {
5040 [0x1c] = 0xaa, [0x1d] = 0x55,
5041 [0x1e] = 0xbb, [0x1f] = 0x66,
5042 [0x20] = 0xcc, [0x21] = 0x77,
5043 [0x22] = 0xdd, [0x23] = 0x88,
5044 [0x24] = 0xee, [0x25] = 0x99,
5045 [0x26] = 0xff, [0x27] = 0xaa,
5046 },
5047 { {0x40, 0xdd88ee99 } },
5048 },
5049 {
5050 "LD_ABS word unaligned (addr & 3 == 1)",
5051 .u.insns = {
5052 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
5053 BPF_STMT(BPF_RET | BPF_A, 0x0),
5054 },
5055 CLASSIC,
5056 {
5057 [0x1c] = 0xaa, [0x1d] = 0x55,
5058 [0x1e] = 0xbb, [0x1f] = 0x66,
5059 [0x20] = 0xcc, [0x21] = 0x77,
5060 [0x22] = 0xdd, [0x23] = 0x88,
5061 [0x24] = 0xee, [0x25] = 0x99,
5062 [0x26] = 0xff, [0x27] = 0xaa,
5063 },
5064 { {0x40, 0x77dd88ee } },
5065 },
5066 {
5067 "LD_ABS word unaligned (addr & 3 == 3)",
5068 .u.insns = {
5069 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
5070 BPF_STMT(BPF_RET | BPF_A, 0x0),
5071 },
5072 CLASSIC,
5073 {
5074 [0x1c] = 0xaa, [0x1d] = 0x55,
5075 [0x1e] = 0xbb, [0x1f] = 0x66,
5076 [0x20] = 0xcc, [0x21] = 0x77,
5077 [0x22] = 0xdd, [0x23] = 0x88,
5078 [0x24] = 0xee, [0x25] = 0x99,
5079 [0x26] = 0xff, [0x27] = 0xaa,
5080 },
5081 { {0x40, 0x88ee99ff } },
5082 },
86bf1721
NS		 5083 /*
5084 * verify that the interpreter or JIT correctly sets A and X
5085 * to 0.
5086 */
5087 {
5088 "ADD default X",
5089 .u.insns = {
5090 /*
5091 * A = 0x42
5092 * A = A + X
5093 * ret A
5094 */
5095 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5096 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
5097 BPF_STMT(BPF_RET | BPF_A, 0x0),
5098 },
5099 CLASSIC | FLAG_NO_DATA,
5100 {},
5101 { {0x1, 0x42 } },
5102 },
5103 {
5104 "ADD default A",
5105 .u.insns = {
5106 /*
5107 * A = A + 0x42
5108 * ret A
5109 */
5110 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
5111 BPF_STMT(BPF_RET | BPF_A, 0x0),
5112 },
5113 CLASSIC | FLAG_NO_DATA,
5114 {},
5115 { {0x1, 0x42 } },
5116 },
5117 {
5118 "SUB default X",
5119 .u.insns = {
5120 /*
5121 * A = 0x66
5122 * A = A - X
5123 * ret A
5124 */
5125 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
5126 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
5127 BPF_STMT(BPF_RET | BPF_A, 0x0),
5128 },
5129 CLASSIC | FLAG_NO_DATA,
5130 {},
5131 { {0x1, 0x66 } },
5132 },
5133 {
5134 "SUB default A",
5135 .u.insns = {
5136 /*
5137 * A = A - -0x66
5138 * ret A
5139 */
5140 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
5141 BPF_STMT(BPF_RET | BPF_A, 0x0),
5142 },
5143 CLASSIC | FLAG_NO_DATA,
5144 {},
5145 { {0x1, 0x66 } },
5146 },
5147 {
5148 "MUL default X",
5149 .u.insns = {
5150 /*
5151 * A = 0x42
5152 * A = A * X
5153 * ret A
5154 */
5155 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5156 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
5157 BPF_STMT(BPF_RET | BPF_A, 0x0),
5158 },
5159 CLASSIC | FLAG_NO_DATA,
5160 {},
5161 { {0x1, 0x0 } },
5162 },
5163 {
5164 "MUL default A",
5165 .u.insns = {
5166 /*
5167 * A = A * 0x66
5168 * ret A
5169 */
5170 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
5171 BPF_STMT(BPF_RET | BPF_A, 0x0),
5172 },
5173 CLASSIC | FLAG_NO_DATA,
5174 {},
5175 { {0x1, 0x0 } },
5176 },
5177 {
5178 "DIV default X",
5179 .u.insns = {
5180 /*
5181 * A = 0x42
5182 * A = A / X ; this halt the filter execution if X is 0
5183 * ret 0x42
5184 */
5185 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5186 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
5187 BPF_STMT(BPF_RET | BPF_K, 0x42),
5188 },
5189 CLASSIC | FLAG_NO_DATA,
5190 {},
5191 { {0x1, 0x0 } },
5192 },
5193 {
5194 "DIV default A",
5195 .u.insns = {
5196 /*
5197 * A = A / 1
5198 * ret A
5199 */
5200 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
5201 BPF_STMT(BPF_RET | BPF_A, 0x0),
5202 },
5203 CLASSIC | FLAG_NO_DATA,
5204 {},
5205 { {0x1, 0x0 } },
5206 },
d4e4bc16
YS		 5207 {
5208 "MOD default X",
5209 .u.insns = {
5210 /*
5211 * A = 0x42
5212 * A = A mod X ; this halt the filter execution if X is 0
5213 * ret 0x42
5214 */
5215 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
5216 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
5217 BPF_STMT(BPF_RET | BPF_K, 0x42),
5218 },
5219 CLASSIC | FLAG_NO_DATA,
5220 {},
5221 { {0x1, 0x0 } },
5222 },
5223 {
5224 "MOD default A",
5225 .u.insns = {
5226 /*
5227 * A = A mod 1
5228 * ret A
5229 */
5230 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
5231 BPF_STMT(BPF_RET | BPF_A, 0x0),
5232 },
5233 CLASSIC | FLAG_NO_DATA,
5234 {},
5235 { {0x1, 0x0 } },
5236 },
86bf1721
NS		 5237 {
5238 "JMP EQ default A",
5239 .u.insns = {
5240 /*
5241 * cmp A, 0x0, 0, 1
5242 * ret 0x42
5243 * ret 0x66
5244 */
5245 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
5246 BPF_STMT(BPF_RET | BPF_K, 0x42),
5247 BPF_STMT(BPF_RET | BPF_K, 0x66),
5248 },
5249 CLASSIC | FLAG_NO_DATA,
5250 {},
5251 { {0x1, 0x42 } },
5252 },
5253 {
5254 "JMP EQ default X",
5255 .u.insns = {
5256 /*
5257 * A = 0x0
5258 * cmp A, X, 0, 1
5259 * ret 0x42
5260 * ret 0x66
5261 */
5262 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
5263 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
5264 BPF_STMT(BPF_RET | BPF_K, 0x42),
5265 BPF_STMT(BPF_RET | BPF_K, 0x66),
5266 },
5267 CLASSIC | FLAG_NO_DATA,
5268 {},
5269 { {0x1, 0x42 } },
5270 },
64a8946b
AS		 5271};
5272
10f18e0b 5273static struct net_device dev;
64a8946b 5274
10f18e0b 5275static struct sk_buff *populate_skb(char *buf, int size)
64a8946b
AS		 5276{
5277 struct sk_buff *skb;
5278
5279 if (size >= MAX_DATA)
5280 return NULL;
5281
5282 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
5283 if (!skb)
5284 return NULL;
5285
5286 memcpy(__skb_put(skb, size), buf, size);
10f18e0b
DB		 5287
5288 /* Initialize a fake skb with test pattern. */
64a8946b
AS		 5289 skb_reset_mac_header(skb);
5290 skb->protocol = htons(ETH_P_IP);
5291 skb->pkt_type = SKB_TYPE;
5292 skb->mark = SKB_MARK;
5293 skb->hash = SKB_HASH;
5294 skb->queue_mapping = SKB_QUEUE_MAP;
5295 skb->vlan_tci = SKB_VLAN_TCI;
5296 skb->dev = &dev;
5297 skb->dev->ifindex = SKB_DEV_IFINDEX;
5298 skb->dev->type = SKB_DEV_TYPE;
5299 skb_set_network_header(skb, min(size, ETH_HLEN));
5300
5301 return skb;
5302}
5303
10f18e0b 5304static void *generate_test_data(struct bpf_test *test, int sub)
64a8946b 5305{
bac142ac
NS		 5306 struct sk_buff *skb;
5307 struct page *page;
5308
10f18e0b
DB		 5309 if (test->aux & FLAG_NO_DATA)
5310 return NULL;
64a8946b 5311
10f18e0b
DB		 5312 /* Test case expects an skb, so populate one. Various
5313 * subtests generate skbs of different sizes based on
5314 * the same data.
5315 */
bac142ac
NS		 5316 skb = populate_skb(test->data, test->test[sub].data_size);
5317 if (!skb)
5318 return NULL;
5319
5320 if (test->aux & FLAG_SKB_FRAG) {
5321 /*
5322 * when the test requires a fragmented skb, add a
5323 * single fragment to the skb, filled with
5324 * test->frag_data.
5325 */
5326 void *ptr;
5327
5328 page = alloc_page(GFP_KERNEL);
5329
5330 if (!page)
5331 goto err_kfree_skb;
5332
5333 ptr = kmap(page);
5334 if (!ptr)
5335 goto err_free_page;
5336 memcpy(ptr, test->frag_data, MAX_DATA);
5337 kunmap(page);
5338 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
5339 }
5340
5341 return skb;
5342
5343err_free_page:
5344 __free_page(page);
5345err_kfree_skb:
5346 kfree_skb(skb);
5347 return NULL;
10f18e0b
DB		 5348}
5349
5350static void release_test_data(const struct bpf_test *test, void *data)
5351{
5352 if (test->aux & FLAG_NO_DATA)
5353 return;
5354
5355 kfree_skb(data);
5356}
5357
a4afd37b 5358static int filter_length(int which)
10f18e0b 5359{
a4afd37b
DB		 5360 struct sock_filter *fp;
5361 int len;
10f18e0b 5362
a4afd37b
DB		 5363 if (tests[which].fill_helper)
5364 return tests[which].u.ptr.len;
5365
5366 fp = tests[which].u.insns;
e9d94504
CG		 5367 for (len = MAX_INSNS - 1; len > 0; --len)
5368 if (fp[len].code != 0 || fp[len].k != 0)
5369 break;
10f18e0b 5370
e9d94504 5371 return len + 1;
10f18e0b
DB		 5372}
5373
a4afd37b
DB		 5374static void *filter_pointer(int which)
5375{
5376 if (tests[which].fill_helper)
5377 return tests[which].u.ptr.insns;
5378 else
5379 return tests[which].u.insns;
5380}
5381
7ae457c1 5382static struct bpf_prog *generate_filter(int which, int *err)
10f18e0b 5383{
10f18e0b 5384 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
a4afd37b
DB		 5385 unsigned int flen = filter_length(which);
5386 void *fptr = filter_pointer(which);
5387 struct sock_fprog_kern fprog;
5388 struct bpf_prog *fp;
10f18e0b
DB		 5389
5390 switch (test_type) {
5391 case CLASSIC:
a4afd37b 5392 fprog.filter = fptr;
10f18e0b
DB		 5393 fprog.len = flen;
5394
7ae457c1 5395 *err = bpf_prog_create(&fp, &fprog);
10f18e0b
DB		 5396 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
5397 if (*err == -EINVAL) {
5398 pr_cont("PASS\n");
5399 /* Verifier rejected filter as expected. */
5400 *err = 0;
5401 return NULL;
5402 } else {
5403 pr_cont("UNEXPECTED_PASS\n");
5404 /* Verifier didn't reject the test that's
5405 * bad enough, just return!
5406 */
5407 *err = -EINVAL;
5408 return NULL;
5409 }
5410 }
5411 /* We don't expect to fail. */
5412 if (*err) {
5413 pr_cont("FAIL to attach err=%d len=%d\n",
5414 *err, fprog.len);
5415 return NULL;
5416 }
5417 break;
5418
5419 case INTERNAL:
60a3b225 5420 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
10f18e0b
DB		 5421 if (fp == NULL) {
5422 pr_cont("UNEXPECTED_FAIL no memory left\n");
5423 *err = -ENOMEM;
5424 return NULL;
64a8946b
AS		 5425 }
5426
10f18e0b 5427 fp->len = flen;
4962fa10
DB		 5428 /* Type doesn't really matter here as long as it's not unspec. */
5429 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
a4afd37b 5430 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
64a8946b 5431
7ae457c1 5432 bpf_prog_select_runtime(fp);
10f18e0b
DB		 5433 break;
5434 }
64a8946b 5435
10f18e0b
DB		 5436 *err = 0;
5437 return fp;
5438}
64a8946b 5439
7ae457c1 5440static void release_filter(struct bpf_prog *fp, int which)
10f18e0b
DB		 5441{
5442 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
64a8946b 5443
10f18e0b
DB		 5444 switch (test_type) {
5445 case CLASSIC:
7ae457c1 5446 bpf_prog_destroy(fp);
10f18e0b
DB		 5447 break;
5448 case INTERNAL:
7ae457c1 5449 bpf_prog_free(fp);
10f18e0b
DB		 5450 break;
5451 }
5452}
5453
7ae457c1 5454static int __run_one(const struct bpf_prog *fp, const void *data,
10f18e0b
DB		 5455 int runs, u64 *duration)
5456{
5457 u64 start, finish;
25ee7327 5458 int ret = 0, i;
10f18e0b 5459
4d9c5c53 5460 start = ktime_get_ns();
10f18e0b
DB		 5461
5462 for (i = 0; i < runs; i++)
7ae457c1 5463 ret = BPF_PROG_RUN(fp, data);
10f18e0b 5464
4d9c5c53 5465 finish = ktime_get_ns();
10f18e0b 5466
4d9c5c53 5467 *duration = finish - start;
10f18e0b
DB		 5468 do_div(*duration, runs);
5469
5470 return ret;
5471}
5472
7ae457c1 5473static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
10f18e0b
DB		 5474{
5475 int err_cnt = 0, i, runs = MAX_TESTRUNS;
5476
5477 for (i = 0; i < MAX_SUBTESTS; i++) {
5478 void *data;
5479 u64 duration;
5480 u32 ret;
5481
5482 if (test->test[i].data_size == 0 &&
5483 test->test[i].result == 0)
5484 break;
5485
5486 data = generate_test_data(test, i);
e34684f8
NS		 5487 if (!data && !(test->aux & FLAG_NO_DATA)) {
5488 pr_cont("data generation failed ");
5489 err_cnt++;
5490 break;
5491 }
10f18e0b
DB		 5492 ret = __run_one(fp, data, runs, &duration);
5493 release_test_data(test, data);
5494
5495 if (ret == test->test[i].result) {
5496 pr_cont("%lld ", duration);
5497 } else {
5498 pr_cont("ret %d != %d ", ret,
5499 test->test[i].result);
64a8946b
AS		 5500 err_cnt++;
5501 }
5502 }
5503
5504 return err_cnt;
5505}
5506
d2648d4e
NS		 5507static char test_name[64];
5508module_param_string(test_name, test_name, sizeof(test_name), 0);
5509
5510static int test_id = -1;
5511module_param(test_id, int, 0);
5512
5513static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
5514module_param_array(test_range, int, NULL, 0);
5515
5516static __init int find_test_index(const char *test_name)
5517{
5518 int i;
5519
5520 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5521 if (!strcmp(tests[i].descr, test_name))
5522 return i;
5523 }
5524 return -1;
5525}
5526
a4afd37b
DB		 5527static __init int prepare_bpf_tests(void)
5528{
5529 int i;
5530
d2648d4e
NS		 5531 if (test_id >= 0) {
5532 /*
5533 * if a test_id was specified, use test_range to
5534 * cover only that test.
5535 */
5536 if (test_id >= ARRAY_SIZE(tests)) {
5537 pr_err("test_bpf: invalid test_id specified.\n");
5538 return -EINVAL;
5539 }
5540
5541 test_range[0] = test_id;
5542 test_range[1] = test_id;
5543 } else if (*test_name) {
5544 /*
5545 * if a test_name was specified, find it and setup
5546 * test_range to cover only that test.
5547 */
5548 int idx = find_test_index(test_name);
5549
5550 if (idx < 0) {
5551 pr_err("test_bpf: no test named '%s' found.\n",
5552 test_name);
5553 return -EINVAL;
5554 }
5555 test_range[0] = idx;
5556 test_range[1] = idx;
5557 } else {
5558 /*
5559 * check that the supplied test_range is valid.
5560 */
5561 if (test_range[0] >= ARRAY_SIZE(tests) ||
5562 test_range[1] >= ARRAY_SIZE(tests) ||
5563 test_range[0] < 0 || test_range[1] < 0) {
5564 pr_err("test_bpf: test_range is out of bound.\n");
5565 return -EINVAL;
5566 }
5567
5568 if (test_range[1] < test_range[0]) {
5569 pr_err("test_bpf: test_range is ending before it starts.\n");
5570 return -EINVAL;
5571 }
5572 }
5573
a4afd37b
DB		 5574 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5575 if (tests[i].fill_helper &&
5576 tests[i].fill_helper(&tests[i]) < 0)
5577 return -ENOMEM;
5578 }
5579
5580 return 0;
5581}
5582
5583static __init void destroy_bpf_tests(void)
5584{
5585 int i;
5586
5587 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5588 if (tests[i].fill_helper)
5589 kfree(tests[i].u.ptr.insns);
5590 }
5591}
5592
d2648d4e
NS		 5593static bool exclude_test(int test_id)
5594{
5595 return test_id < test_range[0] || test_id > test_range[1];
5596}
5597
64a8946b
AS		 5598static __init int test_bpf(void)
5599{
10f18e0b 5600 int i, err_cnt = 0, pass_cnt = 0;
327941f8 5601 int jit_cnt = 0, run_cnt = 0;
64a8946b
AS		 5602
5603 for (i = 0; i < ARRAY_SIZE(tests); i++) {
7ae457c1 5604 struct bpf_prog *fp;
10f18e0b 5605 int err;
64a8946b 5606
d2648d4e
NS		 5607 if (exclude_test(i))
5608 continue;
5609
10f18e0b 5610 pr_info("#%d %s ", i, tests[i].descr);
64a8946b 5611
10f18e0b
DB		 5612 fp = generate_filter(i, &err);
5613 if (fp == NULL) {
5614 if (err == 0) {
5615 pass_cnt++;
5616 continue;
64a8946b 5617 }
64a8946b 5618
10f18e0b
DB		 5619 return err;
5620 }
327941f8
DB		 5621
5622 pr_cont("jited:%u ", fp->jited);
5623
5624 run_cnt++;
5625 if (fp->jited)
5626 jit_cnt++;
5627
64a8946b 5628 err = run_one(fp, &tests[i]);
10f18e0b 5629 release_filter(fp, i);
64a8946b
AS		 5630
5631 if (err) {
10f18e0b 5632 pr_cont("FAIL (%d times)\n", err);
64a8946b
AS		 5633 err_cnt++;
5634 } else {
5635 pr_cont("PASS\n");
10f18e0b 5636 pass_cnt++;
64a8946b
AS		 5637 }
5638 }
5639
327941f8
DB		 5640 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
5641 pass_cnt, err_cnt, jit_cnt, run_cnt);
5642
10f18e0b 5643 return err_cnt ? -EINVAL : 0;
64a8946b
AS		 5644}
5645
5646static int __init test_bpf_init(void)
5647{
a4afd37b
DB		 5648 int ret;
5649
5650 ret = prepare_bpf_tests();
5651 if (ret < 0)
5652 return ret;
5653
5654 ret = test_bpf();
5655
5656 destroy_bpf_tests();
5657 return ret;
64a8946b
AS		 5658}
5659
5660static void __exit test_bpf_exit(void)
5661{
5662}
5663
5664module_init(test_bpf_init);
5665module_exit(test_bpf_exit);
10f18e0b 5666
64a8946b 5667MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror