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