Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 08fcb08fc06758411d099bcd6a60d6cdee2d50a7 / . / lib / test_bpf.c
blob: e6ef56df0dfea35a95f2d8bc8c6028b4bcd61a87 [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 },
1688 {
1689 "INT: ALU MIX",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1690 .u.insns_int = {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1691 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1692 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1693 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1694 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1695 BPF_ALU64_REG(BPF_DIV, R0, R2),
1696 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1697 BPF_EXIT_INSN(),
1698 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1699 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1700 BPF_EXIT_INSN(),
1701 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1702 BPF_EXIT_INSN(),
1703 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1704 INTERNAL,
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1705 { },
1706 { { 0, -1 } }
1707 },
1708 {
Alexei Starovoitov72b603e2014-08-25 12:27:02 -0700[diff] [blame]1709 "INT: shifts by register",
1710 .u.insns_int = {
1711 BPF_MOV64_IMM(R0, -1234),
1712 BPF_MOV64_IMM(R1, 1),
1713 BPF_ALU32_REG(BPF_RSH, R0, R1),
1714 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1715 BPF_EXIT_INSN(),
1716 BPF_MOV64_IMM(R2, 1),
1717 BPF_ALU64_REG(BPF_LSH, R0, R2),
1718 BPF_MOV32_IMM(R4, -1234),
1719 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1720 BPF_EXIT_INSN(),
1721 BPF_ALU64_IMM(BPF_AND, R4, 63),
1722 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1723 BPF_MOV64_IMM(R3, 47),
1724 BPF_ALU64_REG(BPF_ARSH, R0, R3),
1725 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1726 BPF_EXIT_INSN(),
1727 BPF_MOV64_IMM(R2, 1),
1728 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1729 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1730 BPF_EXIT_INSN(),
1731 BPF_MOV64_IMM(R4, 4),
1732 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1733 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1734 BPF_EXIT_INSN(),
1735 BPF_MOV64_IMM(R4, 5),
1736 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1737 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1738 BPF_EXIT_INSN(),
1739 BPF_MOV64_IMM(R0, -1),
1740 BPF_EXIT_INSN(),
1741 },
1742 INTERNAL,
1743 { },
1744 { { 0, -1 } }
1745 },
1746 {
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1747 "INT: DIV + ABS",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1748 .u.insns_int = {
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1749 BPF_ALU64_REG(BPF_MOV, R6, R1),
1750 BPF_LD_ABS(BPF_B, 3),
1751 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1752 BPF_ALU32_REG(BPF_DIV, R0, R2),
1753 BPF_ALU64_REG(BPF_MOV, R8, R0),
1754 BPF_LD_ABS(BPF_B, 4),
1755 BPF_ALU64_REG(BPF_ADD, R8, R0),
1756 BPF_LD_IND(BPF_B, R8, -70),
1757 BPF_EXIT_INSN(),
1758 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1759 INTERNAL,
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1760 { 10, 20, 30, 40, 50 },
1761 { { 4, 0 }, { 5, 10 } }
1762 },
1763 {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1764 "INT: DIV by zero",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1765 .u.insns_int = {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1766 BPF_ALU64_REG(BPF_MOV, R6, R1),
1767 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1768 BPF_LD_ABS(BPF_B, 3),
1769 BPF_ALU32_REG(BPF_DIV, R0, R7),
1770 BPF_EXIT_INSN(),
1771 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1772 INTERNAL,
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1773 { 10, 20, 30, 40, 50 },
1774 { { 3, 0 }, { 4, 0 } }
1775 },
1776 {
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1777 "check: missing ret",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1778 .u.insns = {
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1779 BPF_STMT(BPF_LD | BPF_IMM, 1),
1780 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1781 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]1782 { },
1783 { }
1784 },
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1785 {
1786 "check: div_k_0",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1787 .u.insns = {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1788 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1789 BPF_STMT(BPF_RET | BPF_K, 0)
1790 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1791 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1792 { },
1793 { }
1794 },
1795 {
1796 "check: unknown insn",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1797 .u.insns = {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1798 /* seccomp insn, rejected in socket filter */
1799 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1800 BPF_STMT(BPF_RET | BPF_K, 0)
1801 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1802 CLASSIC | FLAG_EXPECTED_FAIL,
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1803 { },
1804 { }
1805 },
1806 {
1807 "check: out of range spill/fill",
Andrew Mortonece80492014-05-22 10:16:46 -0700[diff] [blame]1808 .u.insns = {
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1809 BPF_STMT(BPF_STX, 16),
1810 BPF_STMT(BPF_RET | BPF_K, 0)
1811 },
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]1812 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
Alexei Starovoitov9def6242014-05-08 14:10:53 -0700[diff] [blame]1813 { },
1814 { }
1815 },
Daniel Borkmann2e8a83c2014-05-23 18:44:01 +0200[diff] [blame]1816 {
1817 "JUMPS + HOLES",
1818 .u.insns = {
1819 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1820 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
1821 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1822 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1823 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1824 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1825 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1826 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1827 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1828 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1829 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1830 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1831 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1832 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1833 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1834 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
1835 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1836 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
1837 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1838 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1839 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1840 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1841 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1842 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1843 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1844 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1845 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1846 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1847 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1848 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1849 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1850 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1851 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1852 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1853 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
1854 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
1855 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1856 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
1857 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
1858 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1859 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1860 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1861 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1862 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1863 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1864 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1865 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1866 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1867 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1868 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1869 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1870 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1871 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
1872 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
1873 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
1874 BPF_STMT(BPF_RET | BPF_A, 0),
1875 BPF_STMT(BPF_RET | BPF_A, 0),
1876 },
1877 CLASSIC,
Daniel Borkmannce25b682014-05-26 20:17:35 +0200[diff] [blame]1878 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
1879 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
1880 0x08, 0x00,
1881 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
1882 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
1883 0xc0, 0xa8, 0x33, 0x01,
1884 0xc0, 0xa8, 0x33, 0x02,
1885 0xbb, 0xb6,
1886 0xa9, 0xfa,
1887 0x00, 0x14, 0x00, 0x00,
1888 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1889 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1890 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1891 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1892 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1893 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1894 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
1895 0xcc, 0xcc, 0xcc, 0xcc },
Daniel Borkmann2e8a83c2014-05-23 18:44:01 +0200[diff] [blame]1896 { { 88, 0x001b } }
1897 },
1898 {
1899 "check: RET X",
1900 .u.insns = {
1901 BPF_STMT(BPF_RET | BPF_X, 0),
1902 },
1903 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1904 { },
1905 { },
1906 },
1907 {
1908 "check: LDX + RET X",
1909 .u.insns = {
1910 BPF_STMT(BPF_LDX | BPF_IMM, 42),
1911 BPF_STMT(BPF_RET | BPF_X, 0),
1912 },
1913 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
1914 { },
1915 { },
1916 },
Daniel Borkmann108cc222014-05-26 20:17:34 +0200[diff] [blame]1917 { /* Mainly checking JIT here. */
Daniel Borkmann9fe13ba2014-05-29 10:22:48 +0200[diff] [blame]1918 "M[]: alt STX + LDX",
Daniel Borkmann108cc222014-05-26 20:17:34 +0200[diff] [blame]1919 .u.insns = {
1920 BPF_STMT(BPF_LDX | BPF_IMM, 100),
1921 BPF_STMT(BPF_STX, 0),
1922 BPF_STMT(BPF_LDX | BPF_MEM, 0),
1923 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1924 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1925 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1926 BPF_STMT(BPF_STX, 1),
1927 BPF_STMT(BPF_LDX | BPF_MEM, 1),
1928 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1929 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1930 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1931 BPF_STMT(BPF_STX, 2),
1932 BPF_STMT(BPF_LDX | BPF_MEM, 2),
1933 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1934 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1935 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1936 BPF_STMT(BPF_STX, 3),
1937 BPF_STMT(BPF_LDX | BPF_MEM, 3),
1938 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1939 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1940 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1941 BPF_STMT(BPF_STX, 4),
1942 BPF_STMT(BPF_LDX | BPF_MEM, 4),
1943 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1944 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1945 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1946 BPF_STMT(BPF_STX, 5),
1947 BPF_STMT(BPF_LDX | BPF_MEM, 5),
1948 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1949 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1950 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1951 BPF_STMT(BPF_STX, 6),
1952 BPF_STMT(BPF_LDX | BPF_MEM, 6),
1953 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1954 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1955 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1956 BPF_STMT(BPF_STX, 7),
1957 BPF_STMT(BPF_LDX | BPF_MEM, 7),
1958 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1959 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1960 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1961 BPF_STMT(BPF_STX, 8),
1962 BPF_STMT(BPF_LDX | BPF_MEM, 8),
1963 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1964 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1965 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1966 BPF_STMT(BPF_STX, 9),
1967 BPF_STMT(BPF_LDX | BPF_MEM, 9),
1968 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1969 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1970 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1971 BPF_STMT(BPF_STX, 10),
1972 BPF_STMT(BPF_LDX | BPF_MEM, 10),
1973 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1974 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1975 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1976 BPF_STMT(BPF_STX, 11),
1977 BPF_STMT(BPF_LDX | BPF_MEM, 11),
1978 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1979 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1980 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1981 BPF_STMT(BPF_STX, 12),
1982 BPF_STMT(BPF_LDX | BPF_MEM, 12),
1983 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1984 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1985 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1986 BPF_STMT(BPF_STX, 13),
1987 BPF_STMT(BPF_LDX | BPF_MEM, 13),
1988 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1989 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1990 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1991 BPF_STMT(BPF_STX, 14),
1992 BPF_STMT(BPF_LDX | BPF_MEM, 14),
1993 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1994 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
1995 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1996 BPF_STMT(BPF_STX, 15),
1997 BPF_STMT(BPF_LDX | BPF_MEM, 15),
1998 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1999 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2000 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2001 BPF_STMT(BPF_RET | BPF_A, 0),
2002 },
2003 CLASSIC | FLAG_NO_DATA,
2004 { },
2005 { { 0, 116 } },
2006 },
Daniel Borkmann9fe13ba2014-05-29 10:22:48 +0200[diff] [blame]2007 { /* Mainly checking JIT here. */
2008 "M[]: full STX + full LDX",
2009 .u.insns = {
2010 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2011 BPF_STMT(BPF_STX, 0),
2012 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2013 BPF_STMT(BPF_STX, 1),
2014 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2015 BPF_STMT(BPF_STX, 2),
2016 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2017 BPF_STMT(BPF_STX, 3),
2018 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2019 BPF_STMT(BPF_STX, 4),
2020 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2021 BPF_STMT(BPF_STX, 5),
2022 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2023 BPF_STMT(BPF_STX, 6),
2024 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2025 BPF_STMT(BPF_STX, 7),
2026 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2027 BPF_STMT(BPF_STX, 8),
2028 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2029 BPF_STMT(BPF_STX, 9),
2030 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2031 BPF_STMT(BPF_STX, 10),
2032 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2033 BPF_STMT(BPF_STX, 11),
2034 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2035 BPF_STMT(BPF_STX, 12),
2036 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2037 BPF_STMT(BPF_STX, 13),
2038 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2039 BPF_STMT(BPF_STX, 14),
2040 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2041 BPF_STMT(BPF_STX, 15),
2042 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2043 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2044 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2045 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2046 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2047 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2048 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2049 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2050 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2051 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2052 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2053 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2054 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2055 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2056 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2057 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2058 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2059 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2060 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2061 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2062 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2063 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2064 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2065 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2066 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2067 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2068 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2069 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2070 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2071 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2072 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2073 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2074 BPF_STMT(BPF_RET | BPF_A, 0),
2075 },
2076 CLASSIC | FLAG_NO_DATA,
2077 { },
2078 { { 0, 0x2a5a5e5 } },
2079 },
Daniel Borkmannd50bc152014-05-29 10:22:49 +0200[diff] [blame]2080 {
2081 "check: SKF_AD_MAX",
2082 .u.insns = {
2083 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2084 SKF_AD_OFF + SKF_AD_MAX),
2085 BPF_STMT(BPF_RET | BPF_A, 0),
2086 },
2087 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2088 { },
2089 { },
2090 },
2091 { /* Passes checker but fails during runtime. */
2092 "LD [SKF_AD_OFF-1]",
2093 .u.insns = {
2094 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2095 SKF_AD_OFF - 1),
2096 BPF_STMT(BPF_RET | BPF_K, 1),
2097 },
2098 CLASSIC,
2099 { },
2100 { { 1, 0 } },
2101 },
Alexei Starovoitov02ab6952014-09-04 22:17:17 -0700[diff] [blame]2102 {
2103 "load 64-bit immediate",
2104 .u.insns_int = {
Alexei Starovoitov25ee7322014-09-19 13:53:51 -0700[diff] [blame]2105 BPF_LD_IMM64(R1, 0x567800001234LL),
Alexei Starovoitov02ab6952014-09-04 22:17:17 -0700[diff] [blame]2106 BPF_MOV64_REG(R2, R1),
2107 BPF_MOV64_REG(R3, R2),
2108 BPF_ALU64_IMM(BPF_RSH, R2, 32),
2109 BPF_ALU64_IMM(BPF_LSH, R3, 32),
2110 BPF_ALU64_IMM(BPF_RSH, R3, 32),
2111 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2112 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2113 BPF_EXIT_INSN(),
2114 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2115 BPF_EXIT_INSN(),
Xi Wang986ccfd2015-05-09 04:14:30 -0400[diff] [blame]2116 BPF_LD_IMM64(R0, 0x1ffffffffLL),
2117 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
Alexei Starovoitov02ab6952014-09-04 22:17:17 -0700[diff] [blame]2118 BPF_EXIT_INSN(),
2119 },
2120 INTERNAL,
2121 { },
2122 { { 0, 1 } }
2123 },
Alexei Starovoitove21ab362014-10-28 15:11:43 -0700[diff] [blame]2124 {
2125 "nmap reduced",
2126 .u.insns_int = {
2127 BPF_MOV64_REG(R6, R1),
2128 BPF_LD_ABS(BPF_H, 12),
2129 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28),
2130 BPF_LD_ABS(BPF_H, 12),
2131 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26),
2132 BPF_MOV32_IMM(R0, 18),
2133 BPF_STX_MEM(BPF_W, R10, R0, -64),
2134 BPF_LDX_MEM(BPF_W, R7, R10, -64),
2135 BPF_LD_IND(BPF_W, R7, 14),
2136 BPF_STX_MEM(BPF_W, R10, R0, -60),
2137 BPF_MOV32_IMM(R0, 280971478),
2138 BPF_STX_MEM(BPF_W, R10, R0, -56),
2139 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2140 BPF_LDX_MEM(BPF_W, R0, R10, -60),
2141 BPF_ALU32_REG(BPF_SUB, R0, R7),
2142 BPF_JMP_IMM(BPF_JNE, R0, 0, 15),
2143 BPF_LD_ABS(BPF_H, 12),
2144 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13),
2145 BPF_MOV32_IMM(R0, 22),
2146 BPF_STX_MEM(BPF_W, R10, R0, -56),
2147 BPF_LDX_MEM(BPF_W, R7, R10, -56),
2148 BPF_LD_IND(BPF_H, R7, 14),
2149 BPF_STX_MEM(BPF_W, R10, R0, -52),
2150 BPF_MOV32_IMM(R0, 17366),
2151 BPF_STX_MEM(BPF_W, R10, R0, -48),
2152 BPF_LDX_MEM(BPF_W, R7, R10, -48),
2153 BPF_LDX_MEM(BPF_W, R0, R10, -52),
2154 BPF_ALU32_REG(BPF_SUB, R0, R7),
2155 BPF_JMP_IMM(BPF_JNE, R0, 0, 2),
2156 BPF_MOV32_IMM(R0, 256),
2157 BPF_EXIT_INSN(),
2158 BPF_MOV32_IMM(R0, 0),
2159 BPF_EXIT_INSN(),
2160 },
2161 INTERNAL,
2162 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0,
2163 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2164 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6},
2165 { { 38, 256 } }
2166 },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2167 /* BPF_ALU | BPF_MOV | BPF_X */
2168 {
2169 "ALU_MOV_X: dst = 2",
2170 .u.insns_int = {
2171 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2172 BPF_ALU32_REG(BPF_MOV, R0, R1),
2173 BPF_EXIT_INSN(),
2174 },
2175 INTERNAL,
2176 { },
2177 { { 0, 2 } },
2178 },
2179 {
2180 "ALU_MOV_X: dst = 4294967295",
2181 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2182 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2183 BPF_ALU32_REG(BPF_MOV, R0, R1),
2184 BPF_EXIT_INSN(),
2185 },
2186 INTERNAL,
2187 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2188 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2189 },
2190 {
2191 "ALU64_MOV_X: dst = 2",
2192 .u.insns_int = {
2193 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2194 BPF_ALU64_REG(BPF_MOV, R0, R1),
2195 BPF_EXIT_INSN(),
2196 },
2197 INTERNAL,
2198 { },
2199 { { 0, 2 } },
2200 },
2201 {
2202 "ALU64_MOV_X: dst = 4294967295",
2203 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2204 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2205 BPF_ALU64_REG(BPF_MOV, R0, R1),
2206 BPF_EXIT_INSN(),
2207 },
2208 INTERNAL,
2209 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2210 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2211 },
2212 /* BPF_ALU | BPF_MOV | BPF_K */
2213 {
2214 "ALU_MOV_K: dst = 2",
2215 .u.insns_int = {
2216 BPF_ALU32_IMM(BPF_MOV, R0, 2),
2217 BPF_EXIT_INSN(),
2218 },
2219 INTERNAL,
2220 { },
2221 { { 0, 2 } },
2222 },
2223 {
2224 "ALU_MOV_K: dst = 4294967295",
2225 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2226 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2227 BPF_EXIT_INSN(),
2228 },
2229 INTERNAL,
2230 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2231 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2232 },
2233 {
2234 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2235 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2236 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2237 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2238 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2239 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2240 BPF_MOV32_IMM(R0, 2),
2241 BPF_EXIT_INSN(),
2242 BPF_MOV32_IMM(R0, 1),
2243 BPF_EXIT_INSN(),
2244 },
2245 INTERNAL,
2246 { },
2247 { { 0, 0x1 } },
2248 },
2249 {
2250 "ALU64_MOV_K: dst = 2",
2251 .u.insns_int = {
2252 BPF_ALU64_IMM(BPF_MOV, R0, 2),
2253 BPF_EXIT_INSN(),
2254 },
2255 INTERNAL,
2256 { },
2257 { { 0, 2 } },
2258 },
2259 {
2260 "ALU64_MOV_K: dst = 2147483647",
2261 .u.insns_int = {
2262 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2263 BPF_EXIT_INSN(),
2264 },
2265 INTERNAL,
2266 { },
2267 { { 0, 2147483647 } },
2268 },
2269 {
2270 "ALU64_OR_K: dst = 0x0",
2271 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2272 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2273 BPF_LD_IMM64(R3, 0x0),
2274 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2275 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2276 BPF_MOV32_IMM(R0, 2),
2277 BPF_EXIT_INSN(),
2278 BPF_MOV32_IMM(R0, 1),
2279 BPF_EXIT_INSN(),
2280 },
2281 INTERNAL,
2282 { },
2283 { { 0, 0x1 } },
2284 },
2285 {
2286 "ALU64_MOV_K: dst = -1",
2287 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2288 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2289 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2290 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2291 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2292 BPF_MOV32_IMM(R0, 2),
2293 BPF_EXIT_INSN(),
2294 BPF_MOV32_IMM(R0, 1),
2295 BPF_EXIT_INSN(),
2296 },
2297 INTERNAL,
2298 { },
2299 { { 0, 0x1 } },
2300 },
2301 /* BPF_ALU | BPF_ADD | BPF_X */
2302 {
2303 "ALU_ADD_X: 1 + 2 = 3",
2304 .u.insns_int = {
2305 BPF_LD_IMM64(R0, 1),
2306 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2307 BPF_ALU32_REG(BPF_ADD, R0, R1),
2308 BPF_EXIT_INSN(),
2309 },
2310 INTERNAL,
2311 { },
2312 { { 0, 3 } },
2313 },
2314 {
2315 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2316 .u.insns_int = {
2317 BPF_LD_IMM64(R0, 1),
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2318 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2319 BPF_ALU32_REG(BPF_ADD, R0, R1),
2320 BPF_EXIT_INSN(),
2321 },
2322 INTERNAL,
2323 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2324 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2325 },
2326 {
2327 "ALU64_ADD_X: 1 + 2 = 3",
2328 .u.insns_int = {
2329 BPF_LD_IMM64(R0, 1),
2330 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2331 BPF_ALU64_REG(BPF_ADD, R0, R1),
2332 BPF_EXIT_INSN(),
2333 },
2334 INTERNAL,
2335 { },
2336 { { 0, 3 } },
2337 },
2338 {
2339 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2340 .u.insns_int = {
2341 BPF_LD_IMM64(R0, 1),
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2342 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2343 BPF_ALU64_REG(BPF_ADD, R0, R1),
2344 BPF_EXIT_INSN(),
2345 },
2346 INTERNAL,
2347 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2348 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2349 },
2350 /* BPF_ALU | BPF_ADD | BPF_K */
2351 {
2352 "ALU_ADD_K: 1 + 2 = 3",
2353 .u.insns_int = {
2354 BPF_LD_IMM64(R0, 1),
2355 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2356 BPF_EXIT_INSN(),
2357 },
2358 INTERNAL,
2359 { },
2360 { { 0, 3 } },
2361 },
2362 {
2363 "ALU_ADD_K: 3 + 0 = 3",
2364 .u.insns_int = {
2365 BPF_LD_IMM64(R0, 3),
2366 BPF_ALU32_IMM(BPF_ADD, R0, 0),
2367 BPF_EXIT_INSN(),
2368 },
2369 INTERNAL,
2370 { },
2371 { { 0, 3 } },
2372 },
2373 {
2374 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2375 .u.insns_int = {
2376 BPF_LD_IMM64(R0, 1),
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2377 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2378 BPF_EXIT_INSN(),
2379 },
2380 INTERNAL,
2381 { },
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2382 { { 0, 4294967295U } },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2383 },
2384 {
2385 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2386 .u.insns_int = {
2387 BPF_LD_IMM64(R2, 0x0),
2388 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2389 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2390 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2391 BPF_MOV32_IMM(R0, 2),
2392 BPF_EXIT_INSN(),
2393 BPF_MOV32_IMM(R0, 1),
2394 BPF_EXIT_INSN(),
2395 },
2396 INTERNAL,
2397 { },
2398 { { 0, 0x1 } },
2399 },
2400 {
2401 "ALU64_ADD_K: 1 + 2 = 3",
2402 .u.insns_int = {
2403 BPF_LD_IMM64(R0, 1),
2404 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2405 BPF_EXIT_INSN(),
2406 },
2407 INTERNAL,
2408 { },
2409 { { 0, 3 } },
2410 },
2411 {
2412 "ALU64_ADD_K: 3 + 0 = 3",
2413 .u.insns_int = {
2414 BPF_LD_IMM64(R0, 3),
2415 BPF_ALU64_IMM(BPF_ADD, R0, 0),
2416 BPF_EXIT_INSN(),
2417 },
2418 INTERNAL,
2419 { },
2420 { { 0, 3 } },
2421 },
2422 {
2423 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2424 .u.insns_int = {
2425 BPF_LD_IMM64(R0, 1),
2426 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2427 BPF_EXIT_INSN(),
2428 },
2429 INTERNAL,
2430 { },
2431 { { 0, 2147483647 } },
2432 },
2433 {
2434 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2435 .u.insns_int = {
2436 BPF_LD_IMM64(R0, 2147483646),
2437 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2438 BPF_EXIT_INSN(),
2439 },
2440 INTERNAL,
2441 { },
2442 { { 0, -1 } },
2443 },
2444 {
2445 "ALU64_ADD_K: 1 + 0 = 1",
2446 .u.insns_int = {
2447 BPF_LD_IMM64(R2, 0x1),
2448 BPF_LD_IMM64(R3, 0x1),
2449 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2450 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2451 BPF_MOV32_IMM(R0, 2),
2452 BPF_EXIT_INSN(),
2453 BPF_MOV32_IMM(R0, 1),
2454 BPF_EXIT_INSN(),
2455 },
2456 INTERNAL,
2457 { },
2458 { { 0, 0x1 } },
2459 },
2460 {
2461 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2462 .u.insns_int = {
2463 BPF_LD_IMM64(R2, 0x0),
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2464 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2465 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2466 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2467 BPF_MOV32_IMM(R0, 2),
2468 BPF_EXIT_INSN(),
2469 BPF_MOV32_IMM(R0, 1),
2470 BPF_EXIT_INSN(),
2471 },
2472 INTERNAL,
2473 { },
2474 { { 0, 0x1 } },
2475 },
2476 /* BPF_ALU | BPF_SUB | BPF_X */
2477 {
2478 "ALU_SUB_X: 3 - 1 = 2",
2479 .u.insns_int = {
2480 BPF_LD_IMM64(R0, 3),
2481 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2482 BPF_ALU32_REG(BPF_SUB, R0, R1),
2483 BPF_EXIT_INSN(),
2484 },
2485 INTERNAL,
2486 { },
2487 { { 0, 2 } },
2488 },
2489 {
2490 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
2491 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2492 BPF_LD_IMM64(R0, 4294967295U),
2493 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2494 BPF_ALU32_REG(BPF_SUB, R0, R1),
2495 BPF_EXIT_INSN(),
2496 },
2497 INTERNAL,
2498 { },
2499 { { 0, 1 } },
2500 },
2501 {
2502 "ALU64_SUB_X: 3 - 1 = 2",
2503 .u.insns_int = {
2504 BPF_LD_IMM64(R0, 3),
2505 BPF_ALU32_IMM(BPF_MOV, R1, 1),
2506 BPF_ALU64_REG(BPF_SUB, R0, R1),
2507 BPF_EXIT_INSN(),
2508 },
2509 INTERNAL,
2510 { },
2511 { { 0, 2 } },
2512 },
2513 {
2514 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
2515 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2516 BPF_LD_IMM64(R0, 4294967295U),
2517 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2518 BPF_ALU64_REG(BPF_SUB, R0, R1),
2519 BPF_EXIT_INSN(),
2520 },
2521 INTERNAL,
2522 { },
2523 { { 0, 1 } },
2524 },
2525 /* BPF_ALU | BPF_SUB | BPF_K */
2526 {
2527 "ALU_SUB_K: 3 - 1 = 2",
2528 .u.insns_int = {
2529 BPF_LD_IMM64(R0, 3),
2530 BPF_ALU32_IMM(BPF_SUB, R0, 1),
2531 BPF_EXIT_INSN(),
2532 },
2533 INTERNAL,
2534 { },
2535 { { 0, 2 } },
2536 },
2537 {
2538 "ALU_SUB_K: 3 - 0 = 3",
2539 .u.insns_int = {
2540 BPF_LD_IMM64(R0, 3),
2541 BPF_ALU32_IMM(BPF_SUB, R0, 0),
2542 BPF_EXIT_INSN(),
2543 },
2544 INTERNAL,
2545 { },
2546 { { 0, 3 } },
2547 },
2548 {
2549 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
2550 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2551 BPF_LD_IMM64(R0, 4294967295U),
2552 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2553 BPF_EXIT_INSN(),
2554 },
2555 INTERNAL,
2556 { },
2557 { { 0, 1 } },
2558 },
2559 {
2560 "ALU64_SUB_K: 3 - 1 = 2",
2561 .u.insns_int = {
2562 BPF_LD_IMM64(R0, 3),
2563 BPF_ALU64_IMM(BPF_SUB, R0, 1),
2564 BPF_EXIT_INSN(),
2565 },
2566 INTERNAL,
2567 { },
2568 { { 0, 2 } },
2569 },
2570 {
2571 "ALU64_SUB_K: 3 - 0 = 3",
2572 .u.insns_int = {
2573 BPF_LD_IMM64(R0, 3),
2574 BPF_ALU64_IMM(BPF_SUB, R0, 0),
2575 BPF_EXIT_INSN(),
2576 },
2577 INTERNAL,
2578 { },
2579 { { 0, 3 } },
2580 },
2581 {
2582 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
2583 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2584 BPF_LD_IMM64(R0, 4294967294U),
2585 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2586 BPF_EXIT_INSN(),
2587 },
2588 INTERNAL,
2589 { },
2590 { { 0, -1 } },
2591 },
2592 {
2593 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
2594 .u.insns_int = {
2595 BPF_LD_IMM64(R0, 2147483646),
2596 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
2597 BPF_EXIT_INSN(),
2598 },
2599 INTERNAL,
2600 { },
2601 { { 0, -1 } },
2602 },
2603 /* BPF_ALU | BPF_MUL | BPF_X */
2604 {
2605 "ALU_MUL_X: 2 * 3 = 6",
2606 .u.insns_int = {
2607 BPF_LD_IMM64(R0, 2),
2608 BPF_ALU32_IMM(BPF_MOV, R1, 3),
2609 BPF_ALU32_REG(BPF_MUL, R0, R1),
2610 BPF_EXIT_INSN(),
2611 },
2612 INTERNAL,
2613 { },
2614 { { 0, 6 } },
2615 },
2616 {
2617 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2618 .u.insns_int = {
2619 BPF_LD_IMM64(R0, 2),
2620 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
2621 BPF_ALU32_REG(BPF_MUL, R0, R1),
2622 BPF_EXIT_INSN(),
2623 },
2624 INTERNAL,
2625 { },
2626 { { 0, 0xFFFFFFF0 } },
2627 },
2628 {
2629 "ALU_MUL_X: -1 * -1 = 1",
2630 .u.insns_int = {
2631 BPF_LD_IMM64(R0, -1),
2632 BPF_ALU32_IMM(BPF_MOV, R1, -1),
2633 BPF_ALU32_REG(BPF_MUL, R0, R1),
2634 BPF_EXIT_INSN(),
2635 },
2636 INTERNAL,
2637 { },
2638 { { 0, 1 } },
2639 },
2640 {
2641 "ALU64_MUL_X: 2 * 3 = 6",
2642 .u.insns_int = {
2643 BPF_LD_IMM64(R0, 2),
2644 BPF_ALU32_IMM(BPF_MOV, R1, 3),
2645 BPF_ALU64_REG(BPF_MUL, R0, R1),
2646 BPF_EXIT_INSN(),
2647 },
2648 INTERNAL,
2649 { },
2650 { { 0, 6 } },
2651 },
2652 {
2653 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
2654 .u.insns_int = {
2655 BPF_LD_IMM64(R0, 1),
2656 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
2657 BPF_ALU64_REG(BPF_MUL, R0, R1),
2658 BPF_EXIT_INSN(),
2659 },
2660 INTERNAL,
2661 { },
2662 { { 0, 2147483647 } },
2663 },
2664 /* BPF_ALU | BPF_MUL | BPF_K */
2665 {
2666 "ALU_MUL_K: 2 * 3 = 6",
2667 .u.insns_int = {
2668 BPF_LD_IMM64(R0, 2),
2669 BPF_ALU32_IMM(BPF_MUL, R0, 3),
2670 BPF_EXIT_INSN(),
2671 },
2672 INTERNAL,
2673 { },
2674 { { 0, 6 } },
2675 },
2676 {
2677 "ALU_MUL_K: 3 * 1 = 3",
2678 .u.insns_int = {
2679 BPF_LD_IMM64(R0, 3),
2680 BPF_ALU32_IMM(BPF_MUL, R0, 1),
2681 BPF_EXIT_INSN(),
2682 },
2683 INTERNAL,
2684 { },
2685 { { 0, 3 } },
2686 },
2687 {
2688 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
2689 .u.insns_int = {
2690 BPF_LD_IMM64(R0, 2),
2691 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
2692 BPF_EXIT_INSN(),
2693 },
2694 INTERNAL,
2695 { },
2696 { { 0, 0xFFFFFFF0 } },
2697 },
2698 {
2699 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
2700 .u.insns_int = {
2701 BPF_LD_IMM64(R2, 0x1),
2702 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2703 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
2704 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2705 BPF_MOV32_IMM(R0, 2),
2706 BPF_EXIT_INSN(),
2707 BPF_MOV32_IMM(R0, 1),
2708 BPF_EXIT_INSN(),
2709 },
2710 INTERNAL,
2711 { },
2712 { { 0, 0x1 } },
2713 },
2714 {
2715 "ALU64_MUL_K: 2 * 3 = 6",
2716 .u.insns_int = {
2717 BPF_LD_IMM64(R0, 2),
2718 BPF_ALU64_IMM(BPF_MUL, R0, 3),
2719 BPF_EXIT_INSN(),
2720 },
2721 INTERNAL,
2722 { },
2723 { { 0, 6 } },
2724 },
2725 {
2726 "ALU64_MUL_K: 3 * 1 = 3",
2727 .u.insns_int = {
2728 BPF_LD_IMM64(R0, 3),
2729 BPF_ALU64_IMM(BPF_MUL, R0, 1),
2730 BPF_EXIT_INSN(),
2731 },
2732 INTERNAL,
2733 { },
2734 { { 0, 3 } },
2735 },
2736 {
2737 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
2738 .u.insns_int = {
2739 BPF_LD_IMM64(R0, 1),
2740 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
2741 BPF_EXIT_INSN(),
2742 },
2743 INTERNAL,
2744 { },
2745 { { 0, 2147483647 } },
2746 },
2747 {
2748 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
2749 .u.insns_int = {
2750 BPF_LD_IMM64(R0, 1),
2751 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
2752 BPF_EXIT_INSN(),
2753 },
2754 INTERNAL,
2755 { },
2756 { { 0, -2147483647 } },
2757 },
2758 {
2759 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
2760 .u.insns_int = {
2761 BPF_LD_IMM64(R2, 0x1),
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2762 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2763 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
2764 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2765 BPF_MOV32_IMM(R0, 2),
2766 BPF_EXIT_INSN(),
2767 BPF_MOV32_IMM(R0, 1),
2768 BPF_EXIT_INSN(),
2769 },
2770 INTERNAL,
2771 { },
2772 { { 0, 0x1 } },
2773 },
2774 /* BPF_ALU | BPF_DIV | BPF_X */
2775 {
2776 "ALU_DIV_X: 6 / 2 = 3",
2777 .u.insns_int = {
2778 BPF_LD_IMM64(R0, 6),
2779 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2780 BPF_ALU32_REG(BPF_DIV, R0, R1),
2781 BPF_EXIT_INSN(),
2782 },
2783 INTERNAL,
2784 { },
2785 { { 0, 3 } },
2786 },
2787 {
2788 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
2789 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2790 BPF_LD_IMM64(R0, 4294967295U),
2791 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2792 BPF_ALU32_REG(BPF_DIV, R0, R1),
2793 BPF_EXIT_INSN(),
2794 },
2795 INTERNAL,
2796 { },
2797 { { 0, 1 } },
2798 },
2799 {
2800 "ALU64_DIV_X: 6 / 2 = 3",
2801 .u.insns_int = {
2802 BPF_LD_IMM64(R0, 6),
2803 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2804 BPF_ALU64_REG(BPF_DIV, R0, R1),
2805 BPF_EXIT_INSN(),
2806 },
2807 INTERNAL,
2808 { },
2809 { { 0, 3 } },
2810 },
2811 {
2812 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
2813 .u.insns_int = {
2814 BPF_LD_IMM64(R0, 2147483647),
2815 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
2816 BPF_ALU64_REG(BPF_DIV, R0, R1),
2817 BPF_EXIT_INSN(),
2818 },
2819 INTERNAL,
2820 { },
2821 { { 0, 1 } },
2822 },
2823 {
2824 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
2825 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2826 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
2827 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
2828 BPF_LD_IMM64(R3, 0x0000000000000001LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2829 BPF_ALU64_REG(BPF_DIV, R2, R4),
2830 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2831 BPF_MOV32_IMM(R0, 2),
2832 BPF_EXIT_INSN(),
2833 BPF_MOV32_IMM(R0, 1),
2834 BPF_EXIT_INSN(),
2835 },
2836 INTERNAL,
2837 { },
2838 { { 0, 0x1 } },
2839 },
2840 /* BPF_ALU | BPF_DIV | BPF_K */
2841 {
2842 "ALU_DIV_K: 6 / 2 = 3",
2843 .u.insns_int = {
2844 BPF_LD_IMM64(R0, 6),
2845 BPF_ALU32_IMM(BPF_DIV, R0, 2),
2846 BPF_EXIT_INSN(),
2847 },
2848 INTERNAL,
2849 { },
2850 { { 0, 3 } },
2851 },
2852 {
2853 "ALU_DIV_K: 3 / 1 = 3",
2854 .u.insns_int = {
2855 BPF_LD_IMM64(R0, 3),
2856 BPF_ALU32_IMM(BPF_DIV, R0, 1),
2857 BPF_EXIT_INSN(),
2858 },
2859 INTERNAL,
2860 { },
2861 { { 0, 3 } },
2862 },
2863 {
2864 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
2865 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2866 BPF_LD_IMM64(R0, 4294967295U),
2867 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2868 BPF_EXIT_INSN(),
2869 },
2870 INTERNAL,
2871 { },
2872 { { 0, 1 } },
2873 },
2874 {
2875 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
2876 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2877 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2878 BPF_LD_IMM64(R3, 0x1UL),
2879 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
2880 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2881 BPF_MOV32_IMM(R0, 2),
2882 BPF_EXIT_INSN(),
2883 BPF_MOV32_IMM(R0, 1),
2884 BPF_EXIT_INSN(),
2885 },
2886 INTERNAL,
2887 { },
2888 { { 0, 0x1 } },
2889 },
2890 {
2891 "ALU64_DIV_K: 6 / 2 = 3",
2892 .u.insns_int = {
2893 BPF_LD_IMM64(R0, 6),
2894 BPF_ALU64_IMM(BPF_DIV, R0, 2),
2895 BPF_EXIT_INSN(),
2896 },
2897 INTERNAL,
2898 { },
2899 { { 0, 3 } },
2900 },
2901 {
2902 "ALU64_DIV_K: 3 / 1 = 3",
2903 .u.insns_int = {
2904 BPF_LD_IMM64(R0, 3),
2905 BPF_ALU64_IMM(BPF_DIV, R0, 1),
2906 BPF_EXIT_INSN(),
2907 },
2908 INTERNAL,
2909 { },
2910 { { 0, 3 } },
2911 },
2912 {
2913 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
2914 .u.insns_int = {
2915 BPF_LD_IMM64(R0, 2147483647),
2916 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
2917 BPF_EXIT_INSN(),
2918 },
2919 INTERNAL,
2920 { },
2921 { { 0, 1 } },
2922 },
2923 {
2924 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
2925 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2926 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
2927 BPF_LD_IMM64(R3, 0x0000000000000001LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2928 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
2929 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2930 BPF_MOV32_IMM(R0, 2),
2931 BPF_EXIT_INSN(),
2932 BPF_MOV32_IMM(R0, 1),
2933 BPF_EXIT_INSN(),
2934 },
2935 INTERNAL,
2936 { },
2937 { { 0, 0x1 } },
2938 },
2939 /* BPF_ALU | BPF_MOD | BPF_X */
2940 {
2941 "ALU_MOD_X: 3 % 2 = 1",
2942 .u.insns_int = {
2943 BPF_LD_IMM64(R0, 3),
2944 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2945 BPF_ALU32_REG(BPF_MOD, R0, R1),
2946 BPF_EXIT_INSN(),
2947 },
2948 INTERNAL,
2949 { },
2950 { { 0, 1 } },
2951 },
2952 {
2953 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
2954 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]2955 BPF_LD_IMM64(R0, 4294967295U),
2956 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]2957 BPF_ALU32_REG(BPF_MOD, R0, R1),
2958 BPF_EXIT_INSN(),
2959 },
2960 INTERNAL,
2961 { },
2962 { { 0, 2 } },
2963 },
2964 {
2965 "ALU64_MOD_X: 3 % 2 = 1",
2966 .u.insns_int = {
2967 BPF_LD_IMM64(R0, 3),
2968 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2969 BPF_ALU64_REG(BPF_MOD, R0, R1),
2970 BPF_EXIT_INSN(),
2971 },
2972 INTERNAL,
2973 { },
2974 { { 0, 1 } },
2975 },
2976 {
2977 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
2978 .u.insns_int = {
2979 BPF_LD_IMM64(R0, 2147483647),
2980 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
2981 BPF_ALU64_REG(BPF_MOD, R0, R1),
2982 BPF_EXIT_INSN(),
2983 },
2984 INTERNAL,
2985 { },
2986 { { 0, 2 } },
2987 },
2988 /* BPF_ALU | BPF_MOD | BPF_K */
2989 {
2990 "ALU_MOD_K: 3 % 2 = 1",
2991 .u.insns_int = {
2992 BPF_LD_IMM64(R0, 3),
2993 BPF_ALU32_IMM(BPF_MOD, R0, 2),
2994 BPF_EXIT_INSN(),
2995 },
2996 INTERNAL,
2997 { },
2998 { { 0, 1 } },
2999 },
3000 {
3001 "ALU_MOD_K: 3 % 1 = 0",
3002 .u.insns_int = {
3003 BPF_LD_IMM64(R0, 3),
3004 BPF_ALU32_IMM(BPF_MOD, R0, 1),
3005 BPF_EXIT_INSN(),
3006 },
3007 INTERNAL,
3008 { },
3009 { { 0, 0 } },
3010 },
3011 {
3012 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3013 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3014 BPF_LD_IMM64(R0, 4294967295U),
3015 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3016 BPF_EXIT_INSN(),
3017 },
3018 INTERNAL,
3019 { },
3020 { { 0, 2 } },
3021 },
3022 {
3023 "ALU64_MOD_K: 3 % 2 = 1",
3024 .u.insns_int = {
3025 BPF_LD_IMM64(R0, 3),
3026 BPF_ALU64_IMM(BPF_MOD, R0, 2),
3027 BPF_EXIT_INSN(),
3028 },
3029 INTERNAL,
3030 { },
3031 { { 0, 1 } },
3032 },
3033 {
3034 "ALU64_MOD_K: 3 % 1 = 0",
3035 .u.insns_int = {
3036 BPF_LD_IMM64(R0, 3),
3037 BPF_ALU64_IMM(BPF_MOD, R0, 1),
3038 BPF_EXIT_INSN(),
3039 },
3040 INTERNAL,
3041 { },
3042 { { 0, 0 } },
3043 },
3044 {
3045 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3046 .u.insns_int = {
3047 BPF_LD_IMM64(R0, 2147483647),
3048 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3049 BPF_EXIT_INSN(),
3050 },
3051 INTERNAL,
3052 { },
3053 { { 0, 2 } },
3054 },
3055 /* BPF_ALU | BPF_AND | BPF_X */
3056 {
3057 "ALU_AND_X: 3 & 2 = 2",
3058 .u.insns_int = {
3059 BPF_LD_IMM64(R0, 3),
3060 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3061 BPF_ALU32_REG(BPF_AND, R0, R1),
3062 BPF_EXIT_INSN(),
3063 },
3064 INTERNAL,
3065 { },
3066 { { 0, 2 } },
3067 },
3068 {
3069 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3070 .u.insns_int = {
3071 BPF_LD_IMM64(R0, 0xffffffff),
3072 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3073 BPF_ALU32_REG(BPF_AND, R0, R1),
3074 BPF_EXIT_INSN(),
3075 },
3076 INTERNAL,
3077 { },
3078 { { 0, 0xffffffff } },
3079 },
3080 {
3081 "ALU64_AND_X: 3 & 2 = 2",
3082 .u.insns_int = {
3083 BPF_LD_IMM64(R0, 3),
3084 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3085 BPF_ALU64_REG(BPF_AND, R0, R1),
3086 BPF_EXIT_INSN(),
3087 },
3088 INTERNAL,
3089 { },
3090 { { 0, 2 } },
3091 },
3092 {
3093 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3094 .u.insns_int = {
3095 BPF_LD_IMM64(R0, 0xffffffff),
3096 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3097 BPF_ALU64_REG(BPF_AND, R0, R1),
3098 BPF_EXIT_INSN(),
3099 },
3100 INTERNAL,
3101 { },
3102 { { 0, 0xffffffff } },
3103 },
3104 /* BPF_ALU | BPF_AND | BPF_K */
3105 {
3106 "ALU_AND_K: 3 & 2 = 2",
3107 .u.insns_int = {
3108 BPF_LD_IMM64(R0, 3),
3109 BPF_ALU32_IMM(BPF_AND, R0, 2),
3110 BPF_EXIT_INSN(),
3111 },
3112 INTERNAL,
3113 { },
3114 { { 0, 2 } },
3115 },
3116 {
3117 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3118 .u.insns_int = {
3119 BPF_LD_IMM64(R0, 0xffffffff),
3120 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3121 BPF_EXIT_INSN(),
3122 },
3123 INTERNAL,
3124 { },
3125 { { 0, 0xffffffff } },
3126 },
3127 {
3128 "ALU64_AND_K: 3 & 2 = 2",
3129 .u.insns_int = {
3130 BPF_LD_IMM64(R0, 3),
3131 BPF_ALU64_IMM(BPF_AND, R0, 2),
3132 BPF_EXIT_INSN(),
3133 },
3134 INTERNAL,
3135 { },
3136 { { 0, 2 } },
3137 },
3138 {
3139 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3140 .u.insns_int = {
3141 BPF_LD_IMM64(R0, 0xffffffff),
3142 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3143 BPF_EXIT_INSN(),
3144 },
3145 INTERNAL,
3146 { },
3147 { { 0, 0xffffffff } },
3148 },
3149 {
3150 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000",
3151 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3152 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3153 BPF_LD_IMM64(R3, 0x0000000000000000LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3154 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3155 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3156 BPF_MOV32_IMM(R0, 2),
3157 BPF_EXIT_INSN(),
3158 BPF_MOV32_IMM(R0, 1),
3159 BPF_EXIT_INSN(),
3160 },
3161 INTERNAL,
3162 { },
3163 { { 0, 0x1 } },
3164 },
3165 {
3166 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff",
3167 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3168 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3169 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3170 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3171 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3172 BPF_MOV32_IMM(R0, 2),
3173 BPF_EXIT_INSN(),
3174 BPF_MOV32_IMM(R0, 1),
3175 BPF_EXIT_INSN(),
3176 },
3177 INTERNAL,
3178 { },
3179 { { 0, 0x1 } },
3180 },
3181 {
3182 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3183 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3184 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3185 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3186 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3187 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3188 BPF_MOV32_IMM(R0, 2),
3189 BPF_EXIT_INSN(),
3190 BPF_MOV32_IMM(R0, 1),
3191 BPF_EXIT_INSN(),
3192 },
3193 INTERNAL,
3194 { },
3195 { { 0, 0x1 } },
3196 },
3197 /* BPF_ALU | BPF_OR | BPF_X */
3198 {
3199 "ALU_OR_X: 1 | 2 = 3",
3200 .u.insns_int = {
3201 BPF_LD_IMM64(R0, 1),
3202 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3203 BPF_ALU32_REG(BPF_OR, R0, R1),
3204 BPF_EXIT_INSN(),
3205 },
3206 INTERNAL,
3207 { },
3208 { { 0, 3 } },
3209 },
3210 {
3211 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3212 .u.insns_int = {
3213 BPF_LD_IMM64(R0, 0),
3214 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3215 BPF_ALU32_REG(BPF_OR, R0, R1),
3216 BPF_EXIT_INSN(),
3217 },
3218 INTERNAL,
3219 { },
3220 { { 0, 0xffffffff } },
3221 },
3222 {
3223 "ALU64_OR_X: 1 | 2 = 3",
3224 .u.insns_int = {
3225 BPF_LD_IMM64(R0, 1),
3226 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3227 BPF_ALU64_REG(BPF_OR, R0, R1),
3228 BPF_EXIT_INSN(),
3229 },
3230 INTERNAL,
3231 { },
3232 { { 0, 3 } },
3233 },
3234 {
3235 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3236 .u.insns_int = {
3237 BPF_LD_IMM64(R0, 0),
3238 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3239 BPF_ALU64_REG(BPF_OR, R0, R1),
3240 BPF_EXIT_INSN(),
3241 },
3242 INTERNAL,
3243 { },
3244 { { 0, 0xffffffff } },
3245 },
3246 /* BPF_ALU | BPF_OR | BPF_K */
3247 {
3248 "ALU_OR_K: 1 | 2 = 3",
3249 .u.insns_int = {
3250 BPF_LD_IMM64(R0, 1),
3251 BPF_ALU32_IMM(BPF_OR, R0, 2),
3252 BPF_EXIT_INSN(),
3253 },
3254 INTERNAL,
3255 { },
3256 { { 0, 3 } },
3257 },
3258 {
3259 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3260 .u.insns_int = {
3261 BPF_LD_IMM64(R0, 0),
3262 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3263 BPF_EXIT_INSN(),
3264 },
3265 INTERNAL,
3266 { },
3267 { { 0, 0xffffffff } },
3268 },
3269 {
3270 "ALU64_OR_K: 1 | 2 = 3",
3271 .u.insns_int = {
3272 BPF_LD_IMM64(R0, 1),
3273 BPF_ALU64_IMM(BPF_OR, R0, 2),
3274 BPF_EXIT_INSN(),
3275 },
3276 INTERNAL,
3277 { },
3278 { { 0, 3 } },
3279 },
3280 {
3281 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
3282 .u.insns_int = {
3283 BPF_LD_IMM64(R0, 0),
3284 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
3285 BPF_EXIT_INSN(),
3286 },
3287 INTERNAL,
3288 { },
3289 { { 0, 0xffffffff } },
3290 },
3291 {
3292 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000",
3293 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3294 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3295 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3296 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
3297 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3298 BPF_MOV32_IMM(R0, 2),
3299 BPF_EXIT_INSN(),
3300 BPF_MOV32_IMM(R0, 1),
3301 BPF_EXIT_INSN(),
3302 },
3303 INTERNAL,
3304 { },
3305 { { 0, 0x1 } },
3306 },
3307 {
3308 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
3309 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3310 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3311 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3312 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3313 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3314 BPF_MOV32_IMM(R0, 2),
3315 BPF_EXIT_INSN(),
3316 BPF_MOV32_IMM(R0, 1),
3317 BPF_EXIT_INSN(),
3318 },
3319 INTERNAL,
3320 { },
3321 { { 0, 0x1 } },
3322 },
3323 {
3324 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
3325 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3326 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3327 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3328 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
3329 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3330 BPF_MOV32_IMM(R0, 2),
3331 BPF_EXIT_INSN(),
3332 BPF_MOV32_IMM(R0, 1),
3333 BPF_EXIT_INSN(),
3334 },
3335 INTERNAL,
3336 { },
3337 { { 0, 0x1 } },
3338 },
3339 /* BPF_ALU | BPF_XOR | BPF_X */
3340 {
3341 "ALU_XOR_X: 5 ^ 6 = 3",
3342 .u.insns_int = {
3343 BPF_LD_IMM64(R0, 5),
3344 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3345 BPF_ALU32_REG(BPF_XOR, R0, R1),
3346 BPF_EXIT_INSN(),
3347 },
3348 INTERNAL,
3349 { },
3350 { { 0, 3 } },
3351 },
3352 {
3353 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
3354 .u.insns_int = {
3355 BPF_LD_IMM64(R0, 1),
3356 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3357 BPF_ALU32_REG(BPF_XOR, R0, R1),
3358 BPF_EXIT_INSN(),
3359 },
3360 INTERNAL,
3361 { },
3362 { { 0, 0xfffffffe } },
3363 },
3364 {
3365 "ALU64_XOR_X: 5 ^ 6 = 3",
3366 .u.insns_int = {
3367 BPF_LD_IMM64(R0, 5),
3368 BPF_ALU32_IMM(BPF_MOV, R1, 6),
3369 BPF_ALU64_REG(BPF_XOR, R0, R1),
3370 BPF_EXIT_INSN(),
3371 },
3372 INTERNAL,
3373 { },
3374 { { 0, 3 } },
3375 },
3376 {
3377 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
3378 .u.insns_int = {
3379 BPF_LD_IMM64(R0, 1),
3380 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3381 BPF_ALU64_REG(BPF_XOR, R0, R1),
3382 BPF_EXIT_INSN(),
3383 },
3384 INTERNAL,
3385 { },
3386 { { 0, 0xfffffffe } },
3387 },
3388 /* BPF_ALU | BPF_XOR | BPF_K */
3389 {
3390 "ALU_XOR_K: 5 ^ 6 = 3",
3391 .u.insns_int = {
3392 BPF_LD_IMM64(R0, 5),
3393 BPF_ALU32_IMM(BPF_XOR, R0, 6),
3394 BPF_EXIT_INSN(),
3395 },
3396 INTERNAL,
3397 { },
3398 { { 0, 3 } },
3399 },
3400 {
3401 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
3402 .u.insns_int = {
3403 BPF_LD_IMM64(R0, 1),
3404 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
3405 BPF_EXIT_INSN(),
3406 },
3407 INTERNAL,
3408 { },
3409 { { 0, 0xfffffffe } },
3410 },
3411 {
3412 "ALU64_XOR_K: 5 ^ 6 = 3",
3413 .u.insns_int = {
3414 BPF_LD_IMM64(R0, 5),
3415 BPF_ALU64_IMM(BPF_XOR, R0, 6),
3416 BPF_EXIT_INSN(),
3417 },
3418 INTERNAL,
3419 { },
3420 { { 0, 3 } },
3421 },
3422 {
3423 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe",
3424 .u.insns_int = {
3425 BPF_LD_IMM64(R0, 1),
3426 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
3427 BPF_EXIT_INSN(),
3428 },
3429 INTERNAL,
3430 { },
3431 { { 0, 0xfffffffe } },
3432 },
3433 {
3434 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
3435 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3436 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3437 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3438 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
3439 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3440 BPF_MOV32_IMM(R0, 2),
3441 BPF_EXIT_INSN(),
3442 BPF_MOV32_IMM(R0, 1),
3443 BPF_EXIT_INSN(),
3444 },
3445 INTERNAL,
3446 { },
3447 { { 0, 0x1 } },
3448 },
3449 {
3450 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
3451 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3452 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3453 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3454 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3455 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3456 BPF_MOV32_IMM(R0, 2),
3457 BPF_EXIT_INSN(),
3458 BPF_MOV32_IMM(R0, 1),
3459 BPF_EXIT_INSN(),
3460 },
3461 INTERNAL,
3462 { },
3463 { { 0, 0x1 } },
3464 },
3465 {
3466 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
3467 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3468 BPF_LD_IMM64(R2, 0x0000000000000000LL),
3469 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3470 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
3471 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3472 BPF_MOV32_IMM(R0, 2),
3473 BPF_EXIT_INSN(),
3474 BPF_MOV32_IMM(R0, 1),
3475 BPF_EXIT_INSN(),
3476 },
3477 INTERNAL,
3478 { },
3479 { { 0, 0x1 } },
3480 },
3481 /* BPF_ALU | BPF_LSH | BPF_X */
3482 {
3483 "ALU_LSH_X: 1 << 1 = 2",
3484 .u.insns_int = {
3485 BPF_LD_IMM64(R0, 1),
3486 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3487 BPF_ALU32_REG(BPF_LSH, R0, R1),
3488 BPF_EXIT_INSN(),
3489 },
3490 INTERNAL,
3491 { },
3492 { { 0, 2 } },
3493 },
3494 {
3495 "ALU_LSH_X: 1 << 31 = 0x80000000",
3496 .u.insns_int = {
3497 BPF_LD_IMM64(R0, 1),
3498 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3499 BPF_ALU32_REG(BPF_LSH, R0, R1),
3500 BPF_EXIT_INSN(),
3501 },
3502 INTERNAL,
3503 { },
3504 { { 0, 0x80000000 } },
3505 },
3506 {
3507 "ALU64_LSH_X: 1 << 1 = 2",
3508 .u.insns_int = {
3509 BPF_LD_IMM64(R0, 1),
3510 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3511 BPF_ALU64_REG(BPF_LSH, R0, R1),
3512 BPF_EXIT_INSN(),
3513 },
3514 INTERNAL,
3515 { },
3516 { { 0, 2 } },
3517 },
3518 {
3519 "ALU64_LSH_X: 1 << 31 = 0x80000000",
3520 .u.insns_int = {
3521 BPF_LD_IMM64(R0, 1),
3522 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3523 BPF_ALU64_REG(BPF_LSH, R0, R1),
3524 BPF_EXIT_INSN(),
3525 },
3526 INTERNAL,
3527 { },
3528 { { 0, 0x80000000 } },
3529 },
3530 /* BPF_ALU | BPF_LSH | BPF_K */
3531 {
3532 "ALU_LSH_K: 1 << 1 = 2",
3533 .u.insns_int = {
3534 BPF_LD_IMM64(R0, 1),
3535 BPF_ALU32_IMM(BPF_LSH, R0, 1),
3536 BPF_EXIT_INSN(),
3537 },
3538 INTERNAL,
3539 { },
3540 { { 0, 2 } },
3541 },
3542 {
3543 "ALU_LSH_K: 1 << 31 = 0x80000000",
3544 .u.insns_int = {
3545 BPF_LD_IMM64(R0, 1),
3546 BPF_ALU32_IMM(BPF_LSH, R0, 31),
3547 BPF_EXIT_INSN(),
3548 },
3549 INTERNAL,
3550 { },
3551 { { 0, 0x80000000 } },
3552 },
3553 {
3554 "ALU64_LSH_K: 1 << 1 = 2",
3555 .u.insns_int = {
3556 BPF_LD_IMM64(R0, 1),
3557 BPF_ALU64_IMM(BPF_LSH, R0, 1),
3558 BPF_EXIT_INSN(),
3559 },
3560 INTERNAL,
3561 { },
3562 { { 0, 2 } },
3563 },
3564 {
3565 "ALU64_LSH_K: 1 << 31 = 0x80000000",
3566 .u.insns_int = {
3567 BPF_LD_IMM64(R0, 1),
3568 BPF_ALU64_IMM(BPF_LSH, R0, 31),
3569 BPF_EXIT_INSN(),
3570 },
3571 INTERNAL,
3572 { },
3573 { { 0, 0x80000000 } },
3574 },
3575 /* BPF_ALU | BPF_RSH | BPF_X */
3576 {
3577 "ALU_RSH_X: 2 >> 1 = 1",
3578 .u.insns_int = {
3579 BPF_LD_IMM64(R0, 2),
3580 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3581 BPF_ALU32_REG(BPF_RSH, R0, R1),
3582 BPF_EXIT_INSN(),
3583 },
3584 INTERNAL,
3585 { },
3586 { { 0, 1 } },
3587 },
3588 {
3589 "ALU_RSH_X: 0x80000000 >> 31 = 1",
3590 .u.insns_int = {
3591 BPF_LD_IMM64(R0, 0x80000000),
3592 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3593 BPF_ALU32_REG(BPF_RSH, R0, R1),
3594 BPF_EXIT_INSN(),
3595 },
3596 INTERNAL,
3597 { },
3598 { { 0, 1 } },
3599 },
3600 {
3601 "ALU64_RSH_X: 2 >> 1 = 1",
3602 .u.insns_int = {
3603 BPF_LD_IMM64(R0, 2),
3604 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3605 BPF_ALU64_REG(BPF_RSH, R0, R1),
3606 BPF_EXIT_INSN(),
3607 },
3608 INTERNAL,
3609 { },
3610 { { 0, 1 } },
3611 },
3612 {
3613 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
3614 .u.insns_int = {
3615 BPF_LD_IMM64(R0, 0x80000000),
3616 BPF_ALU32_IMM(BPF_MOV, R1, 31),
3617 BPF_ALU64_REG(BPF_RSH, R0, R1),
3618 BPF_EXIT_INSN(),
3619 },
3620 INTERNAL,
3621 { },
3622 { { 0, 1 } },
3623 },
3624 /* BPF_ALU | BPF_RSH | BPF_K */
3625 {
3626 "ALU_RSH_K: 2 >> 1 = 1",
3627 .u.insns_int = {
3628 BPF_LD_IMM64(R0, 2),
3629 BPF_ALU32_IMM(BPF_RSH, R0, 1),
3630 BPF_EXIT_INSN(),
3631 },
3632 INTERNAL,
3633 { },
3634 { { 0, 1 } },
3635 },
3636 {
3637 "ALU_RSH_K: 0x80000000 >> 31 = 1",
3638 .u.insns_int = {
3639 BPF_LD_IMM64(R0, 0x80000000),
3640 BPF_ALU32_IMM(BPF_RSH, R0, 31),
3641 BPF_EXIT_INSN(),
3642 },
3643 INTERNAL,
3644 { },
3645 { { 0, 1 } },
3646 },
3647 {
3648 "ALU64_RSH_K: 2 >> 1 = 1",
3649 .u.insns_int = {
3650 BPF_LD_IMM64(R0, 2),
3651 BPF_ALU64_IMM(BPF_RSH, R0, 1),
3652 BPF_EXIT_INSN(),
3653 },
3654 INTERNAL,
3655 { },
3656 { { 0, 1 } },
3657 },
3658 {
3659 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
3660 .u.insns_int = {
3661 BPF_LD_IMM64(R0, 0x80000000),
3662 BPF_ALU64_IMM(BPF_RSH, R0, 31),
3663 BPF_EXIT_INSN(),
3664 },
3665 INTERNAL,
3666 { },
3667 { { 0, 1 } },
3668 },
3669 /* BPF_ALU | BPF_ARSH | BPF_X */
3670 {
3671 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3672 .u.insns_int = {
3673 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3674 BPF_ALU32_IMM(BPF_MOV, R1, 40),
3675 BPF_ALU64_REG(BPF_ARSH, R0, R1),
3676 BPF_EXIT_INSN(),
3677 },
3678 INTERNAL,
3679 { },
3680 { { 0, 0xffff00ff } },
3681 },
3682 /* BPF_ALU | BPF_ARSH | BPF_K */
3683 {
3684 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
3685 .u.insns_int = {
3686 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
3687 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
3688 BPF_EXIT_INSN(),
3689 },
3690 INTERNAL,
3691 { },
3692 { { 0, 0xffff00ff } },
3693 },
3694 /* BPF_ALU | BPF_NEG */
3695 {
3696 "ALU_NEG: -(3) = -3",
3697 .u.insns_int = {
3698 BPF_ALU32_IMM(BPF_MOV, R0, 3),
3699 BPF_ALU32_IMM(BPF_NEG, R0, 0),
3700 BPF_EXIT_INSN(),
3701 },
3702 INTERNAL,
3703 { },
3704 { { 0, -3 } },
3705 },
3706 {
3707 "ALU_NEG: -(-3) = 3",
3708 .u.insns_int = {
3709 BPF_ALU32_IMM(BPF_MOV, R0, -3),
3710 BPF_ALU32_IMM(BPF_NEG, R0, 0),
3711 BPF_EXIT_INSN(),
3712 },
3713 INTERNAL,
3714 { },
3715 { { 0, 3 } },
3716 },
3717 {
3718 "ALU64_NEG: -(3) = -3",
3719 .u.insns_int = {
3720 BPF_LD_IMM64(R0, 3),
3721 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3722 BPF_EXIT_INSN(),
3723 },
3724 INTERNAL,
3725 { },
3726 { { 0, -3 } },
3727 },
3728 {
3729 "ALU64_NEG: -(-3) = 3",
3730 .u.insns_int = {
3731 BPF_LD_IMM64(R0, -3),
3732 BPF_ALU64_IMM(BPF_NEG, R0, 0),
3733 BPF_EXIT_INSN(),
3734 },
3735 INTERNAL,
3736 { },
3737 { { 0, 3 } },
3738 },
3739 /* BPF_ALU | BPF_END | BPF_FROM_BE */
3740 {
3741 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
3742 .u.insns_int = {
3743 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3744 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
3745 BPF_EXIT_INSN(),
3746 },
3747 INTERNAL,
3748 { },
3749 { { 0, cpu_to_be16(0xcdef) } },
3750 },
3751 {
3752 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
3753 .u.insns_int = {
3754 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3755 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
Xi Wangba29bec2015-07-08 14:00:56 -0700[diff] [blame]3756 BPF_ALU64_REG(BPF_MOV, R1, R0),
3757 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3758 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3759 BPF_EXIT_INSN(),
3760 },
3761 INTERNAL,
3762 { },
3763 { { 0, cpu_to_be32(0x89abcdef) } },
3764 },
3765 {
3766 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
3767 .u.insns_int = {
3768 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3769 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
3770 BPF_EXIT_INSN(),
3771 },
3772 INTERNAL,
3773 { },
3774 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
3775 },
3776 /* BPF_ALU | BPF_END | BPF_FROM_LE */
3777 {
3778 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
3779 .u.insns_int = {
3780 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3781 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
3782 BPF_EXIT_INSN(),
3783 },
3784 INTERNAL,
3785 { },
3786 { { 0, cpu_to_le16(0xcdef) } },
3787 },
3788 {
3789 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
3790 .u.insns_int = {
3791 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3792 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
Xi Wangba29bec2015-07-08 14:00:56 -0700[diff] [blame]3793 BPF_ALU64_REG(BPF_MOV, R1, R0),
3794 BPF_ALU64_IMM(BPF_RSH, R1, 32),
3795 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3796 BPF_EXIT_INSN(),
3797 },
3798 INTERNAL,
3799 { },
3800 { { 0, cpu_to_le32(0x89abcdef) } },
3801 },
3802 {
3803 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
3804 .u.insns_int = {
3805 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3806 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
3807 BPF_EXIT_INSN(),
3808 },
3809 INTERNAL,
3810 { },
3811 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
3812 },
3813 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
3814 {
3815 "ST_MEM_B: Store/Load byte: max negative",
3816 .u.insns_int = {
3817 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3818 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
3819 BPF_LDX_MEM(BPF_B, R0, R10, -40),
3820 BPF_EXIT_INSN(),
3821 },
3822 INTERNAL,
3823 { },
3824 { { 0, 0xff } },
3825 },
3826 {
3827 "ST_MEM_B: Store/Load byte: max positive",
3828 .u.insns_int = {
3829 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3830 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
3831 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3832 BPF_EXIT_INSN(),
3833 },
3834 INTERNAL,
3835 { },
3836 { { 0, 0x7f } },
3837 },
3838 {
3839 "STX_MEM_B: Store/Load byte: max negative",
3840 .u.insns_int = {
3841 BPF_LD_IMM64(R0, 0),
3842 BPF_LD_IMM64(R1, 0xffLL),
3843 BPF_STX_MEM(BPF_B, R10, R1, -40),
3844 BPF_LDX_MEM(BPF_B, R0, R10, -40),
3845 BPF_EXIT_INSN(),
3846 },
3847 INTERNAL,
3848 { },
3849 { { 0, 0xff } },
3850 },
3851 {
3852 "ST_MEM_H: Store/Load half word: max negative",
3853 .u.insns_int = {
3854 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3855 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
3856 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3857 BPF_EXIT_INSN(),
3858 },
3859 INTERNAL,
3860 { },
3861 { { 0, 0xffff } },
3862 },
3863 {
3864 "ST_MEM_H: Store/Load half word: max positive",
3865 .u.insns_int = {
3866 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3867 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
3868 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3869 BPF_EXIT_INSN(),
3870 },
3871 INTERNAL,
3872 { },
3873 { { 0, 0x7fff } },
3874 },
3875 {
3876 "STX_MEM_H: Store/Load half word: max negative",
3877 .u.insns_int = {
3878 BPF_LD_IMM64(R0, 0),
3879 BPF_LD_IMM64(R1, 0xffffLL),
3880 BPF_STX_MEM(BPF_H, R10, R1, -40),
3881 BPF_LDX_MEM(BPF_H, R0, R10, -40),
3882 BPF_EXIT_INSN(),
3883 },
3884 INTERNAL,
3885 { },
3886 { { 0, 0xffff } },
3887 },
3888 {
3889 "ST_MEM_W: Store/Load word: max negative",
3890 .u.insns_int = {
3891 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3892 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
3893 BPF_LDX_MEM(BPF_W, R0, R10, -40),
3894 BPF_EXIT_INSN(),
3895 },
3896 INTERNAL,
3897 { },
3898 { { 0, 0xffffffff } },
3899 },
3900 {
3901 "ST_MEM_W: Store/Load word: max positive",
3902 .u.insns_int = {
3903 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3904 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
3905 BPF_LDX_MEM(BPF_W, R0, R10, -40),
3906 BPF_EXIT_INSN(),
3907 },
3908 INTERNAL,
3909 { },
3910 { { 0, 0x7fffffff } },
3911 },
3912 {
3913 "STX_MEM_W: Store/Load word: max negative",
3914 .u.insns_int = {
3915 BPF_LD_IMM64(R0, 0),
3916 BPF_LD_IMM64(R1, 0xffffffffLL),
3917 BPF_STX_MEM(BPF_W, R10, R1, -40),
3918 BPF_LDX_MEM(BPF_W, R0, R10, -40),
3919 BPF_EXIT_INSN(),
3920 },
3921 INTERNAL,
3922 { },
3923 { { 0, 0xffffffff } },
3924 },
3925 {
3926 "ST_MEM_DW: Store/Load double word: max negative",
3927 .u.insns_int = {
3928 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3929 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
3930 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
3931 BPF_EXIT_INSN(),
3932 },
3933 INTERNAL,
3934 { },
3935 { { 0, 0xffffffff } },
3936 },
3937 {
3938 "ST_MEM_DW: Store/Load double word: max negative 2",
3939 .u.insns_int = {
Michael Holzheu56cbaa42015-05-13 20:40:39 -0700[diff] [blame]3940 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
3941 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]3942 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
3943 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
3944 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3945 BPF_MOV32_IMM(R0, 2),
3946 BPF_EXIT_INSN(),
3947 BPF_MOV32_IMM(R0, 1),
3948 BPF_EXIT_INSN(),
3949 },
3950 INTERNAL,
3951 { },
3952 { { 0, 0x1 } },
3953 },
3954 {
3955 "ST_MEM_DW: Store/Load double word: max positive",
3956 .u.insns_int = {
3957 BPF_ALU32_IMM(BPF_MOV, R0, 1),
3958 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
3959 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
3960 BPF_EXIT_INSN(),
3961 },
3962 INTERNAL,
3963 { },
3964 { { 0, 0x7fffffff } },
3965 },
3966 {
3967 "STX_MEM_DW: Store/Load double word: max negative",
3968 .u.insns_int = {
3969 BPF_LD_IMM64(R0, 0),
3970 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
3971 BPF_STX_MEM(BPF_W, R10, R1, -40),
3972 BPF_LDX_MEM(BPF_W, R0, R10, -40),
3973 BPF_EXIT_INSN(),
3974 },
3975 INTERNAL,
3976 { },
3977 { { 0, 0xffffffff } },
3978 },
3979 /* BPF_STX | BPF_XADD | BPF_W/DW */
3980 {
3981 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22",
3982 .u.insns_int = {
3983 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
3984 BPF_ST_MEM(BPF_W, R10, -40, 0x10),
3985 BPF_STX_XADD(BPF_W, R10, R0, -40),
3986 BPF_LDX_MEM(BPF_W, R0, R10, -40),
3987 BPF_EXIT_INSN(),
3988 },
3989 INTERNAL,
3990 { },
3991 { { 0, 0x22 } },
3992 },
3993 {
3994 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22",
3995 .u.insns_int = {
3996 BPF_ALU32_IMM(BPF_MOV, R0, 0x12),
3997 BPF_ST_MEM(BPF_DW, R10, -40, 0x10),
3998 BPF_STX_XADD(BPF_DW, R10, R0, -40),
3999 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
4000 BPF_EXIT_INSN(),
4001 },
4002 INTERNAL,
4003 { },
4004 { { 0, 0x22 } },
4005 },
4006 /* BPF_JMP | BPF_EXIT */
4007 {
4008 "JMP_EXIT",
4009 .u.insns_int = {
4010 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
4011 BPF_EXIT_INSN(),
4012 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
4013 },
4014 INTERNAL,
4015 { },
4016 { { 0, 0x4711 } },
4017 },
4018 /* BPF_JMP | BPF_JA */
4019 {
4020 "JMP_JA: Unconditional jump: if (true) return 1",
4021 .u.insns_int = {
4022 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4023 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
4024 BPF_EXIT_INSN(),
4025 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4026 BPF_EXIT_INSN(),
4027 },
4028 INTERNAL,
4029 { },
4030 { { 0, 1 } },
4031 },
4032 /* BPF_JMP | BPF_JSGT | BPF_K */
4033 {
4034 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
4035 .u.insns_int = {
4036 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4037 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4038 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
4039 BPF_EXIT_INSN(),
4040 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4041 BPF_EXIT_INSN(),
4042 },
4043 INTERNAL,
4044 { },
4045 { { 0, 1 } },
4046 },
4047 {
4048 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
4049 .u.insns_int = {
4050 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4051 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4052 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
4053 BPF_EXIT_INSN(),
4054 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4055 BPF_EXIT_INSN(),
4056 },
4057 INTERNAL,
4058 { },
4059 { { 0, 1 } },
4060 },
4061 /* BPF_JMP | BPF_JSGE | BPF_K */
4062 {
4063 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
4064 .u.insns_int = {
4065 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4066 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4067 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
4068 BPF_EXIT_INSN(),
4069 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4070 BPF_EXIT_INSN(),
4071 },
4072 INTERNAL,
4073 { },
4074 { { 0, 1 } },
4075 },
4076 {
4077 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
4078 .u.insns_int = {
4079 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4080 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
4081 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
4082 BPF_EXIT_INSN(),
4083 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4084 BPF_EXIT_INSN(),
4085 },
4086 INTERNAL,
4087 { },
4088 { { 0, 1 } },
4089 },
4090 /* BPF_JMP | BPF_JGT | BPF_K */
4091 {
4092 "JMP_JGT_K: if (3 > 2) return 1",
4093 .u.insns_int = {
4094 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4095 BPF_LD_IMM64(R1, 3),
4096 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
4097 BPF_EXIT_INSN(),
4098 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4099 BPF_EXIT_INSN(),
4100 },
4101 INTERNAL,
4102 { },
4103 { { 0, 1 } },
4104 },
4105 /* BPF_JMP | BPF_JGE | BPF_K */
4106 {
4107 "JMP_JGE_K: if (3 >= 2) return 1",
4108 .u.insns_int = {
4109 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4110 BPF_LD_IMM64(R1, 3),
4111 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
4112 BPF_EXIT_INSN(),
4113 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4114 BPF_EXIT_INSN(),
4115 },
4116 INTERNAL,
4117 { },
4118 { { 0, 1 } },
4119 },
Michael Holzheufe593842015-05-22 08:36:40 -0700[diff] [blame]4120 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
4121 {
4122 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
4123 .u.insns_int = {
4124 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
4125 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
4126 BPF_EXIT_INSN(),
4127 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
4128 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
4129 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
4130 BPF_EXIT_INSN(),
4131 },
4132 INTERNAL,
4133 { },
4134 { { 0, 1 } },
4135 },
Michael Holzheucffc6422015-05-11 22:22:44 -0700[diff] [blame]4136 {
4137 "JMP_JGE_K: if (3 >= 3) return 1",
4138 .u.insns_int = {
4139 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4140 BPF_LD_IMM64(R1, 3),
4141 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
4142 BPF_EXIT_INSN(),
4143 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4144 BPF_EXIT_INSN(),
4145 },
4146 INTERNAL,
4147 { },
4148 { { 0, 1 } },
4149 },
4150 /* BPF_JMP | BPF_JNE | BPF_K */
4151 {
4152 "JMP_JNE_K: if (3 != 2) return 1",
4153 .u.insns_int = {
4154 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4155 BPF_LD_IMM64(R1, 3),
4156 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4157 BPF_EXIT_INSN(),
4158 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4159 BPF_EXIT_INSN(),
4160 },
4161 INTERNAL,
4162 { },
4163 { { 0, 1 } },
4164 },
4165 /* BPF_JMP | BPF_JEQ | BPF_K */
4166 {
4167 "JMP_JEQ_K: if (3 == 3) return 1",
4168 .u.insns_int = {
4169 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4170 BPF_LD_IMM64(R1, 3),
4171 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
4172 BPF_EXIT_INSN(),
4173 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4174 BPF_EXIT_INSN(),
4175 },
4176 INTERNAL,
4177 { },
4178 { { 0, 1 } },
4179 },
4180 /* BPF_JMP | BPF_JSET | BPF_K */
4181 {
4182 "JMP_JSET_K: if (0x3 & 0x2) return 1",
4183 .u.insns_int = {
4184 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4185 BPF_LD_IMM64(R1, 3),
4186 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
4187 BPF_EXIT_INSN(),
4188 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4189 BPF_EXIT_INSN(),
4190 },
4191 INTERNAL,
4192 { },
4193 { { 0, 1 } },
4194 },
4195 {
4196 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
4197 .u.insns_int = {
4198 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4199 BPF_LD_IMM64(R1, 3),
4200 BPF_JMP_IMM(BPF_JNE, R1, 0xffffffff, 1),
4201 BPF_EXIT_INSN(),
4202 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4203 BPF_EXIT_INSN(),
4204 },
4205 INTERNAL,
4206 { },
4207 { { 0, 1 } },
4208 },
4209 /* BPF_JMP | BPF_JSGT | BPF_X */
4210 {
4211 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
4212 .u.insns_int = {
4213 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4214 BPF_LD_IMM64(R1, -1),
4215 BPF_LD_IMM64(R2, -2),
4216 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4217 BPF_EXIT_INSN(),
4218 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4219 BPF_EXIT_INSN(),
4220 },
4221 INTERNAL,
4222 { },
4223 { { 0, 1 } },
4224 },
4225 {
4226 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
4227 .u.insns_int = {
4228 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4229 BPF_LD_IMM64(R1, -1),
4230 BPF_LD_IMM64(R2, -1),
4231 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
4232 BPF_EXIT_INSN(),
4233 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4234 BPF_EXIT_INSN(),
4235 },
4236 INTERNAL,
4237 { },
4238 { { 0, 1 } },
4239 },
4240 /* BPF_JMP | BPF_JSGE | BPF_X */
4241 {
4242 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
4243 .u.insns_int = {
4244 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4245 BPF_LD_IMM64(R1, -1),
4246 BPF_LD_IMM64(R2, -2),
4247 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4248 BPF_EXIT_INSN(),
4249 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4250 BPF_EXIT_INSN(),
4251 },
4252 INTERNAL,
4253 { },
4254 { { 0, 1 } },
4255 },
4256 {
4257 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
4258 .u.insns_int = {
4259 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4260 BPF_LD_IMM64(R1, -1),
4261 BPF_LD_IMM64(R2, -1),
4262 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
4263 BPF_EXIT_INSN(),
4264 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4265 BPF_EXIT_INSN(),
4266 },
4267 INTERNAL,
4268 { },
4269 { { 0, 1 } },
4270 },
4271 /* BPF_JMP | BPF_JGT | BPF_X */
4272 {
4273 "JMP_JGT_X: if (3 > 2) return 1",
4274 .u.insns_int = {
4275 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4276 BPF_LD_IMM64(R1, 3),
4277 BPF_LD_IMM64(R2, 2),
4278 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
4279 BPF_EXIT_INSN(),
4280 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4281 BPF_EXIT_INSN(),
4282 },
4283 INTERNAL,
4284 { },
4285 { { 0, 1 } },
4286 },
4287 /* BPF_JMP | BPF_JGE | BPF_X */
4288 {
4289 "JMP_JGE_X: if (3 >= 2) return 1",
4290 .u.insns_int = {
4291 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4292 BPF_LD_IMM64(R1, 3),
4293 BPF_LD_IMM64(R2, 2),
4294 BPF_JMP_REG(BPF_JGE, R1, R2, 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 },
4303 {
4304 "JMP_JGE_X: if (3 >= 3) return 1",
4305 .u.insns_int = {
4306 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4307 BPF_LD_IMM64(R1, 3),
4308 BPF_LD_IMM64(R2, 3),
4309 BPF_JMP_REG(BPF_JGE, R1, R2, 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 },
4318 /* BPF_JMP | BPF_JNE | BPF_X */
4319 {
4320 "JMP_JNE_X: if (3 != 2) return 1",
4321 .u.insns_int = {
4322 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4323 BPF_LD_IMM64(R1, 3),
4324 BPF_LD_IMM64(R2, 2),
4325 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
4326 BPF_EXIT_INSN(),
4327 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4328 BPF_EXIT_INSN(),
4329 },
4330 INTERNAL,
4331 { },
4332 { { 0, 1 } },
4333 },
4334 /* BPF_JMP | BPF_JEQ | BPF_X */
4335 {
4336 "JMP_JEQ_X: if (3 == 3) return 1",
4337 .u.insns_int = {
4338 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4339 BPF_LD_IMM64(R1, 3),
4340 BPF_LD_IMM64(R2, 3),
4341 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
4342 BPF_EXIT_INSN(),
4343 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4344 BPF_EXIT_INSN(),
4345 },
4346 INTERNAL,
4347 { },
4348 { { 0, 1 } },
4349 },
4350 /* BPF_JMP | BPF_JSET | BPF_X */
4351 {
4352 "JMP_JSET_X: if (0x3 & 0x2) return 1",
4353 .u.insns_int = {
4354 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4355 BPF_LD_IMM64(R1, 3),
4356 BPF_LD_IMM64(R2, 2),
4357 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
4358 BPF_EXIT_INSN(),
4359 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4360 BPF_EXIT_INSN(),
4361 },
4362 INTERNAL,
4363 { },
4364 { { 0, 1 } },
4365 },
4366 {
4367 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
4368 .u.insns_int = {
4369 BPF_ALU32_IMM(BPF_MOV, R0, 0),
4370 BPF_LD_IMM64(R1, 3),
4371 BPF_LD_IMM64(R2, 0xffffffff),
4372 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
4373 BPF_EXIT_INSN(),
4374 BPF_ALU32_IMM(BPF_MOV, R0, 1),
4375 BPF_EXIT_INSN(),
4376 },
4377 INTERNAL,
4378 { },
4379 { { 0, 1 } },
4380 },
Daniel Borkmannbde28bc2015-05-26 22:35:43 +0200[diff] [blame]4381 {
4382 "JMP_JA: Jump, gap, jump, ...",
4383 { },
4384 CLASSIC | FLAG_NO_DATA,
4385 { },
4386 { { 0, 0xababcbac } },
4387 .fill_helper = bpf_fill_ja,
4388 },
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]4389 { /* Mainly checking JIT here. */
4390 "BPF_MAXINSNS: Maximum possible literals",
4391 { },
4392 CLASSIC | FLAG_NO_DATA,
4393 { },
4394 { { 0, 0xffffffff } },
4395 .fill_helper = bpf_fill_maxinsns1,
4396 },
4397 { /* Mainly checking JIT here. */
4398 "BPF_MAXINSNS: Single literal",
4399 { },
4400 CLASSIC | FLAG_NO_DATA,
4401 { },
4402 { { 0, 0xfefefefe } },
4403 .fill_helper = bpf_fill_maxinsns2,
4404 },
4405 { /* Mainly checking JIT here. */
4406 "BPF_MAXINSNS: Run/add until end",
4407 { },
4408 CLASSIC | FLAG_NO_DATA,
4409 { },
4410 { { 0, 0x947bf368 } },
4411 .fill_helper = bpf_fill_maxinsns3,
4412 },
4413 {
4414 "BPF_MAXINSNS: Too many instructions",
4415 { },
4416 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
4417 { },
4418 { },
4419 .fill_helper = bpf_fill_maxinsns4,
4420 },
4421 { /* Mainly checking JIT here. */
4422 "BPF_MAXINSNS: Very long jump",
4423 { },
4424 CLASSIC | FLAG_NO_DATA,
4425 { },
4426 { { 0, 0xabababab } },
4427 .fill_helper = bpf_fill_maxinsns5,
4428 },
4429 { /* Mainly checking JIT here. */
4430 "BPF_MAXINSNS: Ctx heavy transformations",
4431 { },
4432 CLASSIC,
4433 { },
4434 {
4435 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
4436 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
4437 },
4438 .fill_helper = bpf_fill_maxinsns6,
4439 },
4440 { /* Mainly checking JIT here. */
4441 "BPF_MAXINSNS: Call heavy transformations",
4442 { },
4443 CLASSIC | FLAG_NO_DATA,
4444 { },
4445 { { 1, 0 }, { 10, 0 } },
4446 .fill_helper = bpf_fill_maxinsns7,
4447 },
4448 { /* Mainly checking JIT here. */
4449 "BPF_MAXINSNS: Jump heavy test",
4450 { },
4451 CLASSIC | FLAG_NO_DATA,
4452 { },
4453 { { 0, 0xffffffff } },
4454 .fill_helper = bpf_fill_maxinsns8,
4455 },
Daniel Borkmann3b529602015-05-23 01:10:07 +0200[diff] [blame]4456 { /* Mainly checking JIT here. */
4457 "BPF_MAXINSNS: Very long jump backwards",
4458 { },
4459 INTERNAL | FLAG_NO_DATA,
4460 { },
4461 { { 0, 0xcbababab } },
4462 .fill_helper = bpf_fill_maxinsns9,
4463 },
4464 { /* Mainly checking JIT here. */
4465 "BPF_MAXINSNS: Edge hopping nuthouse",
4466 { },
4467 INTERNAL | FLAG_NO_DATA,
4468 { },
4469 { { 0, 0xabababac } },
4470 .fill_helper = bpf_fill_maxinsns10,
4471 },
Daniel Borkmannbde28bc2015-05-26 22:35:43 +0200[diff] [blame]4472 {
4473 "BPF_MAXINSNS: Jump, gap, jump, ...",
4474 { },
4475 CLASSIC | FLAG_NO_DATA,
4476 { },
4477 { { 0, 0xababcbac } },
4478 .fill_helper = bpf_fill_maxinsns11,
4479 },
Alexei Starovoitov4d9c5c52015-07-20 20:34:19 -0700[diff] [blame]4480 {
4481 "BPF_MAXINSNS: ld_abs+get_processor_id",
4482 { },
4483 CLASSIC,
4484 { },
4485 { { 1, 0xbee } },
4486 .fill_helper = bpf_fill_ld_abs_get_processor_id,
4487 },
4488 {
4489 "BPF_MAXINSNS: ld_abs+vlan_push/pop",
4490 { },
4491 INTERNAL,
4492 { 0x34 },
4493 { { 1, 0xbef } },
4494 .fill_helper = bpf_fill_ld_abs_vlan_push_pop,
4495 },
Nicolas Schichan2cf1ad72015-08-04 15:19:09 +0200[diff] [blame]4496 /*
4497 * LD_IND / LD_ABS on fragmented SKBs
4498 */
4499 {
4500 "LD_IND byte frag",
4501 .u.insns = {
4502 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4503 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
4504 BPF_STMT(BPF_RET | BPF_A, 0x0),
4505 },
4506 CLASSIC | FLAG_SKB_FRAG,
4507 { },
4508 { {0x40, 0x42} },
4509 .frag_data = {
4510 0x42, 0x00, 0x00, 0x00,
4511 0x43, 0x44, 0x00, 0x00,
4512 0x21, 0x07, 0x19, 0x83,
4513 },
4514 },
4515 {
4516 "LD_IND halfword frag",
4517 .u.insns = {
4518 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4519 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
4520 BPF_STMT(BPF_RET | BPF_A, 0x0),
4521 },
4522 CLASSIC | FLAG_SKB_FRAG,
4523 { },
4524 { {0x40, 0x4344} },
4525 .frag_data = {
4526 0x42, 0x00, 0x00, 0x00,
4527 0x43, 0x44, 0x00, 0x00,
4528 0x21, 0x07, 0x19, 0x83,
4529 },
4530 },
4531 {
4532 "LD_IND word frag",
4533 .u.insns = {
4534 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4535 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
4536 BPF_STMT(BPF_RET | BPF_A, 0x0),
4537 },
4538 CLASSIC | FLAG_SKB_FRAG,
4539 { },
4540 { {0x40, 0x21071983} },
4541 .frag_data = {
4542 0x42, 0x00, 0x00, 0x00,
4543 0x43, 0x44, 0x00, 0x00,
4544 0x21, 0x07, 0x19, 0x83,
4545 },
4546 },
4547 {
4548 "LD_IND halfword mixed head/frag",
4549 .u.insns = {
4550 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4551 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4552 BPF_STMT(BPF_RET | BPF_A, 0x0),
4553 },
4554 CLASSIC | FLAG_SKB_FRAG,
4555 { [0x3e] = 0x25, [0x3f] = 0x05, },
4556 { {0x40, 0x0519} },
4557 .frag_data = { 0x19, 0x82 },
4558 },
4559 {
4560 "LD_IND word mixed head/frag",
4561 .u.insns = {
4562 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
4563 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4564 BPF_STMT(BPF_RET | BPF_A, 0x0),
4565 },
4566 CLASSIC | FLAG_SKB_FRAG,
4567 { [0x3e] = 0x25, [0x3f] = 0x05, },
4568 { {0x40, 0x25051982} },
4569 .frag_data = { 0x19, 0x82 },
4570 },
4571 {
4572 "LD_ABS byte frag",
4573 .u.insns = {
4574 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
4575 BPF_STMT(BPF_RET | BPF_A, 0x0),
4576 },
4577 CLASSIC | FLAG_SKB_FRAG,
4578 { },
4579 { {0x40, 0x42} },
4580 .frag_data = {
4581 0x42, 0x00, 0x00, 0x00,
4582 0x43, 0x44, 0x00, 0x00,
4583 0x21, 0x07, 0x19, 0x83,
4584 },
4585 },
4586 {
4587 "LD_ABS halfword frag",
4588 .u.insns = {
4589 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
4590 BPF_STMT(BPF_RET | BPF_A, 0x0),
4591 },
4592 CLASSIC | FLAG_SKB_FRAG,
4593 { },
4594 { {0x40, 0x4344} },
4595 .frag_data = {
4596 0x42, 0x00, 0x00, 0x00,
4597 0x43, 0x44, 0x00, 0x00,
4598 0x21, 0x07, 0x19, 0x83,
4599 },
4600 },
4601 {
4602 "LD_ABS word frag",
4603 .u.insns = {
4604 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
4605 BPF_STMT(BPF_RET | BPF_A, 0x0),
4606 },
4607 CLASSIC | FLAG_SKB_FRAG,
4608 { },
4609 { {0x40, 0x21071983} },
4610 .frag_data = {
4611 0x42, 0x00, 0x00, 0x00,
4612 0x43, 0x44, 0x00, 0x00,
4613 0x21, 0x07, 0x19, 0x83,
4614 },
4615 },
4616 {
4617 "LD_ABS halfword mixed head/frag",
4618 .u.insns = {
4619 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
4620 BPF_STMT(BPF_RET | BPF_A, 0x0),
4621 },
4622 CLASSIC | FLAG_SKB_FRAG,
4623 { [0x3e] = 0x25, [0x3f] = 0x05, },
4624 { {0x40, 0x0519} },
4625 .frag_data = { 0x19, 0x82 },
4626 },
4627 {
4628 "LD_ABS word mixed head/frag",
4629 .u.insns = {
4630 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
4631 BPF_STMT(BPF_RET | BPF_A, 0x0),
4632 },
4633 CLASSIC | FLAG_SKB_FRAG,
4634 { [0x3e] = 0x25, [0x3f] = 0x05, },
4635 { {0x40, 0x25051982} },
4636 .frag_data = { 0x19, 0x82 },
4637 },
Nicolas Schichan08fcb082015-08-04 15:19:11 +0200[diff] [blame^]4638 /*
4639 * LD_IND / LD_ABS on non fragmented SKBs
4640 */
4641 {
4642 /*
4643 * this tests that the JIT/interpreter correctly resets X
4644 * before using it in an LD_IND instruction.
4645 */
4646 "LD_IND byte default X",
4647 .u.insns = {
4648 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
4649 BPF_STMT(BPF_RET | BPF_A, 0x0),
4650 },
4651 CLASSIC,
4652 { [0x1] = 0x42 },
4653 { {0x40, 0x42 } },
4654 },
4655 {
4656 "LD_IND byte positive offset",
4657 .u.insns = {
4658 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
4659 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
4660 BPF_STMT(BPF_RET | BPF_A, 0x0),
4661 },
4662 CLASSIC,
4663 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
4664 { {0x40, 0x82 } },
4665 },
4666 {
4667 "LD_IND byte negative offset",
4668 .u.insns = {
4669 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
4670 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
4671 BPF_STMT(BPF_RET | BPF_A, 0x0),
4672 },
4673 CLASSIC,
4674 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
4675 { {0x40, 0x05 } },
4676 },
4677 {
4678 "LD_IND halfword positive offset",
4679 .u.insns = {
4680 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4681 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
4682 BPF_STMT(BPF_RET | BPF_A, 0x0),
4683 },
4684 CLASSIC,
4685 {
4686 [0x1c] = 0xaa, [0x1d] = 0x55,
4687 [0x1e] = 0xbb, [0x1f] = 0x66,
4688 [0x20] = 0xcc, [0x21] = 0x77,
4689 [0x22] = 0xdd, [0x23] = 0x88,
4690 },
4691 { {0x40, 0xdd88 } },
4692 },
4693 {
4694 "LD_IND halfword negative offset",
4695 .u.insns = {
4696 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4697 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
4698 BPF_STMT(BPF_RET | BPF_A, 0x0),
4699 },
4700 CLASSIC,
4701 {
4702 [0x1c] = 0xaa, [0x1d] = 0x55,
4703 [0x1e] = 0xbb, [0x1f] = 0x66,
4704 [0x20] = 0xcc, [0x21] = 0x77,
4705 [0x22] = 0xdd, [0x23] = 0x88,
4706 },
4707 { {0x40, 0xbb66 } },
4708 },
4709 {
4710 "LD_IND halfword unaligned",
4711 .u.insns = {
4712 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4713 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
4714 BPF_STMT(BPF_RET | BPF_A, 0x0),
4715 },
4716 CLASSIC,
4717 {
4718 [0x1c] = 0xaa, [0x1d] = 0x55,
4719 [0x1e] = 0xbb, [0x1f] = 0x66,
4720 [0x20] = 0xcc, [0x21] = 0x77,
4721 [0x22] = 0xdd, [0x23] = 0x88,
4722 },
4723 { {0x40, 0x66cc } },
4724 },
4725 {
4726 "LD_IND word positive offset",
4727 .u.insns = {
4728 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4729 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
4730 BPF_STMT(BPF_RET | BPF_A, 0x0),
4731 },
4732 CLASSIC,
4733 {
4734 [0x1c] = 0xaa, [0x1d] = 0x55,
4735 [0x1e] = 0xbb, [0x1f] = 0x66,
4736 [0x20] = 0xcc, [0x21] = 0x77,
4737 [0x22] = 0xdd, [0x23] = 0x88,
4738 [0x24] = 0xee, [0x25] = 0x99,
4739 [0x26] = 0xff, [0x27] = 0xaa,
4740 },
4741 { {0x40, 0xee99ffaa } },
4742 },
4743 {
4744 "LD_IND word negative offset",
4745 .u.insns = {
4746 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4747 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
4748 BPF_STMT(BPF_RET | BPF_A, 0x0),
4749 },
4750 CLASSIC,
4751 {
4752 [0x1c] = 0xaa, [0x1d] = 0x55,
4753 [0x1e] = 0xbb, [0x1f] = 0x66,
4754 [0x20] = 0xcc, [0x21] = 0x77,
4755 [0x22] = 0xdd, [0x23] = 0x88,
4756 [0x24] = 0xee, [0x25] = 0x99,
4757 [0x26] = 0xff, [0x27] = 0xaa,
4758 },
4759 { {0x40, 0xaa55bb66 } },
4760 },
4761 {
4762 "LD_IND word unaligned (addr & 3 == 2)",
4763 .u.insns = {
4764 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4765 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
4766 BPF_STMT(BPF_RET | BPF_A, 0x0),
4767 },
4768 CLASSIC,
4769 {
4770 [0x1c] = 0xaa, [0x1d] = 0x55,
4771 [0x1e] = 0xbb, [0x1f] = 0x66,
4772 [0x20] = 0xcc, [0x21] = 0x77,
4773 [0x22] = 0xdd, [0x23] = 0x88,
4774 [0x24] = 0xee, [0x25] = 0x99,
4775 [0x26] = 0xff, [0x27] = 0xaa,
4776 },
4777 { {0x40, 0xbb66cc77 } },
4778 },
4779 {
4780 "LD_IND word unaligned (addr & 3 == 1)",
4781 .u.insns = {
4782 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4783 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
4784 BPF_STMT(BPF_RET | BPF_A, 0x0),
4785 },
4786 CLASSIC,
4787 {
4788 [0x1c] = 0xaa, [0x1d] = 0x55,
4789 [0x1e] = 0xbb, [0x1f] = 0x66,
4790 [0x20] = 0xcc, [0x21] = 0x77,
4791 [0x22] = 0xdd, [0x23] = 0x88,
4792 [0x24] = 0xee, [0x25] = 0x99,
4793 [0x26] = 0xff, [0x27] = 0xaa,
4794 },
4795 { {0x40, 0x55bb66cc } },
4796 },
4797 {
4798 "LD_IND word unaligned (addr & 3 == 3)",
4799 .u.insns = {
4800 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
4801 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
4802 BPF_STMT(BPF_RET | BPF_A, 0x0),
4803 },
4804 CLASSIC,
4805 {
4806 [0x1c] = 0xaa, [0x1d] = 0x55,
4807 [0x1e] = 0xbb, [0x1f] = 0x66,
4808 [0x20] = 0xcc, [0x21] = 0x77,
4809 [0x22] = 0xdd, [0x23] = 0x88,
4810 [0x24] = 0xee, [0x25] = 0x99,
4811 [0x26] = 0xff, [0x27] = 0xaa,
4812 },
4813 { {0x40, 0x66cc77dd } },
4814 },
4815 {
4816 "LD_ABS byte",
4817 .u.insns = {
4818 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
4819 BPF_STMT(BPF_RET | BPF_A, 0x0),
4820 },
4821 CLASSIC,
4822 {
4823 [0x1c] = 0xaa, [0x1d] = 0x55,
4824 [0x1e] = 0xbb, [0x1f] = 0x66,
4825 [0x20] = 0xcc, [0x21] = 0x77,
4826 [0x22] = 0xdd, [0x23] = 0x88,
4827 [0x24] = 0xee, [0x25] = 0x99,
4828 [0x26] = 0xff, [0x27] = 0xaa,
4829 },
4830 { {0x40, 0xcc } },
4831 },
4832 {
4833 "LD_ABS halfword",
4834 .u.insns = {
4835 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
4836 BPF_STMT(BPF_RET | BPF_A, 0x0),
4837 },
4838 CLASSIC,
4839 {
4840 [0x1c] = 0xaa, [0x1d] = 0x55,
4841 [0x1e] = 0xbb, [0x1f] = 0x66,
4842 [0x20] = 0xcc, [0x21] = 0x77,
4843 [0x22] = 0xdd, [0x23] = 0x88,
4844 [0x24] = 0xee, [0x25] = 0x99,
4845 [0x26] = 0xff, [0x27] = 0xaa,
4846 },
4847 { {0x40, 0xdd88 } },
4848 },
4849 {
4850 "LD_ABS halfword unaligned",
4851 .u.insns = {
4852 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
4853 BPF_STMT(BPF_RET | BPF_A, 0x0),
4854 },
4855 CLASSIC,
4856 {
4857 [0x1c] = 0xaa, [0x1d] = 0x55,
4858 [0x1e] = 0xbb, [0x1f] = 0x66,
4859 [0x20] = 0xcc, [0x21] = 0x77,
4860 [0x22] = 0xdd, [0x23] = 0x88,
4861 [0x24] = 0xee, [0x25] = 0x99,
4862 [0x26] = 0xff, [0x27] = 0xaa,
4863 },
4864 { {0x40, 0x99ff } },
4865 },
4866 {
4867 "LD_ABS word",
4868 .u.insns = {
4869 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
4870 BPF_STMT(BPF_RET | BPF_A, 0x0),
4871 },
4872 CLASSIC,
4873 {
4874 [0x1c] = 0xaa, [0x1d] = 0x55,
4875 [0x1e] = 0xbb, [0x1f] = 0x66,
4876 [0x20] = 0xcc, [0x21] = 0x77,
4877 [0x22] = 0xdd, [0x23] = 0x88,
4878 [0x24] = 0xee, [0x25] = 0x99,
4879 [0x26] = 0xff, [0x27] = 0xaa,
4880 },
4881 { {0x40, 0xaa55bb66 } },
4882 },
4883 {
4884 "LD_ABS word unaligned (addr & 3 == 2)",
4885 .u.insns = {
4886 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
4887 BPF_STMT(BPF_RET | BPF_A, 0x0),
4888 },
4889 CLASSIC,
4890 {
4891 [0x1c] = 0xaa, [0x1d] = 0x55,
4892 [0x1e] = 0xbb, [0x1f] = 0x66,
4893 [0x20] = 0xcc, [0x21] = 0x77,
4894 [0x22] = 0xdd, [0x23] = 0x88,
4895 [0x24] = 0xee, [0x25] = 0x99,
4896 [0x26] = 0xff, [0x27] = 0xaa,
4897 },
4898 { {0x40, 0xdd88ee99 } },
4899 },
4900 {
4901 "LD_ABS word unaligned (addr & 3 == 1)",
4902 .u.insns = {
4903 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
4904 BPF_STMT(BPF_RET | BPF_A, 0x0),
4905 },
4906 CLASSIC,
4907 {
4908 [0x1c] = 0xaa, [0x1d] = 0x55,
4909 [0x1e] = 0xbb, [0x1f] = 0x66,
4910 [0x20] = 0xcc, [0x21] = 0x77,
4911 [0x22] = 0xdd, [0x23] = 0x88,
4912 [0x24] = 0xee, [0x25] = 0x99,
4913 [0x26] = 0xff, [0x27] = 0xaa,
4914 },
4915 { {0x40, 0x77dd88ee } },
4916 },
4917 {
4918 "LD_ABS word unaligned (addr & 3 == 3)",
4919 .u.insns = {
4920 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
4921 BPF_STMT(BPF_RET | BPF_A, 0x0),
4922 },
4923 CLASSIC,
4924 {
4925 [0x1c] = 0xaa, [0x1d] = 0x55,
4926 [0x1e] = 0xbb, [0x1f] = 0x66,
4927 [0x20] = 0xcc, [0x21] = 0x77,
4928 [0x22] = 0xdd, [0x23] = 0x88,
4929 [0x24] = 0xee, [0x25] = 0x99,
4930 [0x26] = 0xff, [0x27] = 0xaa,
4931 },
4932 { {0x40, 0x88ee99ff } },
4933 },
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4934};
4935
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4936static struct net_device dev;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4937
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4938static struct sk_buff *populate_skb(char *buf, int size)
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4939{
4940 struct sk_buff *skb;
4941
4942 if (size >= MAX_DATA)
4943 return NULL;
4944
4945 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
4946 if (!skb)
4947 return NULL;
4948
4949 memcpy(__skb_put(skb, size), buf, size);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4950
4951 /* Initialize a fake skb with test pattern. */
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4952 skb_reset_mac_header(skb);
4953 skb->protocol = htons(ETH_P_IP);
4954 skb->pkt_type = SKB_TYPE;
4955 skb->mark = SKB_MARK;
4956 skb->hash = SKB_HASH;
4957 skb->queue_mapping = SKB_QUEUE_MAP;
4958 skb->vlan_tci = SKB_VLAN_TCI;
4959 skb->dev = &dev;
4960 skb->dev->ifindex = SKB_DEV_IFINDEX;
4961 skb->dev->type = SKB_DEV_TYPE;
4962 skb_set_network_header(skb, min(size, ETH_HLEN));
4963
4964 return skb;
4965}
4966
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4967static void *generate_test_data(struct bpf_test *test, int sub)
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4968{
Nicolas Schichanbac142a2015-08-04 15:19:08 +0200[diff] [blame]4969 struct sk_buff *skb;
4970 struct page *page;
4971
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4972 if (test->aux & FLAG_NO_DATA)
4973 return NULL;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]4974
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]4975 /* Test case expects an skb, so populate one. Various
4976 * subtests generate skbs of different sizes based on
4977 * the same data.
4978 */
Nicolas Schichanbac142a2015-08-04 15:19:08 +0200[diff] [blame]4979 skb = populate_skb(test->data, test->test[sub].data_size);
4980 if (!skb)
4981 return NULL;
4982
4983 if (test->aux & FLAG_SKB_FRAG) {
4984 /*
4985 * when the test requires a fragmented skb, add a
4986 * single fragment to the skb, filled with
4987 * test->frag_data.
4988 */
4989 void *ptr;
4990
4991 page = alloc_page(GFP_KERNEL);
4992
4993 if (!page)
4994 goto err_kfree_skb;
4995
4996 ptr = kmap(page);
4997 if (!ptr)
4998 goto err_free_page;
4999 memcpy(ptr, test->frag_data, MAX_DATA);
5000 kunmap(page);
5001 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
5002 }
5003
5004 return skb;
5005
5006err_free_page:
5007 __free_page(page);
5008err_kfree_skb:
5009 kfree_skb(skb);
5010 return NULL;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5011}
5012
5013static void release_test_data(const struct bpf_test *test, void *data)
5014{
5015 if (test->aux & FLAG_NO_DATA)
5016 return;
5017
5018 kfree_skb(data);
5019}
5020
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5021static int filter_length(int which)
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5022{
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5023 struct sock_filter *fp;
5024 int len;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5025
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5026 if (tests[which].fill_helper)
5027 return tests[which].u.ptr.len;
5028
5029 fp = tests[which].u.insns;
Chema Gonzaleze9d94502014-05-30 10:15:12 -0700[diff] [blame]5030 for (len = MAX_INSNS - 1; len > 0; --len)
5031 if (fp[len].code != 0 || fp[len].k != 0)
5032 break;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5033
Chema Gonzaleze9d94502014-05-30 10:15:12 -0700[diff] [blame]5034 return len + 1;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5035}
5036
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5037static void *filter_pointer(int which)
5038{
5039 if (tests[which].fill_helper)
5040 return tests[which].u.ptr.insns;
5041 else
5042 return tests[which].u.insns;
5043}
5044
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5045static struct bpf_prog *generate_filter(int which, int *err)
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5046{
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5047 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5048 unsigned int flen = filter_length(which);
5049 void *fptr = filter_pointer(which);
5050 struct sock_fprog_kern fprog;
5051 struct bpf_prog *fp;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5052
5053 switch (test_type) {
5054 case CLASSIC:
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5055 fprog.filter = fptr;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5056 fprog.len = flen;
5057
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5058 *err = bpf_prog_create(&fp, &fprog);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5059 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
5060 if (*err == -EINVAL) {
5061 pr_cont("PASS\n");
5062 /* Verifier rejected filter as expected. */
5063 *err = 0;
5064 return NULL;
5065 } else {
5066 pr_cont("UNEXPECTED_PASS\n");
5067 /* Verifier didn't reject the test that's
5068 * bad enough, just return!
5069 */
5070 *err = -EINVAL;
5071 return NULL;
5072 }
5073 }
5074 /* We don't expect to fail. */
5075 if (*err) {
5076 pr_cont("FAIL to attach err=%d len=%d\n",
5077 *err, fprog.len);
5078 return NULL;
5079 }
5080 break;
5081
5082 case INTERNAL:
Daniel Borkmann60a3b222014-09-02 22:53:44 +0200[diff] [blame]5083 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5084 if (fp == NULL) {
5085 pr_cont("UNEXPECTED_FAIL no memory left\n");
5086 *err = -ENOMEM;
5087 return NULL;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5088 }
5089
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5090 fp->len = flen;
Daniel Borkmann4962fa12015-07-30 12:42:46 +0200[diff] [blame]5091 /* Type doesn't really matter here as long as it's not unspec. */
5092 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5093 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5094
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5095 bpf_prog_select_runtime(fp);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5096 break;
5097 }
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5098
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5099 *err = 0;
5100 return fp;
5101}
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5102
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5103static void release_filter(struct bpf_prog *fp, int which)
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5104{
5105 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5106
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5107 switch (test_type) {
5108 case CLASSIC:
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5109 bpf_prog_destroy(fp);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5110 break;
5111 case INTERNAL:
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5112 bpf_prog_free(fp);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5113 break;
5114 }
5115}
5116
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5117static int __run_one(const struct bpf_prog *fp, const void *data,
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5118 int runs, u64 *duration)
5119{
5120 u64 start, finish;
Alexei Starovoitov25ee7322014-09-19 13:53:51 -0700[diff] [blame]5121 int ret = 0, i;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5122
Alexei Starovoitov4d9c5c52015-07-20 20:34:19 -0700[diff] [blame]5123 start = ktime_get_ns();
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5124
5125 for (i = 0; i < runs; i++)
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5126 ret = BPF_PROG_RUN(fp, data);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5127
Alexei Starovoitov4d9c5c52015-07-20 20:34:19 -0700[diff] [blame]5128 finish = ktime_get_ns();
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5129
Alexei Starovoitov4d9c5c52015-07-20 20:34:19 -0700[diff] [blame]5130 *duration = finish - start;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5131 do_div(*duration, runs);
5132
5133 return ret;
5134}
5135
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5136static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5137{
5138 int err_cnt = 0, i, runs = MAX_TESTRUNS;
5139
5140 for (i = 0; i < MAX_SUBTESTS; i++) {
5141 void *data;
5142 u64 duration;
5143 u32 ret;
5144
5145 if (test->test[i].data_size == 0 &&
5146 test->test[i].result == 0)
5147 break;
5148
5149 data = generate_test_data(test, i);
Nicolas Schichane34684f2015-08-04 15:19:07 +0200[diff] [blame]5150 if (!data && !(test->aux & FLAG_NO_DATA)) {
5151 pr_cont("data generation failed ");
5152 err_cnt++;
5153 break;
5154 }
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5155 ret = __run_one(fp, data, runs, &duration);
5156 release_test_data(test, data);
5157
5158 if (ret == test->test[i].result) {
5159 pr_cont("%lld ", duration);
5160 } else {
5161 pr_cont("ret %d != %d ", ret,
5162 test->test[i].result);
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5163 err_cnt++;
5164 }
5165 }
5166
5167 return err_cnt;
5168}
5169
Nicolas Schichand2648d42015-08-04 15:19:10 +0200[diff] [blame]5170static char test_name[64];
5171module_param_string(test_name, test_name, sizeof(test_name), 0);
5172
5173static int test_id = -1;
5174module_param(test_id, int, 0);
5175
5176static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
5177module_param_array(test_range, int, NULL, 0);
5178
5179static __init int find_test_index(const char *test_name)
5180{
5181 int i;
5182
5183 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5184 if (!strcmp(tests[i].descr, test_name))
5185 return i;
5186 }
5187 return -1;
5188}
5189
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5190static __init int prepare_bpf_tests(void)
5191{
5192 int i;
5193
Nicolas Schichand2648d42015-08-04 15:19:10 +0200[diff] [blame]5194 if (test_id >= 0) {
5195 /*
5196 * if a test_id was specified, use test_range to
5197 * cover only that test.
5198 */
5199 if (test_id >= ARRAY_SIZE(tests)) {
5200 pr_err("test_bpf: invalid test_id specified.\n");
5201 return -EINVAL;
5202 }
5203
5204 test_range[0] = test_id;
5205 test_range[1] = test_id;
5206 } else if (*test_name) {
5207 /*
5208 * if a test_name was specified, find it and setup
5209 * test_range to cover only that test.
5210 */
5211 int idx = find_test_index(test_name);
5212
5213 if (idx < 0) {
5214 pr_err("test_bpf: no test named '%s' found.\n",
5215 test_name);
5216 return -EINVAL;
5217 }
5218 test_range[0] = idx;
5219 test_range[1] = idx;
5220 } else {
5221 /*
5222 * check that the supplied test_range is valid.
5223 */
5224 if (test_range[0] >= ARRAY_SIZE(tests) ||
5225 test_range[1] >= ARRAY_SIZE(tests) ||
5226 test_range[0] < 0 || test_range[1] < 0) {
5227 pr_err("test_bpf: test_range is out of bound.\n");
5228 return -EINVAL;
5229 }
5230
5231 if (test_range[1] < test_range[0]) {
5232 pr_err("test_bpf: test_range is ending before it starts.\n");
5233 return -EINVAL;
5234 }
5235 }
5236
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5237 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5238 if (tests[i].fill_helper &&
5239 tests[i].fill_helper(&tests[i]) < 0)
5240 return -ENOMEM;
5241 }
5242
5243 return 0;
5244}
5245
5246static __init void destroy_bpf_tests(void)
5247{
5248 int i;
5249
5250 for (i = 0; i < ARRAY_SIZE(tests); i++) {
5251 if (tests[i].fill_helper)
5252 kfree(tests[i].u.ptr.insns);
5253 }
5254}
5255
Nicolas Schichand2648d42015-08-04 15:19:10 +0200[diff] [blame]5256static bool exclude_test(int test_id)
5257{
5258 return test_id < test_range[0] || test_id > test_range[1];
5259}
5260
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5261static __init int test_bpf(void)
5262{
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5263 int i, err_cnt = 0, pass_cnt = 0;
Daniel Borkmann327941f2015-04-30 16:17:27 +0200[diff] [blame]5264 int jit_cnt = 0, run_cnt = 0;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5265
5266 for (i = 0; i < ARRAY_SIZE(tests); i++) {
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700[diff] [blame]5267 struct bpf_prog *fp;
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5268 int err;
5269
Nicolas Schichand2648d42015-08-04 15:19:10 +0200[diff] [blame]5270 if (exclude_test(i))
5271 continue;
5272
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5273 pr_info("#%d %s ", i, tests[i].descr);
5274
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5275 fp = generate_filter(i, &err);
5276 if (fp == NULL) {
5277 if (err == 0) {
5278 pass_cnt++;
5279 continue;
5280 }
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5281
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5282 return err;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5283 }
Daniel Borkmann327941f2015-04-30 16:17:27 +0200[diff] [blame]5284
5285 pr_cont("jited:%u ", fp->jited);
5286
5287 run_cnt++;
5288 if (fp->jited)
5289 jit_cnt++;
5290
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5291 err = run_one(fp, &tests[i]);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5292 release_filter(fp, i);
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5293
5294 if (err) {
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5295 pr_cont("FAIL (%d times)\n", err);
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5296 err_cnt++;
5297 } else {
5298 pr_cont("PASS\n");
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5299 pass_cnt++;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5300 }
5301 }
5302
Daniel Borkmann327941f2015-04-30 16:17:27 +0200[diff] [blame]5303 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
5304 pass_cnt, err_cnt, jit_cnt, run_cnt);
5305
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5306 return err_cnt ? -EINVAL : 0;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5307}
5308
5309static int __init test_bpf_init(void)
5310{
Daniel Borkmanna4afd37b2015-05-13 13:12:43 +0200[diff] [blame]5311 int ret;
5312
5313 ret = prepare_bpf_tests();
5314 if (ret < 0)
5315 return ret;
5316
5317 ret = test_bpf();
5318
5319 destroy_bpf_tests();
5320 return ret;
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5321}
5322
5323static void __exit test_bpf_exit(void)
5324{
5325}
5326
5327module_init(test_bpf_init);
5328module_exit(test_bpf_exit);
Daniel Borkmann10f18e02014-05-23 18:44:00 +0200[diff] [blame]5329
Alexei Starovoitov64a89462014-05-08 14:10:52 -0700[diff] [blame]5330MODULE_LICENSE("GPL");