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