2 * Testsuite for BPF interpreter and BPF JIT compiler
4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/filter.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
23 #include <linux/if_vlan.h>
25 /* General test specific settings */
26 #define MAX_SUBTESTS 3
27 #define MAX_TESTRUNS 10000
30 #define MAX_K 0xffffFFFF
32 /* Few constants used to init test 'skb' */
34 #define SKB_MARK 0x1234aaaa
35 #define SKB_HASH 0x1234aaab
36 #define SKB_QUEUE_MAP 123
37 #define SKB_VLAN_TCI 0xffff
38 #define SKB_DEV_IFINDEX 577
39 #define SKB_DEV_TYPE 588
41 /* Redefine REGs to make tests less verbose */
52 #define R10 BPF_REG_10
54 /* Flags that can be passed to test cases */
55 #define FLAG_NO_DATA BIT(0)
56 #define FLAG_EXPECTED_FAIL BIT(1)
59 CLASSIC = BIT(6), /* Old BPF instructions only. */
60 INTERNAL = BIT(7), /* Extended instruction set. */
63 #define TEST_TYPE_MASK (CLASSIC | INTERNAL)
68 struct sock_filter insns[MAX_INSNS];
69 struct sock_filter_int insns_int[MAX_INSNS];
79 static struct bpf_test tests[] = {
83 BPF_STMT(BPF_LD | BPF_IMM, 1),
84 BPF_STMT(BPF_MISC | BPF_TAX, 0),
85 BPF_STMT(BPF_LD | BPF_IMM, 2),
86 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
87 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
88 BPF_STMT(BPF_MISC | BPF_TAX, 0),
89 BPF_STMT(BPF_LD | BPF_LEN, 0),
90 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
91 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
92 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
93 BPF_STMT(BPF_RET | BPF_A, 0)
96 { 10, 20, 30, 40, 50 },
97 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
102 BPF_STMT(BPF_LDX | BPF_LEN, 0),
103 BPF_STMT(BPF_MISC | BPF_TXA, 0),
104 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
105 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
108 { 10, 20, 30, 40, 50 },
109 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
114 BPF_STMT(BPF_LD | BPF_IMM, 1),
115 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
116 BPF_STMT(BPF_LDX | BPF_IMM, 3),
117 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
118 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
119 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
120 BPF_STMT(BPF_RET | BPF_A, 0)
122 CLASSIC | FLAG_NO_DATA,
124 { { 0, 0xfffffffd } }
129 BPF_STMT(BPF_LD | BPF_IMM, 8),
130 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
131 BPF_STMT(BPF_MISC | BPF_TAX, 0),
132 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
133 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
134 BPF_STMT(BPF_MISC | BPF_TAX, 0),
135 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
136 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
137 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
138 BPF_STMT(BPF_RET | BPF_A, 0)
140 CLASSIC | FLAG_NO_DATA,
142 { { 0, 0x40000001 } }
147 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
148 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
149 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
150 BPF_STMT(BPF_MISC | BPF_TAX, 0),
151 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
152 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
153 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
154 BPF_STMT(BPF_RET | BPF_A, 0)
156 CLASSIC | FLAG_NO_DATA,
158 { { 0, 0x800000ff }, { 1, 0x800000ff } },
163 BPF_STMT(BPF_LDX | BPF_LEN, 0),
164 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
165 BPF_STMT(BPF_RET | BPF_K, 1)
169 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
174 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
175 BPF_STMT(BPF_RET | BPF_K, 1)
179 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
184 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
185 BPF_STMT(BPF_MISC | BPF_TAX, 0),
186 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
187 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
188 BPF_STMT(BPF_RET | BPF_A, 0)
192 { { 1, 0 }, { 2, 3 } },
197 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
198 BPF_STMT(BPF_LDX | BPF_LEN, 0),
199 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
200 BPF_STMT(BPF_MISC | BPF_TAX, 0),
201 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
202 BPF_STMT(BPF_RET | BPF_A, 0)
206 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
211 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
212 BPF_STMT(BPF_MISC | BPF_TAX, 0),
213 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
214 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
215 BPF_STMT(BPF_RET | BPF_A, 0)
218 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
219 { { 15, 0 }, { 16, 3 } },
224 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
225 BPF_STMT(BPF_LDX | BPF_LEN, 0),
226 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
227 BPF_STMT(BPF_MISC | BPF_TAX, 0),
228 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
229 BPF_STMT(BPF_RET | BPF_A, 0)
232 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
233 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
238 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
239 SKF_AD_OFF + SKF_AD_PKTTYPE),
240 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
241 BPF_STMT(BPF_RET | BPF_K, 1),
242 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
243 SKF_AD_OFF + SKF_AD_PKTTYPE),
244 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
245 BPF_STMT(BPF_RET | BPF_K, 1),
246 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
247 SKF_AD_OFF + SKF_AD_PKTTYPE),
248 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
249 BPF_STMT(BPF_RET | BPF_K, 1),
250 BPF_STMT(BPF_RET | BPF_A, 0)
254 { { 1, 3 }, { 10, 3 } },
259 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
260 SKF_AD_OFF + SKF_AD_MARK),
261 BPF_STMT(BPF_RET | BPF_A, 0)
265 { { 1, SKB_MARK}, { 10, SKB_MARK} },
270 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
271 SKF_AD_OFF + SKF_AD_RXHASH),
272 BPF_STMT(BPF_RET | BPF_A, 0)
276 { { 1, SKB_HASH}, { 10, SKB_HASH} },
281 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
282 SKF_AD_OFF + SKF_AD_QUEUE),
283 BPF_STMT(BPF_RET | BPF_A, 0)
287 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
292 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
293 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
294 BPF_STMT(BPF_RET | BPF_K, 0),
295 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
296 SKF_AD_OFF + SKF_AD_PROTOCOL),
297 BPF_STMT(BPF_MISC | BPF_TAX, 0),
298 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
299 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
300 BPF_STMT(BPF_RET | BPF_K, 0),
301 BPF_STMT(BPF_MISC | BPF_TXA, 0),
302 BPF_STMT(BPF_RET | BPF_A, 0)
306 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
311 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
312 SKF_AD_OFF + SKF_AD_VLAN_TAG),
313 BPF_STMT(BPF_RET | BPF_A, 0)
318 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
319 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
323 "LD_VLAN_TAG_PRESENT",
325 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
326 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
327 BPF_STMT(BPF_RET | BPF_A, 0)
332 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
333 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
339 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
340 SKF_AD_OFF + SKF_AD_IFINDEX),
341 BPF_STMT(BPF_RET | BPF_A, 0)
345 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
350 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
351 SKF_AD_OFF + SKF_AD_HATYPE),
352 BPF_STMT(BPF_RET | BPF_A, 0)
356 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
361 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
362 SKF_AD_OFF + SKF_AD_CPU),
363 BPF_STMT(BPF_MISC | BPF_TAX, 0),
364 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
365 SKF_AD_OFF + SKF_AD_CPU),
366 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
367 BPF_STMT(BPF_RET | BPF_A, 0)
371 { { 1, 0 }, { 10, 0 } },
376 BPF_STMT(BPF_LDX | BPF_IMM, 1),
377 BPF_STMT(BPF_MISC | BPF_TXA, 0),
378 BPF_STMT(BPF_LDX | BPF_IMM, 3),
379 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
380 SKF_AD_OFF + SKF_AD_NLATTR),
381 BPF_STMT(BPF_RET | BPF_A, 0)
384 { 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
385 { { 4, 0 }, { 20, 5 } },
390 BPF_STMT(BPF_LD | BPF_IMM, 1),
391 BPF_STMT(BPF_LDX | BPF_IMM, 3),
392 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
393 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
394 BPF_STMT(BPF_LD | BPF_IMM, 1),
395 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
396 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
397 BPF_STMT(BPF_LD | BPF_IMM, 1),
398 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
399 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
400 BPF_STMT(BPF_LD | BPF_IMM, 1),
401 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
402 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
403 BPF_STMT(BPF_LD | BPF_IMM, 1),
404 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
405 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
406 BPF_STMT(BPF_LD | BPF_IMM, 1),
407 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
408 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
409 BPF_STMT(BPF_LD | BPF_IMM, 1),
410 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
411 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
412 BPF_STMT(BPF_LD | BPF_IMM, 1),
413 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
414 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
415 BPF_STMT(BPF_RET | BPF_A, 0)
418 { 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
419 { { 4, 0 }, { 20, 9 } },
424 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
425 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
426 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
427 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
428 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
429 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
430 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
431 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
432 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
433 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
434 BPF_STMT(BPF_RET | BPF_A, 0)
437 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
438 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
439 * id 9737, seq 1, length 64
441 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
444 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
445 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
446 { { 30, 0 }, { 100, 42 } },
451 BPF_STMT(BPF_LD | BPF_IMM, 10),
452 BPF_STMT(BPF_LDX | BPF_IMM, 300),
453 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
454 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
455 BPF_STMT(BPF_RET | BPF_A, 0)
459 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
464 BPF_STMT(BPF_LDX | BPF_LEN, 0),
465 BPF_STMT(BPF_LD | BPF_IMM, 2),
466 BPF_STMT(BPF_ALU | BPF_RSH, 1),
467 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
468 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
469 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
470 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
471 BPF_STMT(BPF_STX, 15), /* M3 = len */
472 BPF_STMT(BPF_LDX | BPF_MEM, 1),
473 BPF_STMT(BPF_LD | BPF_MEM, 2),
474 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
475 BPF_STMT(BPF_LDX | BPF_MEM, 15),
476 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
477 BPF_STMT(BPF_RET | BPF_A, 0)
481 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
486 BPF_STMT(BPF_LDX | BPF_LEN, 0),
487 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
488 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
489 BPF_STMT(BPF_RET | BPF_K, 1),
490 BPF_STMT(BPF_RET | BPF_K, MAX_K)
494 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
499 BPF_STMT(BPF_LDX | BPF_LEN, 0),
500 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
501 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
502 BPF_STMT(BPF_RET | BPF_K, 1),
503 BPF_STMT(BPF_RET | BPF_K, MAX_K)
507 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
512 BPF_STMT(BPF_LDX | BPF_LEN, 0),
513 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
514 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
515 BPF_STMT(BPF_RET | BPF_K, 10),
516 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
517 BPF_STMT(BPF_RET | BPF_K, 20),
518 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
519 BPF_STMT(BPF_RET | BPF_K, 30),
520 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
521 BPF_STMT(BPF_RET | BPF_K, 40),
522 BPF_STMT(BPF_RET | BPF_K, MAX_K)
526 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
531 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
532 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
533 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
534 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
535 BPF_STMT(BPF_LDX | BPF_LEN, 0),
536 BPF_STMT(BPF_MISC | BPF_TXA, 0),
537 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
538 BPF_STMT(BPF_MISC | BPF_TAX, 0),
539 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
540 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
541 BPF_STMT(BPF_RET | BPF_K, 10),
542 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
543 BPF_STMT(BPF_RET | BPF_K, 20),
544 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
545 BPF_STMT(BPF_RET | BPF_K, 30),
546 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
547 BPF_STMT(BPF_RET | BPF_K, 30),
548 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
549 BPF_STMT(BPF_RET | BPF_K, 30),
550 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
551 BPF_STMT(BPF_RET | BPF_K, 30),
552 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
553 BPF_STMT(BPF_RET | BPF_K, 30),
554 BPF_STMT(BPF_RET | BPF_K, MAX_K)
557 { 0, 0xAA, 0x55, 1 },
558 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
563 { 0x28, 0, 0, 0x0000000c },
564 { 0x15, 0, 8, 0x000086dd },
565 { 0x30, 0, 0, 0x00000014 },
566 { 0x15, 2, 0, 0x00000084 },
567 { 0x15, 1, 0, 0x00000006 },
568 { 0x15, 0, 17, 0x00000011 },
569 { 0x28, 0, 0, 0x00000036 },
570 { 0x15, 14, 0, 0x00000016 },
571 { 0x28, 0, 0, 0x00000038 },
572 { 0x15, 12, 13, 0x00000016 },
573 { 0x15, 0, 12, 0x00000800 },
574 { 0x30, 0, 0, 0x00000017 },
575 { 0x15, 2, 0, 0x00000084 },
576 { 0x15, 1, 0, 0x00000006 },
577 { 0x15, 0, 8, 0x00000011 },
578 { 0x28, 0, 0, 0x00000014 },
579 { 0x45, 6, 0, 0x00001fff },
580 { 0xb1, 0, 0, 0x0000000e },
581 { 0x48, 0, 0, 0x0000000e },
582 { 0x15, 2, 0, 0x00000016 },
583 { 0x48, 0, 0, 0x00000010 },
584 { 0x15, 0, 1, 0x00000016 },
585 { 0x06, 0, 0, 0x0000ffff },
586 { 0x06, 0, 0, 0x00000000 },
589 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
590 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
591 * seq 1305692979:1305693027, ack 3650467037, win 65535,
592 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
594 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
595 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
597 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
598 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
599 0x0a, 0x01, 0x01, 0x95, /* ip src */
600 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
602 0x00, 0x16 /* dst port */ },
603 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
608 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
609 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
610 * (len > 115 or len < 30000000000)' -d
612 { 0x28, 0, 0, 0x0000000c },
613 { 0x15, 30, 0, 0x000086dd },
614 { 0x15, 0, 29, 0x00000800 },
615 { 0x30, 0, 0, 0x00000017 },
616 { 0x15, 0, 27, 0x00000006 },
617 { 0x28, 0, 0, 0x00000014 },
618 { 0x45, 25, 0, 0x00001fff },
619 { 0xb1, 0, 0, 0x0000000e },
620 { 0x48, 0, 0, 0x0000000e },
621 { 0x15, 2, 0, 0x00000016 },
622 { 0x48, 0, 0, 0x00000010 },
623 { 0x15, 0, 20, 0x00000016 },
624 { 0x28, 0, 0, 0x00000010 },
625 { 0x02, 0, 0, 0x00000001 },
626 { 0x30, 0, 0, 0x0000000e },
627 { 0x54, 0, 0, 0x0000000f },
628 { 0x64, 0, 0, 0x00000002 },
629 { 0x07, 0, 0, 0x00000005 },
630 { 0x60, 0, 0, 0x00000001 },
631 { 0x1c, 0, 0, 0x00000000 },
632 { 0x02, 0, 0, 0x00000005 },
633 { 0xb1, 0, 0, 0x0000000e },
634 { 0x50, 0, 0, 0x0000001a },
635 { 0x54, 0, 0, 0x000000f0 },
636 { 0x74, 0, 0, 0x00000002 },
637 { 0x07, 0, 0, 0x00000009 },
638 { 0x60, 0, 0, 0x00000005 },
639 { 0x1d, 4, 0, 0x00000000 },
640 { 0x80, 0, 0, 0x00000000 },
641 { 0x25, 1, 0, 0x00000073 },
642 { 0x35, 1, 0, 0xfc23ac00 },
643 { 0x06, 0, 0, 0x0000ffff },
644 { 0x06, 0, 0, 0x00000000 },
647 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
648 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
650 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
651 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
652 0x0a, 0x01, 0x01, 0x95, /* ip src */
653 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
655 0x00, 0x16 /* dst port */ },
656 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
661 /* check that unitialized X and A contain zeros */
662 BPF_STMT(BPF_MISC | BPF_TXA, 0),
663 BPF_STMT(BPF_RET | BPF_A, 0)
672 BPF_ALU64_IMM(BPF_MOV, R1, 1),
673 BPF_ALU64_IMM(BPF_ADD, R1, 2),
674 BPF_ALU64_IMM(BPF_MOV, R2, 3),
675 BPF_ALU64_REG(BPF_SUB, R1, R2),
676 BPF_ALU64_IMM(BPF_ADD, R1, -1),
677 BPF_ALU64_IMM(BPF_MUL, R1, 3),
678 BPF_ALU64_REG(BPF_MOV, R0, R1),
683 { { 0, 0xfffffffd } }
688 BPF_ALU64_IMM(BPF_MOV, R0, -1),
689 BPF_ALU64_IMM(BPF_MOV, R1, -1),
690 BPF_ALU64_IMM(BPF_MOV, R2, 3),
691 BPF_ALU64_REG(BPF_MUL, R1, R2),
692 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
694 BPF_ALU64_IMM(BPF_MOV, R0, 1),
704 BPF_ALU32_IMM(BPF_MOV, R0, -1),
705 BPF_ALU32_IMM(BPF_MOV, R1, -1),
706 BPF_ALU32_IMM(BPF_MOV, R2, 3),
707 BPF_ALU64_REG(BPF_MUL, R1, R2),
708 BPF_ALU64_IMM(BPF_RSH, R1, 8),
709 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
711 BPF_ALU32_IMM(BPF_MOV, R0, 1),
721 BPF_ALU32_IMM(BPF_MOV, R0, -1),
722 BPF_ALU64_IMM(BPF_MOV, R1, -1),
723 BPF_ALU32_IMM(BPF_MOV, R2, 3),
724 BPF_ALU32_REG(BPF_MUL, R1, R2),
725 BPF_ALU64_IMM(BPF_RSH, R1, 8),
726 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
728 BPF_ALU32_IMM(BPF_MOV, R0, 1),
736 /* Have to test all register combinations, since
737 * JITing of different registers will produce
738 * different asm code.
742 BPF_ALU64_IMM(BPF_MOV, R0, 0),
743 BPF_ALU64_IMM(BPF_MOV, R1, 1),
744 BPF_ALU64_IMM(BPF_MOV, R2, 2),
745 BPF_ALU64_IMM(BPF_MOV, R3, 3),
746 BPF_ALU64_IMM(BPF_MOV, R4, 4),
747 BPF_ALU64_IMM(BPF_MOV, R5, 5),
748 BPF_ALU64_IMM(BPF_MOV, R6, 6),
749 BPF_ALU64_IMM(BPF_MOV, R7, 7),
750 BPF_ALU64_IMM(BPF_MOV, R8, 8),
751 BPF_ALU64_IMM(BPF_MOV, R9, 9),
752 BPF_ALU64_IMM(BPF_ADD, R0, 20),
753 BPF_ALU64_IMM(BPF_ADD, R1, 20),
754 BPF_ALU64_IMM(BPF_ADD, R2, 20),
755 BPF_ALU64_IMM(BPF_ADD, R3, 20),
756 BPF_ALU64_IMM(BPF_ADD, R4, 20),
757 BPF_ALU64_IMM(BPF_ADD, R5, 20),
758 BPF_ALU64_IMM(BPF_ADD, R6, 20),
759 BPF_ALU64_IMM(BPF_ADD, R7, 20),
760 BPF_ALU64_IMM(BPF_ADD, R8, 20),
761 BPF_ALU64_IMM(BPF_ADD, R9, 20),
762 BPF_ALU64_IMM(BPF_SUB, R0, 10),
763 BPF_ALU64_IMM(BPF_SUB, R1, 10),
764 BPF_ALU64_IMM(BPF_SUB, R2, 10),
765 BPF_ALU64_IMM(BPF_SUB, R3, 10),
766 BPF_ALU64_IMM(BPF_SUB, R4, 10),
767 BPF_ALU64_IMM(BPF_SUB, R5, 10),
768 BPF_ALU64_IMM(BPF_SUB, R6, 10),
769 BPF_ALU64_IMM(BPF_SUB, R7, 10),
770 BPF_ALU64_IMM(BPF_SUB, R8, 10),
771 BPF_ALU64_IMM(BPF_SUB, R9, 10),
772 BPF_ALU64_REG(BPF_ADD, R0, R0),
773 BPF_ALU64_REG(BPF_ADD, R0, R1),
774 BPF_ALU64_REG(BPF_ADD, R0, R2),
775 BPF_ALU64_REG(BPF_ADD, R0, R3),
776 BPF_ALU64_REG(BPF_ADD, R0, R4),
777 BPF_ALU64_REG(BPF_ADD, R0, R5),
778 BPF_ALU64_REG(BPF_ADD, R0, R6),
779 BPF_ALU64_REG(BPF_ADD, R0, R7),
780 BPF_ALU64_REG(BPF_ADD, R0, R8),
781 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
782 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
784 BPF_ALU64_REG(BPF_ADD, R1, R0),
785 BPF_ALU64_REG(BPF_ADD, R1, R1),
786 BPF_ALU64_REG(BPF_ADD, R1, R2),
787 BPF_ALU64_REG(BPF_ADD, R1, R3),
788 BPF_ALU64_REG(BPF_ADD, R1, R4),
789 BPF_ALU64_REG(BPF_ADD, R1, R5),
790 BPF_ALU64_REG(BPF_ADD, R1, R6),
791 BPF_ALU64_REG(BPF_ADD, R1, R7),
792 BPF_ALU64_REG(BPF_ADD, R1, R8),
793 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
794 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
796 BPF_ALU64_REG(BPF_ADD, R2, R0),
797 BPF_ALU64_REG(BPF_ADD, R2, R1),
798 BPF_ALU64_REG(BPF_ADD, R2, R2),
799 BPF_ALU64_REG(BPF_ADD, R2, R3),
800 BPF_ALU64_REG(BPF_ADD, R2, R4),
801 BPF_ALU64_REG(BPF_ADD, R2, R5),
802 BPF_ALU64_REG(BPF_ADD, R2, R6),
803 BPF_ALU64_REG(BPF_ADD, R2, R7),
804 BPF_ALU64_REG(BPF_ADD, R2, R8),
805 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
806 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
808 BPF_ALU64_REG(BPF_ADD, R3, R0),
809 BPF_ALU64_REG(BPF_ADD, R3, R1),
810 BPF_ALU64_REG(BPF_ADD, R3, R2),
811 BPF_ALU64_REG(BPF_ADD, R3, R3),
812 BPF_ALU64_REG(BPF_ADD, R3, R4),
813 BPF_ALU64_REG(BPF_ADD, R3, R5),
814 BPF_ALU64_REG(BPF_ADD, R3, R6),
815 BPF_ALU64_REG(BPF_ADD, R3, R7),
816 BPF_ALU64_REG(BPF_ADD, R3, R8),
817 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
818 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
820 BPF_ALU64_REG(BPF_ADD, R4, R0),
821 BPF_ALU64_REG(BPF_ADD, R4, R1),
822 BPF_ALU64_REG(BPF_ADD, R4, R2),
823 BPF_ALU64_REG(BPF_ADD, R4, R3),
824 BPF_ALU64_REG(BPF_ADD, R4, R4),
825 BPF_ALU64_REG(BPF_ADD, R4, R5),
826 BPF_ALU64_REG(BPF_ADD, R4, R6),
827 BPF_ALU64_REG(BPF_ADD, R4, R7),
828 BPF_ALU64_REG(BPF_ADD, R4, R8),
829 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
830 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
832 BPF_ALU64_REG(BPF_ADD, R5, R0),
833 BPF_ALU64_REG(BPF_ADD, R5, R1),
834 BPF_ALU64_REG(BPF_ADD, R5, R2),
835 BPF_ALU64_REG(BPF_ADD, R5, R3),
836 BPF_ALU64_REG(BPF_ADD, R5, R4),
837 BPF_ALU64_REG(BPF_ADD, R5, R5),
838 BPF_ALU64_REG(BPF_ADD, R5, R6),
839 BPF_ALU64_REG(BPF_ADD, R5, R7),
840 BPF_ALU64_REG(BPF_ADD, R5, R8),
841 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
842 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
844 BPF_ALU64_REG(BPF_ADD, R6, R0),
845 BPF_ALU64_REG(BPF_ADD, R6, R1),
846 BPF_ALU64_REG(BPF_ADD, R6, R2),
847 BPF_ALU64_REG(BPF_ADD, R6, R3),
848 BPF_ALU64_REG(BPF_ADD, R6, R4),
849 BPF_ALU64_REG(BPF_ADD, R6, R5),
850 BPF_ALU64_REG(BPF_ADD, R6, R6),
851 BPF_ALU64_REG(BPF_ADD, R6, R7),
852 BPF_ALU64_REG(BPF_ADD, R6, R8),
853 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
854 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
856 BPF_ALU64_REG(BPF_ADD, R7, R0),
857 BPF_ALU64_REG(BPF_ADD, R7, R1),
858 BPF_ALU64_REG(BPF_ADD, R7, R2),
859 BPF_ALU64_REG(BPF_ADD, R7, R3),
860 BPF_ALU64_REG(BPF_ADD, R7, R4),
861 BPF_ALU64_REG(BPF_ADD, R7, R5),
862 BPF_ALU64_REG(BPF_ADD, R7, R6),
863 BPF_ALU64_REG(BPF_ADD, R7, R7),
864 BPF_ALU64_REG(BPF_ADD, R7, R8),
865 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
866 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
868 BPF_ALU64_REG(BPF_ADD, R8, R0),
869 BPF_ALU64_REG(BPF_ADD, R8, R1),
870 BPF_ALU64_REG(BPF_ADD, R8, R2),
871 BPF_ALU64_REG(BPF_ADD, R8, R3),
872 BPF_ALU64_REG(BPF_ADD, R8, R4),
873 BPF_ALU64_REG(BPF_ADD, R8, R5),
874 BPF_ALU64_REG(BPF_ADD, R8, R6),
875 BPF_ALU64_REG(BPF_ADD, R8, R7),
876 BPF_ALU64_REG(BPF_ADD, R8, R8),
877 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
878 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
880 BPF_ALU64_REG(BPF_ADD, R9, R0),
881 BPF_ALU64_REG(BPF_ADD, R9, R1),
882 BPF_ALU64_REG(BPF_ADD, R9, R2),
883 BPF_ALU64_REG(BPF_ADD, R9, R3),
884 BPF_ALU64_REG(BPF_ADD, R9, R4),
885 BPF_ALU64_REG(BPF_ADD, R9, R5),
886 BPF_ALU64_REG(BPF_ADD, R9, R6),
887 BPF_ALU64_REG(BPF_ADD, R9, R7),
888 BPF_ALU64_REG(BPF_ADD, R9, R8),
889 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
890 BPF_ALU64_REG(BPF_MOV, R0, R9),
900 BPF_ALU32_IMM(BPF_MOV, R0, 20),
901 BPF_ALU32_IMM(BPF_MOV, R1, 1),
902 BPF_ALU32_IMM(BPF_MOV, R2, 2),
903 BPF_ALU32_IMM(BPF_MOV, R3, 3),
904 BPF_ALU32_IMM(BPF_MOV, R4, 4),
905 BPF_ALU32_IMM(BPF_MOV, R5, 5),
906 BPF_ALU32_IMM(BPF_MOV, R6, 6),
907 BPF_ALU32_IMM(BPF_MOV, R7, 7),
908 BPF_ALU32_IMM(BPF_MOV, R8, 8),
909 BPF_ALU32_IMM(BPF_MOV, R9, 9),
910 BPF_ALU64_IMM(BPF_ADD, R1, 10),
911 BPF_ALU64_IMM(BPF_ADD, R2, 10),
912 BPF_ALU64_IMM(BPF_ADD, R3, 10),
913 BPF_ALU64_IMM(BPF_ADD, R4, 10),
914 BPF_ALU64_IMM(BPF_ADD, R5, 10),
915 BPF_ALU64_IMM(BPF_ADD, R6, 10),
916 BPF_ALU64_IMM(BPF_ADD, R7, 10),
917 BPF_ALU64_IMM(BPF_ADD, R8, 10),
918 BPF_ALU64_IMM(BPF_ADD, R9, 10),
919 BPF_ALU32_REG(BPF_ADD, R0, R1),
920 BPF_ALU32_REG(BPF_ADD, R0, R2),
921 BPF_ALU32_REG(BPF_ADD, R0, R3),
922 BPF_ALU32_REG(BPF_ADD, R0, R4),
923 BPF_ALU32_REG(BPF_ADD, R0, R5),
924 BPF_ALU32_REG(BPF_ADD, R0, R6),
925 BPF_ALU32_REG(BPF_ADD, R0, R7),
926 BPF_ALU32_REG(BPF_ADD, R0, R8),
927 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
928 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
930 BPF_ALU32_REG(BPF_ADD, R1, R0),
931 BPF_ALU32_REG(BPF_ADD, R1, R1),
932 BPF_ALU32_REG(BPF_ADD, R1, R2),
933 BPF_ALU32_REG(BPF_ADD, R1, R3),
934 BPF_ALU32_REG(BPF_ADD, R1, R4),
935 BPF_ALU32_REG(BPF_ADD, R1, R5),
936 BPF_ALU32_REG(BPF_ADD, R1, R6),
937 BPF_ALU32_REG(BPF_ADD, R1, R7),
938 BPF_ALU32_REG(BPF_ADD, R1, R8),
939 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
940 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
942 BPF_ALU32_REG(BPF_ADD, R2, R0),
943 BPF_ALU32_REG(BPF_ADD, R2, R1),
944 BPF_ALU32_REG(BPF_ADD, R2, R2),
945 BPF_ALU32_REG(BPF_ADD, R2, R3),
946 BPF_ALU32_REG(BPF_ADD, R2, R4),
947 BPF_ALU32_REG(BPF_ADD, R2, R5),
948 BPF_ALU32_REG(BPF_ADD, R2, R6),
949 BPF_ALU32_REG(BPF_ADD, R2, R7),
950 BPF_ALU32_REG(BPF_ADD, R2, R8),
951 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
952 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
954 BPF_ALU32_REG(BPF_ADD, R3, R0),
955 BPF_ALU32_REG(BPF_ADD, R3, R1),
956 BPF_ALU32_REG(BPF_ADD, R3, R2),
957 BPF_ALU32_REG(BPF_ADD, R3, R3),
958 BPF_ALU32_REG(BPF_ADD, R3, R4),
959 BPF_ALU32_REG(BPF_ADD, R3, R5),
960 BPF_ALU32_REG(BPF_ADD, R3, R6),
961 BPF_ALU32_REG(BPF_ADD, R3, R7),
962 BPF_ALU32_REG(BPF_ADD, R3, R8),
963 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
964 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
966 BPF_ALU32_REG(BPF_ADD, R4, R0),
967 BPF_ALU32_REG(BPF_ADD, R4, R1),
968 BPF_ALU32_REG(BPF_ADD, R4, R2),
969 BPF_ALU32_REG(BPF_ADD, R4, R3),
970 BPF_ALU32_REG(BPF_ADD, R4, R4),
971 BPF_ALU32_REG(BPF_ADD, R4, R5),
972 BPF_ALU32_REG(BPF_ADD, R4, R6),
973 BPF_ALU32_REG(BPF_ADD, R4, R7),
974 BPF_ALU32_REG(BPF_ADD, R4, R8),
975 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
976 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
978 BPF_ALU32_REG(BPF_ADD, R5, R0),
979 BPF_ALU32_REG(BPF_ADD, R5, R1),
980 BPF_ALU32_REG(BPF_ADD, R5, R2),
981 BPF_ALU32_REG(BPF_ADD, R5, R3),
982 BPF_ALU32_REG(BPF_ADD, R5, R4),
983 BPF_ALU32_REG(BPF_ADD, R5, R5),
984 BPF_ALU32_REG(BPF_ADD, R5, R6),
985 BPF_ALU32_REG(BPF_ADD, R5, R7),
986 BPF_ALU32_REG(BPF_ADD, R5, R8),
987 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
988 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
990 BPF_ALU32_REG(BPF_ADD, R6, R0),
991 BPF_ALU32_REG(BPF_ADD, R6, R1),
992 BPF_ALU32_REG(BPF_ADD, R6, R2),
993 BPF_ALU32_REG(BPF_ADD, R6, R3),
994 BPF_ALU32_REG(BPF_ADD, R6, R4),
995 BPF_ALU32_REG(BPF_ADD, R6, R5),
996 BPF_ALU32_REG(BPF_ADD, R6, R6),
997 BPF_ALU32_REG(BPF_ADD, R6, R7),
998 BPF_ALU32_REG(BPF_ADD, R6, R8),
999 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1000 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1002 BPF_ALU32_REG(BPF_ADD, R7, R0),
1003 BPF_ALU32_REG(BPF_ADD, R7, R1),
1004 BPF_ALU32_REG(BPF_ADD, R7, R2),
1005 BPF_ALU32_REG(BPF_ADD, R7, R3),
1006 BPF_ALU32_REG(BPF_ADD, R7, R4),
1007 BPF_ALU32_REG(BPF_ADD, R7, R5),
1008 BPF_ALU32_REG(BPF_ADD, R7, R6),
1009 BPF_ALU32_REG(BPF_ADD, R7, R7),
1010 BPF_ALU32_REG(BPF_ADD, R7, R8),
1011 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1012 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1014 BPF_ALU32_REG(BPF_ADD, R8, R0),
1015 BPF_ALU32_REG(BPF_ADD, R8, R1),
1016 BPF_ALU32_REG(BPF_ADD, R8, R2),
1017 BPF_ALU32_REG(BPF_ADD, R8, R3),
1018 BPF_ALU32_REG(BPF_ADD, R8, R4),
1019 BPF_ALU32_REG(BPF_ADD, R8, R5),
1020 BPF_ALU32_REG(BPF_ADD, R8, R6),
1021 BPF_ALU32_REG(BPF_ADD, R8, R7),
1022 BPF_ALU32_REG(BPF_ADD, R8, R8),
1023 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1024 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1026 BPF_ALU32_REG(BPF_ADD, R9, R0),
1027 BPF_ALU32_REG(BPF_ADD, R9, R1),
1028 BPF_ALU32_REG(BPF_ADD, R9, R2),
1029 BPF_ALU32_REG(BPF_ADD, R9, R3),
1030 BPF_ALU32_REG(BPF_ADD, R9, R4),
1031 BPF_ALU32_REG(BPF_ADD, R9, R5),
1032 BPF_ALU32_REG(BPF_ADD, R9, R6),
1033 BPF_ALU32_REG(BPF_ADD, R9, R7),
1034 BPF_ALU32_REG(BPF_ADD, R9, R8),
1035 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1036 BPF_ALU32_REG(BPF_MOV, R0, R9),
1043 { /* Mainly checking JIT here. */
1046 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1047 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1048 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1049 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1050 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1051 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1052 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1053 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1054 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1055 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1056 BPF_ALU64_REG(BPF_SUB, R0, R0),
1057 BPF_ALU64_REG(BPF_SUB, R0, R1),
1058 BPF_ALU64_REG(BPF_SUB, R0, R2),
1059 BPF_ALU64_REG(BPF_SUB, R0, R3),
1060 BPF_ALU64_REG(BPF_SUB, R0, R4),
1061 BPF_ALU64_REG(BPF_SUB, R0, R5),
1062 BPF_ALU64_REG(BPF_SUB, R0, R6),
1063 BPF_ALU64_REG(BPF_SUB, R0, R7),
1064 BPF_ALU64_REG(BPF_SUB, R0, R8),
1065 BPF_ALU64_REG(BPF_SUB, R0, R9),
1066 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1067 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1069 BPF_ALU64_REG(BPF_SUB, R1, R0),
1070 BPF_ALU64_REG(BPF_SUB, R1, R2),
1071 BPF_ALU64_REG(BPF_SUB, R1, R3),
1072 BPF_ALU64_REG(BPF_SUB, R1, R4),
1073 BPF_ALU64_REG(BPF_SUB, R1, R5),
1074 BPF_ALU64_REG(BPF_SUB, R1, R6),
1075 BPF_ALU64_REG(BPF_SUB, R1, R7),
1076 BPF_ALU64_REG(BPF_SUB, R1, R8),
1077 BPF_ALU64_REG(BPF_SUB, R1, R9),
1078 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1079 BPF_ALU64_REG(BPF_SUB, R2, R0),
1080 BPF_ALU64_REG(BPF_SUB, R2, R1),
1081 BPF_ALU64_REG(BPF_SUB, R2, R3),
1082 BPF_ALU64_REG(BPF_SUB, R2, R4),
1083 BPF_ALU64_REG(BPF_SUB, R2, R5),
1084 BPF_ALU64_REG(BPF_SUB, R2, R6),
1085 BPF_ALU64_REG(BPF_SUB, R2, R7),
1086 BPF_ALU64_REG(BPF_SUB, R2, R8),
1087 BPF_ALU64_REG(BPF_SUB, R2, R9),
1088 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1089 BPF_ALU64_REG(BPF_SUB, R3, R0),
1090 BPF_ALU64_REG(BPF_SUB, R3, R1),
1091 BPF_ALU64_REG(BPF_SUB, R3, R2),
1092 BPF_ALU64_REG(BPF_SUB, R3, R4),
1093 BPF_ALU64_REG(BPF_SUB, R3, R5),
1094 BPF_ALU64_REG(BPF_SUB, R3, R6),
1095 BPF_ALU64_REG(BPF_SUB, R3, R7),
1096 BPF_ALU64_REG(BPF_SUB, R3, R8),
1097 BPF_ALU64_REG(BPF_SUB, R3, R9),
1098 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1099 BPF_ALU64_REG(BPF_SUB, R4, R0),
1100 BPF_ALU64_REG(BPF_SUB, R4, R1),
1101 BPF_ALU64_REG(BPF_SUB, R4, R2),
1102 BPF_ALU64_REG(BPF_SUB, R4, R3),
1103 BPF_ALU64_REG(BPF_SUB, R4, R5),
1104 BPF_ALU64_REG(BPF_SUB, R4, R6),
1105 BPF_ALU64_REG(BPF_SUB, R4, R7),
1106 BPF_ALU64_REG(BPF_SUB, R4, R8),
1107 BPF_ALU64_REG(BPF_SUB, R4, R9),
1108 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1109 BPF_ALU64_REG(BPF_SUB, R5, R0),
1110 BPF_ALU64_REG(BPF_SUB, R5, R1),
1111 BPF_ALU64_REG(BPF_SUB, R5, R2),
1112 BPF_ALU64_REG(BPF_SUB, R5, R3),
1113 BPF_ALU64_REG(BPF_SUB, R5, R4),
1114 BPF_ALU64_REG(BPF_SUB, R5, R6),
1115 BPF_ALU64_REG(BPF_SUB, R5, R7),
1116 BPF_ALU64_REG(BPF_SUB, R5, R8),
1117 BPF_ALU64_REG(BPF_SUB, R5, R9),
1118 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1119 BPF_ALU64_REG(BPF_SUB, R6, R0),
1120 BPF_ALU64_REG(BPF_SUB, R6, R1),
1121 BPF_ALU64_REG(BPF_SUB, R6, R2),
1122 BPF_ALU64_REG(BPF_SUB, R6, R3),
1123 BPF_ALU64_REG(BPF_SUB, R6, R4),
1124 BPF_ALU64_REG(BPF_SUB, R6, R5),
1125 BPF_ALU64_REG(BPF_SUB, R6, R7),
1126 BPF_ALU64_REG(BPF_SUB, R6, R8),
1127 BPF_ALU64_REG(BPF_SUB, R6, R9),
1128 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1129 BPF_ALU64_REG(BPF_SUB, R7, R0),
1130 BPF_ALU64_REG(BPF_SUB, R7, R1),
1131 BPF_ALU64_REG(BPF_SUB, R7, R2),
1132 BPF_ALU64_REG(BPF_SUB, R7, R3),
1133 BPF_ALU64_REG(BPF_SUB, R7, R4),
1134 BPF_ALU64_REG(BPF_SUB, R7, R5),
1135 BPF_ALU64_REG(BPF_SUB, R7, R6),
1136 BPF_ALU64_REG(BPF_SUB, R7, R8),
1137 BPF_ALU64_REG(BPF_SUB, R7, R9),
1138 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1139 BPF_ALU64_REG(BPF_SUB, R8, R0),
1140 BPF_ALU64_REG(BPF_SUB, R8, R1),
1141 BPF_ALU64_REG(BPF_SUB, R8, R2),
1142 BPF_ALU64_REG(BPF_SUB, R8, R3),
1143 BPF_ALU64_REG(BPF_SUB, R8, R4),
1144 BPF_ALU64_REG(BPF_SUB, R8, R5),
1145 BPF_ALU64_REG(BPF_SUB, R8, R6),
1146 BPF_ALU64_REG(BPF_SUB, R8, R7),
1147 BPF_ALU64_REG(BPF_SUB, R8, R9),
1148 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1149 BPF_ALU64_REG(BPF_SUB, R9, R0),
1150 BPF_ALU64_REG(BPF_SUB, R9, R1),
1151 BPF_ALU64_REG(BPF_SUB, R9, R2),
1152 BPF_ALU64_REG(BPF_SUB, R9, R3),
1153 BPF_ALU64_REG(BPF_SUB, R9, R4),
1154 BPF_ALU64_REG(BPF_SUB, R9, R5),
1155 BPF_ALU64_REG(BPF_SUB, R9, R6),
1156 BPF_ALU64_REG(BPF_SUB, R9, R7),
1157 BPF_ALU64_REG(BPF_SUB, R9, R8),
1158 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1159 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1160 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1161 BPF_ALU64_REG(BPF_SUB, R0, R1),
1162 BPF_ALU64_REG(BPF_SUB, R0, R2),
1163 BPF_ALU64_REG(BPF_SUB, R0, R3),
1164 BPF_ALU64_REG(BPF_SUB, R0, R4),
1165 BPF_ALU64_REG(BPF_SUB, R0, R5),
1166 BPF_ALU64_REG(BPF_SUB, R0, R6),
1167 BPF_ALU64_REG(BPF_SUB, R0, R7),
1168 BPF_ALU64_REG(BPF_SUB, R0, R8),
1169 BPF_ALU64_REG(BPF_SUB, R0, R9),
1176 { /* Mainly checking JIT here. */
1179 BPF_ALU64_REG(BPF_SUB, R0, R0),
1180 BPF_ALU64_REG(BPF_XOR, R1, R1),
1181 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1183 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1184 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1185 BPF_ALU64_REG(BPF_SUB, R1, R1),
1186 BPF_ALU64_REG(BPF_XOR, R2, R2),
1187 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1189 BPF_ALU64_REG(BPF_SUB, R2, R2),
1190 BPF_ALU64_REG(BPF_XOR, R3, R3),
1191 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1192 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1193 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1195 BPF_ALU64_REG(BPF_SUB, R3, R3),
1196 BPF_ALU64_REG(BPF_XOR, R4, R4),
1197 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1198 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1199 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1201 BPF_ALU64_REG(BPF_SUB, R4, R4),
1202 BPF_ALU64_REG(BPF_XOR, R5, R5),
1203 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1204 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1205 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1207 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1208 BPF_ALU64_REG(BPF_SUB, R5, R5),
1209 BPF_ALU64_REG(BPF_XOR, R6, R6),
1210 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1211 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1212 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1214 BPF_ALU64_REG(BPF_SUB, R6, R6),
1215 BPF_ALU64_REG(BPF_XOR, R7, R7),
1216 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1218 BPF_ALU64_REG(BPF_SUB, R7, R7),
1219 BPF_ALU64_REG(BPF_XOR, R8, R8),
1220 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1222 BPF_ALU64_REG(BPF_SUB, R8, R8),
1223 BPF_ALU64_REG(BPF_XOR, R9, R9),
1224 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1226 BPF_ALU64_REG(BPF_SUB, R9, R9),
1227 BPF_ALU64_REG(BPF_XOR, R0, R0),
1228 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1230 BPF_ALU64_REG(BPF_SUB, R1, R1),
1231 BPF_ALU64_REG(BPF_XOR, R0, R0),
1232 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1233 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1235 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1242 { /* Mainly checking JIT here. */
1245 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1246 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1247 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1248 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1249 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1250 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1251 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1252 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1253 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1254 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1255 BPF_ALU64_REG(BPF_MUL, R0, R0),
1256 BPF_ALU64_REG(BPF_MUL, R0, R1),
1257 BPF_ALU64_REG(BPF_MUL, R0, R2),
1258 BPF_ALU64_REG(BPF_MUL, R0, R3),
1259 BPF_ALU64_REG(BPF_MUL, R0, R4),
1260 BPF_ALU64_REG(BPF_MUL, R0, R5),
1261 BPF_ALU64_REG(BPF_MUL, R0, R6),
1262 BPF_ALU64_REG(BPF_MUL, R0, R7),
1263 BPF_ALU64_REG(BPF_MUL, R0, R8),
1264 BPF_ALU64_REG(BPF_MUL, R0, R9),
1265 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1266 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1268 BPF_ALU64_REG(BPF_MUL, R1, R0),
1269 BPF_ALU64_REG(BPF_MUL, R1, R2),
1270 BPF_ALU64_REG(BPF_MUL, R1, R3),
1271 BPF_ALU64_REG(BPF_MUL, R1, R4),
1272 BPF_ALU64_REG(BPF_MUL, R1, R5),
1273 BPF_ALU64_REG(BPF_MUL, R1, R6),
1274 BPF_ALU64_REG(BPF_MUL, R1, R7),
1275 BPF_ALU64_REG(BPF_MUL, R1, R8),
1276 BPF_ALU64_REG(BPF_MUL, R1, R9),
1277 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1278 BPF_ALU64_REG(BPF_MOV, R2, R1),
1279 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1280 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1282 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1283 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1284 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1286 BPF_ALU64_REG(BPF_MUL, R2, R0),
1287 BPF_ALU64_REG(BPF_MUL, R2, R1),
1288 BPF_ALU64_REG(BPF_MUL, R2, R3),
1289 BPF_ALU64_REG(BPF_MUL, R2, R4),
1290 BPF_ALU64_REG(BPF_MUL, R2, R5),
1291 BPF_ALU64_REG(BPF_MUL, R2, R6),
1292 BPF_ALU64_REG(BPF_MUL, R2, R7),
1293 BPF_ALU64_REG(BPF_MUL, R2, R8),
1294 BPF_ALU64_REG(BPF_MUL, R2, R9),
1295 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1296 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1297 BPF_ALU64_REG(BPF_MOV, R0, R2),
1302 { { 0, 0x35d97ef2 } }
1307 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1308 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1309 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1310 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1311 BPF_ALU64_REG(BPF_DIV, R0, R2),
1312 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1314 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1315 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1317 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1327 BPF_ALU64_REG(BPF_MOV, R6, R1),
1328 BPF_LD_ABS(BPF_B, 3),
1329 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1330 BPF_ALU32_REG(BPF_DIV, R0, R2),
1331 BPF_ALU64_REG(BPF_MOV, R8, R0),
1332 BPF_LD_ABS(BPF_B, 4),
1333 BPF_ALU64_REG(BPF_ADD, R8, R0),
1334 BPF_LD_IND(BPF_B, R8, -70),
1338 { 10, 20, 30, 40, 50 },
1339 { { 4, 0 }, { 5, 10 } }
1344 BPF_ALU64_REG(BPF_MOV, R6, R1),
1345 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1346 BPF_LD_ABS(BPF_B, 3),
1347 BPF_ALU32_REG(BPF_DIV, R0, R7),
1351 { 10, 20, 30, 40, 50 },
1352 { { 3, 0 }, { 4, 0 } }
1355 "check: missing ret",
1357 BPF_STMT(BPF_LD | BPF_IMM, 1),
1359 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1366 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1367 BPF_STMT(BPF_RET | BPF_K, 0)
1369 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1374 "check: unknown insn",
1376 /* seccomp insn, rejected in socket filter */
1377 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1378 BPF_STMT(BPF_RET | BPF_K, 0)
1380 CLASSIC | FLAG_EXPECTED_FAIL,
1385 "check: out of range spill/fill",
1387 BPF_STMT(BPF_STX, 16),
1388 BPF_STMT(BPF_RET | BPF_K, 0)
1390 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1397 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1398 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
1399 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1400 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1401 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1402 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1403 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1404 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1405 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1406 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1407 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1408 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1409 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1410 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1411 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1412 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
1413 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1414 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
1415 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1416 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1417 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1418 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1419 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1420 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1421 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1422 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1423 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1424 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1425 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1426 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1427 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1428 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1429 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1430 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1431 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
1432 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
1433 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1434 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1435 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1436 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1437 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1438 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1439 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1440 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1441 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1442 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1443 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1444 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1445 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1446 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1447 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1448 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1449 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
1450 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
1451 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1452 BPF_STMT(BPF_RET | BPF_A, 0),
1453 BPF_STMT(BPF_RET | BPF_A, 0),
1456 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 0x90, 0xe2,
1457 0xba, 0x0a, 0x56, 0xb4, 0x08, 0x00, 0x45, 0x00,
1458 0x00, 0x28, 0x00, 0x00, 0x20, 0x00, 0x40, 0x11,
1459 0x00, 0x00, 0xc0, 0xa8, 0x33, 0x01, 0xc0, 0xa8,
1460 0x33, 0x02, 0xbb, 0xb6, 0xa9, 0xfa, 0x00, 0x14,
1461 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1462 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1463 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1464 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1465 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1466 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc },
1472 BPF_STMT(BPF_RET | BPF_X, 0),
1474 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1479 "check: LDX + RET X",
1481 BPF_STMT(BPF_LDX | BPF_IMM, 42),
1482 BPF_STMT(BPF_RET | BPF_X, 0),
1484 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1490 static struct net_device dev;
1492 static struct sk_buff *populate_skb(char *buf, int size)
1494 struct sk_buff *skb;
1496 if (size >= MAX_DATA)
1499 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
1503 memcpy(__skb_put(skb, size), buf, size);
1505 /* Initialize a fake skb with test pattern. */
1506 skb_reset_mac_header(skb);
1507 skb->protocol = htons(ETH_P_IP);
1508 skb->pkt_type = SKB_TYPE;
1509 skb->mark = SKB_MARK;
1510 skb->hash = SKB_HASH;
1511 skb->queue_mapping = SKB_QUEUE_MAP;
1512 skb->vlan_tci = SKB_VLAN_TCI;
1514 skb->dev->ifindex = SKB_DEV_IFINDEX;
1515 skb->dev->type = SKB_DEV_TYPE;
1516 skb_set_network_header(skb, min(size, ETH_HLEN));
1521 static void *generate_test_data(struct bpf_test *test, int sub)
1523 if (test->aux & FLAG_NO_DATA)
1526 /* Test case expects an skb, so populate one. Various
1527 * subtests generate skbs of different sizes based on
1530 return populate_skb(test->data, test->test[sub].data_size);
1533 static void release_test_data(const struct bpf_test *test, void *data)
1535 if (test->aux & FLAG_NO_DATA)
1541 static int probe_filter_length(struct sock_filter *fp)
1545 while (fp->code != 0 || fp->k != 0) {
1553 static struct sk_filter *generate_filter(int which, int *err)
1555 struct sk_filter *fp;
1556 struct sock_fprog_kern fprog;
1557 unsigned int flen = probe_filter_length(tests[which].u.insns);
1558 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
1560 switch (test_type) {
1562 fprog.filter = tests[which].u.insns;
1565 *err = sk_unattached_filter_create(&fp, &fprog);
1566 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
1567 if (*err == -EINVAL) {
1569 /* Verifier rejected filter as expected. */
1573 pr_cont("UNEXPECTED_PASS\n");
1574 /* Verifier didn't reject the test that's
1575 * bad enough, just return!
1581 /* We don't expect to fail. */
1583 pr_cont("FAIL to attach err=%d len=%d\n",
1590 fp = kzalloc(sk_filter_size(flen), GFP_KERNEL);
1592 pr_cont("UNEXPECTED_FAIL no memory left\n");
1598 memcpy(fp->insnsi, tests[which].u.insns_int,
1599 fp->len * sizeof(struct sock_filter_int));
1601 sk_filter_select_runtime(fp);
1609 static void release_filter(struct sk_filter *fp, int which)
1611 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
1613 switch (test_type) {
1615 sk_unattached_filter_destroy(fp);
1623 static int __run_one(const struct sk_filter *fp, const void *data,
1624 int runs, u64 *duration)
1629 start = ktime_to_us(ktime_get());
1631 for (i = 0; i < runs; i++)
1632 ret = SK_RUN_FILTER(fp, data);
1634 finish = ktime_to_us(ktime_get());
1636 *duration = (finish - start) * 1000ULL;
1637 do_div(*duration, runs);
1642 static int run_one(const struct sk_filter *fp, struct bpf_test *test)
1644 int err_cnt = 0, i, runs = MAX_TESTRUNS;
1646 for (i = 0; i < MAX_SUBTESTS; i++) {
1651 if (test->test[i].data_size == 0 &&
1652 test->test[i].result == 0)
1655 data = generate_test_data(test, i);
1656 ret = __run_one(fp, data, runs, &duration);
1657 release_test_data(test, data);
1659 if (ret == test->test[i].result) {
1660 pr_cont("%lld ", duration);
1662 pr_cont("ret %d != %d ", ret,
1663 test->test[i].result);
1671 static __init int test_bpf(void)
1673 int i, err_cnt = 0, pass_cnt = 0;
1675 for (i = 0; i < ARRAY_SIZE(tests); i++) {
1676 struct sk_filter *fp;
1679 pr_info("#%d %s ", i, tests[i].descr);
1681 fp = generate_filter(i, &err);
1690 err = run_one(fp, &tests[i]);
1691 release_filter(fp, i);
1694 pr_cont("FAIL (%d times)\n", err);
1702 pr_info("Summary: %d PASSED, %d FAILED\n", pass_cnt, err_cnt);
1703 return err_cnt ? -EINVAL : 0;
1706 static int __init test_bpf_init(void)
1711 static void __exit test_bpf_exit(void)
1715 module_init(test_bpf_init);
1716 module_exit(test_bpf_exit);
1718 MODULE_LICENSE("GPL");