projects / GitHub / exynos8895 / android_kernel_samsung_universal8895.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: filter: improve test case framework
[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / lib / test_bpf.c
CommitLineData
64a8946b
AS		 1/*
2 * Testsuite for BPF interpreter and BPF JIT compiler
3 *
4 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 */
15
16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18#include <linux/init.h>
19#include <linux/module.h>
20#include <linux/filter.h>
21#include <linux/skbuff.h>
22#include <linux/netdevice.h>
23#include <linux/if_vlan.h>
24
10f18e0b 25/* General test specific settings */
64a8946b 26#define MAX_SUBTESTS 3
10f18e0b 27#define MAX_TESTRUNS 10000
64a8946b
AS		 28#define MAX_DATA 128
29#define MAX_INSNS 512
30#define MAX_K 0xffffFFFF
31
10f18e0b 32/* Few constants used to init test 'skb' */
64a8946b
AS		 33#define SKB_TYPE 3
34#define SKB_MARK 0x1234aaaa
35#define SKB_HASH 0x1234aaab
36#define SKB_QUEUE_MAP 123
37#define SKB_VLAN_TCI 0xffff
38#define SKB_DEV_IFINDEX 577
39#define SKB_DEV_TYPE 588
40
10f18e0b
DB		 41/* Redefine REGs to make tests less verbose */
42#define R0 BPF_REG_0
43#define R1 BPF_REG_1
44#define R2 BPF_REG_2
45#define R3 BPF_REG_3
46#define R4 BPF_REG_4
47#define R5 BPF_REG_5
48#define R6 BPF_REG_6
49#define R7 BPF_REG_7
50#define R8 BPF_REG_8
51#define R9 BPF_REG_9
52#define R10 BPF_REG_10
53
54/* Flags that can be passed to test cases */
55#define FLAG_NO_DATA BIT(0)
56#define FLAG_EXPECTED_FAIL BIT(1)
57
58enum {
59 CLASSIC = BIT(6), /* Old BPF instructions only. */
60 INTERNAL = BIT(7), /* Extended instruction set. */
61};
62
63#define TEST_TYPE_MASK (CLASSIC | INTERNAL)
64a8946b
AS		 64
65struct bpf_test {
66 const char *descr;
67 union {
68 struct sock_filter insns[MAX_INSNS];
69 struct sock_filter_int insns_int[MAX_INSNS];
ece80490 70 } u;
10f18e0b 71 __u8 aux;
64a8946b
AS		 72 __u8 data[MAX_DATA];
73 struct {
74 int data_size;
75 __u32 result;
76 } test[MAX_SUBTESTS];
77};
78
79static struct bpf_test tests[] = {
80 {
81 "TAX",
ece80490 82 .u.insns = {
64a8946b
AS		 83 BPF_STMT(BPF_LD | BPF_IMM, 1),
84 BPF_STMT(BPF_MISC | BPF_TAX, 0),
85 BPF_STMT(BPF_LD | BPF_IMM, 2),
86 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
87 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
88 BPF_STMT(BPF_MISC | BPF_TAX, 0),
89 BPF_STMT(BPF_LD | BPF_LEN, 0),
90 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
91 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
92 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
93 BPF_STMT(BPF_RET | BPF_A, 0)
94 },
10f18e0b 95 CLASSIC,
64a8946b
AS		 96 { 10, 20, 30, 40, 50 },
97 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
98 },
9def624a
AS		 99 {
100 "TXA",
ece80490 101 .u.insns = {
9def624a
AS		 102 BPF_STMT(BPF_LDX | BPF_LEN, 0),
103 BPF_STMT(BPF_MISC | BPF_TXA, 0),
104 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
105 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
106 },
10f18e0b 107 CLASSIC,
9def624a
AS		 108 { 10, 20, 30, 40, 50 },
109 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
110 },
111 {
112 "ADD_SUB_MUL_K",
ece80490 113 .u.insns = {
9def624a
AS		 114 BPF_STMT(BPF_LD | BPF_IMM, 1),
115 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
116 BPF_STMT(BPF_LDX | BPF_IMM, 3),
117 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
118 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
119 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
120 BPF_STMT(BPF_RET | BPF_A, 0)
121 },
10f18e0b 122 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 123 { },
124 { { 0, 0xfffffffd } }
125 },
126 {
127 "DIV_KX",
ece80490 128 .u.insns = {
9def624a
AS		 129 BPF_STMT(BPF_LD | BPF_IMM, 8),
130 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
131 BPF_STMT(BPF_MISC | BPF_TAX, 0),
132 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
133 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
134 BPF_STMT(BPF_MISC | BPF_TAX, 0),
135 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
136 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
137 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
138 BPF_STMT(BPF_RET | BPF_A, 0)
139 },
10f18e0b 140 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 141 { },
142 { { 0, 0x40000001 } }
143 },
144 {
145 "AND_OR_LSH_K",
ece80490 146 .u.insns = {
9def624a
AS		 147 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
148 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
149 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
150 BPF_STMT(BPF_MISC | BPF_TAX, 0),
151 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
152 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
153 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
154 BPF_STMT(BPF_RET | BPF_A, 0)
155 },
10f18e0b 156 CLASSIC | FLAG_NO_DATA,
9def624a
AS		 157 { },
158 { { 0, 0x800000ff }, { 1, 0x800000ff } },
159 },
160 {
161 "LD_IND",
ece80490 162 .u.insns = {
9def624a
AS		 163 BPF_STMT(BPF_LDX | BPF_LEN, 0),
164 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
165 BPF_STMT(BPF_RET | BPF_K, 1)
166 },
10f18e0b 167 CLASSIC,
9def624a
AS		 168 { },
169 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
170 },
171 {
172 "LD_ABS",
ece80490 173 .u.insns = {
9def624a
AS		 174 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
175 BPF_STMT(BPF_RET | BPF_K, 1)
176 },
10f18e0b 177 CLASSIC,
9def624a
AS		 178 { },
179 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
180 },
181 {
182 "LD_ABS_LL",
ece80490 183 .u.insns = {
9def624a
AS		 184 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
185 BPF_STMT(BPF_MISC | BPF_TAX, 0),
186 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
187 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
188 BPF_STMT(BPF_RET | BPF_A, 0)
189 },
10f18e0b 190 CLASSIC,
9def624a
AS		 191 { 1, 2, 3 },
192 { { 1, 0 }, { 2, 3 } },
193 },
194 {
195 "LD_IND_LL",
ece80490 196 .u.insns = {
9def624a
AS		 197 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
198 BPF_STMT(BPF_LDX | BPF_LEN, 0),
199 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
200 BPF_STMT(BPF_MISC | BPF_TAX, 0),
201 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
202 BPF_STMT(BPF_RET | BPF_A, 0)
203 },
10f18e0b 204 CLASSIC,
9def624a
AS		 205 { 1, 2, 3, 0xff },
206 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
207 },
208 {
209 "LD_ABS_NET",
ece80490 210 .u.insns = {
9def624a
AS		 211 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
212 BPF_STMT(BPF_MISC | BPF_TAX, 0),
213 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
214 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
215 BPF_STMT(BPF_RET | BPF_A, 0)
216 },
10f18e0b 217 CLASSIC,
9def624a
AS		 218 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
219 { { 15, 0 }, { 16, 3 } },
220 },
221 {
222 "LD_IND_NET",
ece80490 223 .u.insns = {
9def624a
AS		 224 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
225 BPF_STMT(BPF_LDX | BPF_LEN, 0),
226 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
227 BPF_STMT(BPF_MISC | BPF_TAX, 0),
228 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
229 BPF_STMT(BPF_RET | BPF_A, 0)
230 },
10f18e0b 231 CLASSIC,
9def624a
AS		 232 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
233 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
234 },
235 {
236 "LD_PKTTYPE",
ece80490 237 .u.insns = {
9def624a
AS		 238 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
239 SKF_AD_OFF + SKF_AD_PKTTYPE),
240 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
241 BPF_STMT(BPF_RET | BPF_K, 1),
242 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
243 SKF_AD_OFF + SKF_AD_PKTTYPE),
244 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
245 BPF_STMT(BPF_RET | BPF_K, 1),
246 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
247 SKF_AD_OFF + SKF_AD_PKTTYPE),
248 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
249 BPF_STMT(BPF_RET | BPF_K, 1),
250 BPF_STMT(BPF_RET | BPF_A, 0)
251 },
10f18e0b 252 CLASSIC,
9def624a
AS		 253 { },
254 { { 1, 3 }, { 10, 3 } },
255 },
256 {
257 "LD_MARK",
ece80490 258 .u.insns = {
9def624a
AS		 259 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
260 SKF_AD_OFF + SKF_AD_MARK),
261 BPF_STMT(BPF_RET | BPF_A, 0)
262 },
10f18e0b 263 CLASSIC,
9def624a
AS		 264 { },
265 { { 1, SKB_MARK}, { 10, SKB_MARK} },
266 },
267 {
268 "LD_RXHASH",
ece80490 269 .u.insns = {
9def624a
AS		 270 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
271 SKF_AD_OFF + SKF_AD_RXHASH),
272 BPF_STMT(BPF_RET | BPF_A, 0)
273 },
10f18e0b 274 CLASSIC,
9def624a
AS		 275 { },
276 { { 1, SKB_HASH}, { 10, SKB_HASH} },
277 },
278 {
279 "LD_QUEUE",
ece80490 280 .u.insns = {
9def624a
AS		 281 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
282 SKF_AD_OFF + SKF_AD_QUEUE),
283 BPF_STMT(BPF_RET | BPF_A, 0)
284 },
10f18e0b 285 CLASSIC,
9def624a
AS		 286 { },
287 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
288 },
289 {
290 "LD_PROTOCOL",
ece80490 291 .u.insns = {
9def624a
AS		 292 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
293 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
294 BPF_STMT(BPF_RET | BPF_K, 0),
295 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
296 SKF_AD_OFF + SKF_AD_PROTOCOL),
297 BPF_STMT(BPF_MISC | BPF_TAX, 0),
298 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
299 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
300 BPF_STMT(BPF_RET | BPF_K, 0),
301 BPF_STMT(BPF_MISC | BPF_TXA, 0),
302 BPF_STMT(BPF_RET | BPF_A, 0)
303 },
10f18e0b 304 CLASSIC,
9def624a
AS		 305 { 10, 20, 30 },
306 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
307 },
308 {
309 "LD_VLAN_TAG",
ece80490 310 .u.insns = {
9def624a
AS		 311 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
312 SKF_AD_OFF + SKF_AD_VLAN_TAG),
313 BPF_STMT(BPF_RET | BPF_A, 0)
314 },
10f18e0b 315 CLASSIC,
9def624a
AS		 316 { },
317 {
318 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT },
319 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }
320 },
321 },
322 {
323 "LD_VLAN_TAG_PRESENT",
ece80490 324 .u.insns = {
9def624a
AS		 325 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
326 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
327 BPF_STMT(BPF_RET | BPF_A, 0)
328 },
10f18e0b 329 CLASSIC,
9def624a
AS		 330 { },
331 {
332 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
333 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
334 },
335 },
336 {
337 "LD_IFINDEX",
ece80490 338 .u.insns = {
9def624a
AS		 339 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
340 SKF_AD_OFF + SKF_AD_IFINDEX),
341 BPF_STMT(BPF_RET | BPF_A, 0)
342 },
10f18e0b 343 CLASSIC,
9def624a
AS		 344 { },
345 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
346 },
347 {
348 "LD_HATYPE",
ece80490 349 .u.insns = {
9def624a
AS		 350 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
351 SKF_AD_OFF + SKF_AD_HATYPE),
352 BPF_STMT(BPF_RET | BPF_A, 0)
353 },
10f18e0b 354 CLASSIC,
9def624a
AS		 355 { },
356 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
357 },
358 {
359 "LD_CPU",
ece80490 360 .u.insns = {
9def624a
AS		 361 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
362 SKF_AD_OFF + SKF_AD_CPU),
363 BPF_STMT(BPF_MISC | BPF_TAX, 0),
364 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
365 SKF_AD_OFF + SKF_AD_CPU),
366 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
367 BPF_STMT(BPF_RET | BPF_A, 0)
368 },
10f18e0b 369 CLASSIC,
9def624a
AS		 370 { },
371 { { 1, 0 }, { 10, 0 } },
372 },
373 {
374 "LD_NLATTR",
ece80490 375 .u.insns = {
9def624a
AS		 376 BPF_STMT(BPF_LDX | BPF_IMM, 1),
377 BPF_STMT(BPF_MISC | BPF_TXA, 0),
378 BPF_STMT(BPF_LDX | BPF_IMM, 3),
379 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
380 SKF_AD_OFF + SKF_AD_NLATTR),
381 BPF_STMT(BPF_RET | BPF_A, 0)
382 },
10f18e0b 383 CLASSIC,
9def624a
AS		 384 { 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
385 { { 4, 0 }, { 20, 5 } },
386 },
387 {
388 "LD_NLATTR_NEST",
ece80490 389 .u.insns = {
9def624a
AS		 390 BPF_STMT(BPF_LD | BPF_IMM, 1),
391 BPF_STMT(BPF_LDX | BPF_IMM, 3),
392 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
393 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
394 BPF_STMT(BPF_LD | BPF_IMM, 1),
395 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
396 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
397 BPF_STMT(BPF_LD | BPF_IMM, 1),
398 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
399 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
400 BPF_STMT(BPF_LD | BPF_IMM, 1),
401 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
402 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
403 BPF_STMT(BPF_LD | BPF_IMM, 1),
404 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
405 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
406 BPF_STMT(BPF_LD | BPF_IMM, 1),
407 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
408 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
409 BPF_STMT(BPF_LD | BPF_IMM, 1),
410 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
411 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
412 BPF_STMT(BPF_LD | BPF_IMM, 1),
413 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
414 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
415 BPF_STMT(BPF_RET | BPF_A, 0)
416 },
10f18e0b 417 CLASSIC,
9def624a
AS		 418 { 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
419 { { 4, 0 }, { 20, 9 } },
420 },
421 {
422 "LD_PAYLOAD_OFF",
ece80490 423 .u.insns = {
9def624a
AS		 424 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
425 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
426 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
427 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
428 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
429 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
430 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
431 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
432 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
433 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
434 BPF_STMT(BPF_RET | BPF_A, 0)
435 },
10f18e0b 436 CLASSIC,
9def624a
AS		 437 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
438 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
439 * id 9737, seq 1, length 64
440 */
441 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
443 0x08, 0x00,
444 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
445 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
446 { { 30, 0 }, { 100, 42 } },
447 },
448 {
449 "LD_ANC_XOR",
ece80490 450 .u.insns = {
9def624a
AS		 451 BPF_STMT(BPF_LD | BPF_IMM, 10),
452 BPF_STMT(BPF_LDX | BPF_IMM, 300),
453 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
454 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
455 BPF_STMT(BPF_RET | BPF_A, 0)
456 },
10f18e0b 457 CLASSIC,
9def624a
AS		 458 { },
459 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } },
460 },
461 {
462 "SPILL_FILL",
ece80490 463 .u.insns = {
9def624a
AS		 464 BPF_STMT(BPF_LDX | BPF_LEN, 0),
465 BPF_STMT(BPF_LD | BPF_IMM, 2),
466 BPF_STMT(BPF_ALU | BPF_RSH, 1),
467 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
468 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
469 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
470 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
471 BPF_STMT(BPF_STX, 15), /* M3 = len */
472 BPF_STMT(BPF_LDX | BPF_MEM, 1),
473 BPF_STMT(BPF_LD | BPF_MEM, 2),
474 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
475 BPF_STMT(BPF_LDX | BPF_MEM, 15),
476 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
477 BPF_STMT(BPF_RET | BPF_A, 0)
478 },
10f18e0b 479 CLASSIC,
9def624a
AS		 480 { },
481 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
482 },
483 {
484 "JEQ",
ece80490 485 .u.insns = {
9def624a
AS		 486 BPF_STMT(BPF_LDX | BPF_LEN, 0),
487 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
488 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
489 BPF_STMT(BPF_RET | BPF_K, 1),
490 BPF_STMT(BPF_RET | BPF_K, MAX_K)
491 },
10f18e0b 492 CLASSIC,
9def624a
AS		 493 { 3, 3, 3, 3, 3 },
494 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
495 },
496 {
497 "JGT",
ece80490 498 .u.insns = {
9def624a
AS		 499 BPF_STMT(BPF_LDX | BPF_LEN, 0),
500 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
501 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
502 BPF_STMT(BPF_RET | BPF_K, 1),
503 BPF_STMT(BPF_RET | BPF_K, MAX_K)
504 },
10f18e0b 505 CLASSIC,
9def624a
AS		 506 { 4, 4, 4, 3, 3 },
507 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
508 },
509 {
510 "JGE",
ece80490 511 .u.insns = {
9def624a
AS		 512 BPF_STMT(BPF_LDX | BPF_LEN, 0),
513 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
514 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
515 BPF_STMT(BPF_RET | BPF_K, 10),
516 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
517 BPF_STMT(BPF_RET | BPF_K, 20),
518 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
519 BPF_STMT(BPF_RET | BPF_K, 30),
520 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
521 BPF_STMT(BPF_RET | BPF_K, 40),
522 BPF_STMT(BPF_RET | BPF_K, MAX_K)
523 },
10f18e0b 524 CLASSIC,
9def624a
AS		 525 { 1, 2, 3, 4, 5 },
526 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
527 },
528 {
529 "JSET",
ece80490 530 .u.insns = {
9def624a
AS		 531 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
532 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
533 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
534 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
535 BPF_STMT(BPF_LDX | BPF_LEN, 0),
536 BPF_STMT(BPF_MISC | BPF_TXA, 0),
537 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
538 BPF_STMT(BPF_MISC | BPF_TAX, 0),
539 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
540 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
541 BPF_STMT(BPF_RET | BPF_K, 10),
542 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
543 BPF_STMT(BPF_RET | BPF_K, 20),
544 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
545 BPF_STMT(BPF_RET | BPF_K, 30),
546 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
547 BPF_STMT(BPF_RET | BPF_K, 30),
548 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
549 BPF_STMT(BPF_RET | BPF_K, 30),
550 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
551 BPF_STMT(BPF_RET | BPF_K, 30),
552 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
553 BPF_STMT(BPF_RET | BPF_K, 30),
554 BPF_STMT(BPF_RET | BPF_K, MAX_K)
555 },
10f18e0b 556 CLASSIC,
9def624a
AS		 557 { 0, 0xAA, 0x55, 1 },
558 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
559 },
64a8946b
AS		 560 {
561 "tcpdump port 22",
ece80490 562 .u.insns = {
64a8946b
AS		 563 { 0x28, 0, 0, 0x0000000c },
564 { 0x15, 0, 8, 0x000086dd },
565 { 0x30, 0, 0, 0x00000014 },
566 { 0x15, 2, 0, 0x00000084 },
567 { 0x15, 1, 0, 0x00000006 },
568 { 0x15, 0, 17, 0x00000011 },
569 { 0x28, 0, 0, 0x00000036 },
570 { 0x15, 14, 0, 0x00000016 },
571 { 0x28, 0, 0, 0x00000038 },
572 { 0x15, 12, 13, 0x00000016 },
573 { 0x15, 0, 12, 0x00000800 },
574 { 0x30, 0, 0, 0x00000017 },
575 { 0x15, 2, 0, 0x00000084 },
576 { 0x15, 1, 0, 0x00000006 },
577 { 0x15, 0, 8, 0x00000011 },
578 { 0x28, 0, 0, 0x00000014 },
579 { 0x45, 6, 0, 0x00001fff },
580 { 0xb1, 0, 0, 0x0000000e },
581 { 0x48, 0, 0, 0x0000000e },
582 { 0x15, 2, 0, 0x00000016 },
583 { 0x48, 0, 0, 0x00000010 },
584 { 0x15, 0, 1, 0x00000016 },
585 { 0x06, 0, 0, 0x0000ffff },
586 { 0x06, 0, 0, 0x00000000 },
587 },
10f18e0b 588 CLASSIC,
64a8946b
AS		 589 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
590 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
591 * seq 1305692979:1305693027, ack 3650467037, win 65535,
592 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
593 */
594 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
595 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
596 0x08, 0x00,
597 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
598 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
599 0x0a, 0x01, 0x01, 0x95, /* ip src */
600 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
601 0xc2, 0x24,
602 0x00, 0x16 /* dst port */ },
603 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
604 },
9def624a
AS		 605 {
606 "tcpdump complex",
ece80490 607 .u.insns = {
9def624a
AS		 608 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
609 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
610 * (len > 115 or len < 30000000000)' -d
611 */
612 { 0x28, 0, 0, 0x0000000c },
613 { 0x15, 30, 0, 0x000086dd },
614 { 0x15, 0, 29, 0x00000800 },
615 { 0x30, 0, 0, 0x00000017 },
616 { 0x15, 0, 27, 0x00000006 },
617 { 0x28, 0, 0, 0x00000014 },
618 { 0x45, 25, 0, 0x00001fff },
619 { 0xb1, 0, 0, 0x0000000e },
620 { 0x48, 0, 0, 0x0000000e },
621 { 0x15, 2, 0, 0x00000016 },
622 { 0x48, 0, 0, 0x00000010 },
623 { 0x15, 0, 20, 0x00000016 },
624 { 0x28, 0, 0, 0x00000010 },
625 { 0x02, 0, 0, 0x00000001 },
626 { 0x30, 0, 0, 0x0000000e },
627 { 0x54, 0, 0, 0x0000000f },
628 { 0x64, 0, 0, 0x00000002 },
629 { 0x07, 0, 0, 0x00000005 },
630 { 0x60, 0, 0, 0x00000001 },
631 { 0x1c, 0, 0, 0x00000000 },
632 { 0x02, 0, 0, 0x00000005 },
633 { 0xb1, 0, 0, 0x0000000e },
634 { 0x50, 0, 0, 0x0000001a },
635 { 0x54, 0, 0, 0x000000f0 },
636 { 0x74, 0, 0, 0x00000002 },
637 { 0x07, 0, 0, 0x00000009 },
638 { 0x60, 0, 0, 0x00000005 },
639 { 0x1d, 4, 0, 0x00000000 },
640 { 0x80, 0, 0, 0x00000000 },
641 { 0x25, 1, 0, 0x00000073 },
642 { 0x35, 1, 0, 0xfc23ac00 },
643 { 0x06, 0, 0, 0x0000ffff },
644 { 0x06, 0, 0, 0x00000000 },
645 },
10f18e0b 646 CLASSIC,
9def624a
AS		 647 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
648 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
649 0x08, 0x00,
650 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
651 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
652 0x0a, 0x01, 0x01, 0x95, /* ip src */
653 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
654 0xc2, 0x24,
655 0x00, 0x16 /* dst port */ },
656 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
657 },
658 {
659 "RET_A",
ece80490 660 .u.insns = {
9def624a
AS		 661 /* check that unitialized X and A contain zeros */
662 BPF_STMT(BPF_MISC | BPF_TXA, 0),
663 BPF_STMT(BPF_RET | BPF_A, 0)
664 },
10f18e0b
DB		 665 CLASSIC,
666 { },
9def624a
AS		 667 { {1, 0}, {2, 0} },
668 },
669 {
670 "INT: ADD trivial",
ece80490 671 .u.insns_int = {
9def624a
AS		 672 BPF_ALU64_IMM(BPF_MOV, R1, 1),
673 BPF_ALU64_IMM(BPF_ADD, R1, 2),
674 BPF_ALU64_IMM(BPF_MOV, R2, 3),
675 BPF_ALU64_REG(BPF_SUB, R1, R2),
676 BPF_ALU64_IMM(BPF_ADD, R1, -1),
677 BPF_ALU64_IMM(BPF_MUL, R1, 3),
678 BPF_ALU64_REG(BPF_MOV, R0, R1),
679 BPF_EXIT_INSN(),
680 },
10f18e0b 681 INTERNAL,
9def624a
AS		 682 { },
683 { { 0, 0xfffffffd } }
684 },
685 {
686 "INT: MUL_X",
ece80490 687 .u.insns_int = {
9def624a
AS		 688 BPF_ALU64_IMM(BPF_MOV, R0, -1),
689 BPF_ALU64_IMM(BPF_MOV, R1, -1),
690 BPF_ALU64_IMM(BPF_MOV, R2, 3),
691 BPF_ALU64_REG(BPF_MUL, R1, R2),
692 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
693 BPF_EXIT_INSN(),
694 BPF_ALU64_IMM(BPF_MOV, R0, 1),
695 BPF_EXIT_INSN(),
696 },
10f18e0b 697 INTERNAL,
9def624a
AS		 698 { },
699 { { 0, 1 } }
700 },
701 {
702 "INT: MUL_X2",
ece80490 703 .u.insns_int = {
9def624a
AS		 704 BPF_ALU32_IMM(BPF_MOV, R0, -1),
705 BPF_ALU32_IMM(BPF_MOV, R1, -1),
706 BPF_ALU32_IMM(BPF_MOV, R2, 3),
707 BPF_ALU64_REG(BPF_MUL, R1, R2),
708 BPF_ALU64_IMM(BPF_RSH, R1, 8),
709 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
710 BPF_EXIT_INSN(),
711 BPF_ALU32_IMM(BPF_MOV, R0, 1),
712 BPF_EXIT_INSN(),
713 },
10f18e0b 714 INTERNAL,
9def624a
AS		 715 { },
716 { { 0, 1 } }
717 },
718 {
719 "INT: MUL32_X",
ece80490 720 .u.insns_int = {
9def624a
AS		 721 BPF_ALU32_IMM(BPF_MOV, R0, -1),
722 BPF_ALU64_IMM(BPF_MOV, R1, -1),
723 BPF_ALU32_IMM(BPF_MOV, R2, 3),
724 BPF_ALU32_REG(BPF_MUL, R1, R2),
725 BPF_ALU64_IMM(BPF_RSH, R1, 8),
726 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
727 BPF_EXIT_INSN(),
728 BPF_ALU32_IMM(BPF_MOV, R0, 1),
729 BPF_EXIT_INSN(),
730 },
10f18e0b 731 INTERNAL,
9def624a
AS		 732 { },
733 { { 0, 1 } }
734 },
735 {
736 /* Have to test all register combinations, since
737 * JITing of different registers will produce
738 * different asm code.
739 */
740 "INT: ADD 64-bit",
ece80490 741 .u.insns_int = {
9def624a
AS		 742 BPF_ALU64_IMM(BPF_MOV, R0, 0),
743 BPF_ALU64_IMM(BPF_MOV, R1, 1),
744 BPF_ALU64_IMM(BPF_MOV, R2, 2),
745 BPF_ALU64_IMM(BPF_MOV, R3, 3),
746 BPF_ALU64_IMM(BPF_MOV, R4, 4),
747 BPF_ALU64_IMM(BPF_MOV, R5, 5),
748 BPF_ALU64_IMM(BPF_MOV, R6, 6),
749 BPF_ALU64_IMM(BPF_MOV, R7, 7),
750 BPF_ALU64_IMM(BPF_MOV, R8, 8),
751 BPF_ALU64_IMM(BPF_MOV, R9, 9),
752 BPF_ALU64_IMM(BPF_ADD, R0, 20),
753 BPF_ALU64_IMM(BPF_ADD, R1, 20),
754 BPF_ALU64_IMM(BPF_ADD, R2, 20),
755 BPF_ALU64_IMM(BPF_ADD, R3, 20),
756 BPF_ALU64_IMM(BPF_ADD, R4, 20),
757 BPF_ALU64_IMM(BPF_ADD, R5, 20),
758 BPF_ALU64_IMM(BPF_ADD, R6, 20),
759 BPF_ALU64_IMM(BPF_ADD, R7, 20),
760 BPF_ALU64_IMM(BPF_ADD, R8, 20),
761 BPF_ALU64_IMM(BPF_ADD, R9, 20),
762 BPF_ALU64_IMM(BPF_SUB, R0, 10),
763 BPF_ALU64_IMM(BPF_SUB, R1, 10),
764 BPF_ALU64_IMM(BPF_SUB, R2, 10),
765 BPF_ALU64_IMM(BPF_SUB, R3, 10),
766 BPF_ALU64_IMM(BPF_SUB, R4, 10),
767 BPF_ALU64_IMM(BPF_SUB, R5, 10),
768 BPF_ALU64_IMM(BPF_SUB, R6, 10),
769 BPF_ALU64_IMM(BPF_SUB, R7, 10),
770 BPF_ALU64_IMM(BPF_SUB, R8, 10),
771 BPF_ALU64_IMM(BPF_SUB, R9, 10),
772 BPF_ALU64_REG(BPF_ADD, R0, R0),
773 BPF_ALU64_REG(BPF_ADD, R0, R1),
774 BPF_ALU64_REG(BPF_ADD, R0, R2),
775 BPF_ALU64_REG(BPF_ADD, R0, R3),
776 BPF_ALU64_REG(BPF_ADD, R0, R4),
777 BPF_ALU64_REG(BPF_ADD, R0, R5),
778 BPF_ALU64_REG(BPF_ADD, R0, R6),
779 BPF_ALU64_REG(BPF_ADD, R0, R7),
780 BPF_ALU64_REG(BPF_ADD, R0, R8),
781 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
782 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
783 BPF_EXIT_INSN(),
784 BPF_ALU64_REG(BPF_ADD, R1, R0),
785 BPF_ALU64_REG(BPF_ADD, R1, R1),
786 BPF_ALU64_REG(BPF_ADD, R1, R2),
787 BPF_ALU64_REG(BPF_ADD, R1, R3),
788 BPF_ALU64_REG(BPF_ADD, R1, R4),
789 BPF_ALU64_REG(BPF_ADD, R1, R5),
790 BPF_ALU64_REG(BPF_ADD, R1, R6),
791 BPF_ALU64_REG(BPF_ADD, R1, R7),
792 BPF_ALU64_REG(BPF_ADD, R1, R8),
793 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
794 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
795 BPF_EXIT_INSN(),
796 BPF_ALU64_REG(BPF_ADD, R2, R0),
797 BPF_ALU64_REG(BPF_ADD, R2, R1),
798 BPF_ALU64_REG(BPF_ADD, R2, R2),
799 BPF_ALU64_REG(BPF_ADD, R2, R3),
800 BPF_ALU64_REG(BPF_ADD, R2, R4),
801 BPF_ALU64_REG(BPF_ADD, R2, R5),
802 BPF_ALU64_REG(BPF_ADD, R2, R6),
803 BPF_ALU64_REG(BPF_ADD, R2, R7),
804 BPF_ALU64_REG(BPF_ADD, R2, R8),
805 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
806 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
807 BPF_EXIT_INSN(),
808 BPF_ALU64_REG(BPF_ADD, R3, R0),
809 BPF_ALU64_REG(BPF_ADD, R3, R1),
810 BPF_ALU64_REG(BPF_ADD, R3, R2),
811 BPF_ALU64_REG(BPF_ADD, R3, R3),
812 BPF_ALU64_REG(BPF_ADD, R3, R4),
813 BPF_ALU64_REG(BPF_ADD, R3, R5),
814 BPF_ALU64_REG(BPF_ADD, R3, R6),
815 BPF_ALU64_REG(BPF_ADD, R3, R7),
816 BPF_ALU64_REG(BPF_ADD, R3, R8),
817 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
818 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
819 BPF_EXIT_INSN(),
820 BPF_ALU64_REG(BPF_ADD, R4, R0),
821 BPF_ALU64_REG(BPF_ADD, R4, R1),
822 BPF_ALU64_REG(BPF_ADD, R4, R2),
823 BPF_ALU64_REG(BPF_ADD, R4, R3),
824 BPF_ALU64_REG(BPF_ADD, R4, R4),
825 BPF_ALU64_REG(BPF_ADD, R4, R5),
826 BPF_ALU64_REG(BPF_ADD, R4, R6),
827 BPF_ALU64_REG(BPF_ADD, R4, R7),
828 BPF_ALU64_REG(BPF_ADD, R4, R8),
829 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
830 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
831 BPF_EXIT_INSN(),
832 BPF_ALU64_REG(BPF_ADD, R5, R0),
833 BPF_ALU64_REG(BPF_ADD, R5, R1),
834 BPF_ALU64_REG(BPF_ADD, R5, R2),
835 BPF_ALU64_REG(BPF_ADD, R5, R3),
836 BPF_ALU64_REG(BPF_ADD, R5, R4),
837 BPF_ALU64_REG(BPF_ADD, R5, R5),
838 BPF_ALU64_REG(BPF_ADD, R5, R6),
839 BPF_ALU64_REG(BPF_ADD, R5, R7),
840 BPF_ALU64_REG(BPF_ADD, R5, R8),
841 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
842 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
843 BPF_EXIT_INSN(),
844 BPF_ALU64_REG(BPF_ADD, R6, R0),
845 BPF_ALU64_REG(BPF_ADD, R6, R1),
846 BPF_ALU64_REG(BPF_ADD, R6, R2),
847 BPF_ALU64_REG(BPF_ADD, R6, R3),
848 BPF_ALU64_REG(BPF_ADD, R6, R4),
849 BPF_ALU64_REG(BPF_ADD, R6, R5),
850 BPF_ALU64_REG(BPF_ADD, R6, R6),
851 BPF_ALU64_REG(BPF_ADD, R6, R7),
852 BPF_ALU64_REG(BPF_ADD, R6, R8),
853 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
854 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
855 BPF_EXIT_INSN(),
856 BPF_ALU64_REG(BPF_ADD, R7, R0),
857 BPF_ALU64_REG(BPF_ADD, R7, R1),
858 BPF_ALU64_REG(BPF_ADD, R7, R2),
859 BPF_ALU64_REG(BPF_ADD, R7, R3),
860 BPF_ALU64_REG(BPF_ADD, R7, R4),
861 BPF_ALU64_REG(BPF_ADD, R7, R5),
862 BPF_ALU64_REG(BPF_ADD, R7, R6),
863 BPF_ALU64_REG(BPF_ADD, R7, R7),
864 BPF_ALU64_REG(BPF_ADD, R7, R8),
865 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
866 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
867 BPF_EXIT_INSN(),
868 BPF_ALU64_REG(BPF_ADD, R8, R0),
869 BPF_ALU64_REG(BPF_ADD, R8, R1),
870 BPF_ALU64_REG(BPF_ADD, R8, R2),
871 BPF_ALU64_REG(BPF_ADD, R8, R3),
872 BPF_ALU64_REG(BPF_ADD, R8, R4),
873 BPF_ALU64_REG(BPF_ADD, R8, R5),
874 BPF_ALU64_REG(BPF_ADD, R8, R6),
875 BPF_ALU64_REG(BPF_ADD, R8, R7),
876 BPF_ALU64_REG(BPF_ADD, R8, R8),
877 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
878 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
879 BPF_EXIT_INSN(),
880 BPF_ALU64_REG(BPF_ADD, R9, R0),
881 BPF_ALU64_REG(BPF_ADD, R9, R1),
882 BPF_ALU64_REG(BPF_ADD, R9, R2),
883 BPF_ALU64_REG(BPF_ADD, R9, R3),
884 BPF_ALU64_REG(BPF_ADD, R9, R4),
885 BPF_ALU64_REG(BPF_ADD, R9, R5),
886 BPF_ALU64_REG(BPF_ADD, R9, R6),
887 BPF_ALU64_REG(BPF_ADD, R9, R7),
888 BPF_ALU64_REG(BPF_ADD, R9, R8),
889 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
890 BPF_ALU64_REG(BPF_MOV, R0, R9),
891 BPF_EXIT_INSN(),
892 },
10f18e0b 893 INTERNAL,
9def624a
AS		 894 { },
895 { { 0, 2957380 } }
896 },
897 {
898 "INT: ADD 32-bit",
ece80490 899 .u.insns_int = {
9def624a
AS		 900 BPF_ALU32_IMM(BPF_MOV, R0, 20),
901 BPF_ALU32_IMM(BPF_MOV, R1, 1),
902 BPF_ALU32_IMM(BPF_MOV, R2, 2),
903 BPF_ALU32_IMM(BPF_MOV, R3, 3),
904 BPF_ALU32_IMM(BPF_MOV, R4, 4),
905 BPF_ALU32_IMM(BPF_MOV, R5, 5),
906 BPF_ALU32_IMM(BPF_MOV, R6, 6),
907 BPF_ALU32_IMM(BPF_MOV, R7, 7),
908 BPF_ALU32_IMM(BPF_MOV, R8, 8),
909 BPF_ALU32_IMM(BPF_MOV, R9, 9),
910 BPF_ALU64_IMM(BPF_ADD, R1, 10),
911 BPF_ALU64_IMM(BPF_ADD, R2, 10),
912 BPF_ALU64_IMM(BPF_ADD, R3, 10),
913 BPF_ALU64_IMM(BPF_ADD, R4, 10),
914 BPF_ALU64_IMM(BPF_ADD, R5, 10),
915 BPF_ALU64_IMM(BPF_ADD, R6, 10),
916 BPF_ALU64_IMM(BPF_ADD, R7, 10),
917 BPF_ALU64_IMM(BPF_ADD, R8, 10),
918 BPF_ALU64_IMM(BPF_ADD, R9, 10),
919 BPF_ALU32_REG(BPF_ADD, R0, R1),
920 BPF_ALU32_REG(BPF_ADD, R0, R2),
921 BPF_ALU32_REG(BPF_ADD, R0, R3),
922 BPF_ALU32_REG(BPF_ADD, R0, R4),
923 BPF_ALU32_REG(BPF_ADD, R0, R5),
924 BPF_ALU32_REG(BPF_ADD, R0, R6),
925 BPF_ALU32_REG(BPF_ADD, R0, R7),
926 BPF_ALU32_REG(BPF_ADD, R0, R8),
927 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
928 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
929 BPF_EXIT_INSN(),
930 BPF_ALU32_REG(BPF_ADD, R1, R0),
931 BPF_ALU32_REG(BPF_ADD, R1, R1),
932 BPF_ALU32_REG(BPF_ADD, R1, R2),
933 BPF_ALU32_REG(BPF_ADD, R1, R3),
934 BPF_ALU32_REG(BPF_ADD, R1, R4),
935 BPF_ALU32_REG(BPF_ADD, R1, R5),
936 BPF_ALU32_REG(BPF_ADD, R1, R6),
937 BPF_ALU32_REG(BPF_ADD, R1, R7),
938 BPF_ALU32_REG(BPF_ADD, R1, R8),
939 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
940 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
941 BPF_EXIT_INSN(),
942 BPF_ALU32_REG(BPF_ADD, R2, R0),
943 BPF_ALU32_REG(BPF_ADD, R2, R1),
944 BPF_ALU32_REG(BPF_ADD, R2, R2),
945 BPF_ALU32_REG(BPF_ADD, R2, R3),
946 BPF_ALU32_REG(BPF_ADD, R2, R4),
947 BPF_ALU32_REG(BPF_ADD, R2, R5),
948 BPF_ALU32_REG(BPF_ADD, R2, R6),
949 BPF_ALU32_REG(BPF_ADD, R2, R7),
950 BPF_ALU32_REG(BPF_ADD, R2, R8),
951 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
952 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
953 BPF_EXIT_INSN(),
954 BPF_ALU32_REG(BPF_ADD, R3, R0),
955 BPF_ALU32_REG(BPF_ADD, R3, R1),
956 BPF_ALU32_REG(BPF_ADD, R3, R2),
957 BPF_ALU32_REG(BPF_ADD, R3, R3),
958 BPF_ALU32_REG(BPF_ADD, R3, R4),
959 BPF_ALU32_REG(BPF_ADD, R3, R5),
960 BPF_ALU32_REG(BPF_ADD, R3, R6),
961 BPF_ALU32_REG(BPF_ADD, R3, R7),
962 BPF_ALU32_REG(BPF_ADD, R3, R8),
963 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
964 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
965 BPF_EXIT_INSN(),
966 BPF_ALU32_REG(BPF_ADD, R4, R0),
967 BPF_ALU32_REG(BPF_ADD, R4, R1),
968 BPF_ALU32_REG(BPF_ADD, R4, R2),
969 BPF_ALU32_REG(BPF_ADD, R4, R3),
970 BPF_ALU32_REG(BPF_ADD, R4, R4),
971 BPF_ALU32_REG(BPF_ADD, R4, R5),
972 BPF_ALU32_REG(BPF_ADD, R4, R6),
973 BPF_ALU32_REG(BPF_ADD, R4, R7),
974 BPF_ALU32_REG(BPF_ADD, R4, R8),
975 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
976 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
977 BPF_EXIT_INSN(),
978 BPF_ALU32_REG(BPF_ADD, R5, R0),
979 BPF_ALU32_REG(BPF_ADD, R5, R1),
980 BPF_ALU32_REG(BPF_ADD, R5, R2),
981 BPF_ALU32_REG(BPF_ADD, R5, R3),
982 BPF_ALU32_REG(BPF_ADD, R5, R4),
983 BPF_ALU32_REG(BPF_ADD, R5, R5),
984 BPF_ALU32_REG(BPF_ADD, R5, R6),
985 BPF_ALU32_REG(BPF_ADD, R5, R7),
986 BPF_ALU32_REG(BPF_ADD, R5, R8),
987 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
988 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
989 BPF_EXIT_INSN(),
990 BPF_ALU32_REG(BPF_ADD, R6, R0),
991 BPF_ALU32_REG(BPF_ADD, R6, R1),
992 BPF_ALU32_REG(BPF_ADD, R6, R2),
993 BPF_ALU32_REG(BPF_ADD, R6, R3),
994 BPF_ALU32_REG(BPF_ADD, R6, R4),
995 BPF_ALU32_REG(BPF_ADD, R6, R5),
996 BPF_ALU32_REG(BPF_ADD, R6, R6),
997 BPF_ALU32_REG(BPF_ADD, R6, R7),
998 BPF_ALU32_REG(BPF_ADD, R6, R8),
999 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1000 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1001 BPF_EXIT_INSN(),
1002 BPF_ALU32_REG(BPF_ADD, R7, R0),
1003 BPF_ALU32_REG(BPF_ADD, R7, R1),
1004 BPF_ALU32_REG(BPF_ADD, R7, R2),
1005 BPF_ALU32_REG(BPF_ADD, R7, R3),
1006 BPF_ALU32_REG(BPF_ADD, R7, R4),
1007 BPF_ALU32_REG(BPF_ADD, R7, R5),
1008 BPF_ALU32_REG(BPF_ADD, R7, R6),
1009 BPF_ALU32_REG(BPF_ADD, R7, R7),
1010 BPF_ALU32_REG(BPF_ADD, R7, R8),
1011 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1012 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1013 BPF_EXIT_INSN(),
1014 BPF_ALU32_REG(BPF_ADD, R8, R0),
1015 BPF_ALU32_REG(BPF_ADD, R8, R1),
1016 BPF_ALU32_REG(BPF_ADD, R8, R2),
1017 BPF_ALU32_REG(BPF_ADD, R8, R3),
1018 BPF_ALU32_REG(BPF_ADD, R8, R4),
1019 BPF_ALU32_REG(BPF_ADD, R8, R5),
1020 BPF_ALU32_REG(BPF_ADD, R8, R6),
1021 BPF_ALU32_REG(BPF_ADD, R8, R7),
1022 BPF_ALU32_REG(BPF_ADD, R8, R8),
1023 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1024 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1025 BPF_EXIT_INSN(),
1026 BPF_ALU32_REG(BPF_ADD, R9, R0),
1027 BPF_ALU32_REG(BPF_ADD, R9, R1),
1028 BPF_ALU32_REG(BPF_ADD, R9, R2),
1029 BPF_ALU32_REG(BPF_ADD, R9, R3),
1030 BPF_ALU32_REG(BPF_ADD, R9, R4),
1031 BPF_ALU32_REG(BPF_ADD, R9, R5),
1032 BPF_ALU32_REG(BPF_ADD, R9, R6),
1033 BPF_ALU32_REG(BPF_ADD, R9, R7),
1034 BPF_ALU32_REG(BPF_ADD, R9, R8),
1035 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1036 BPF_ALU32_REG(BPF_MOV, R0, R9),
1037 BPF_EXIT_INSN(),
1038 },
10f18e0b 1039 INTERNAL,
9def624a
AS		 1040 { },
1041 { { 0, 2957380 } }
1042 },
1043 { /* Mainly checking JIT here. */
1044 "INT: SUB",
ece80490 1045 .u.insns_int = {
9def624a
AS		 1046 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1047 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1048 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1049 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1050 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1051 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1052 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1053 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1054 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1055 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1056 BPF_ALU64_REG(BPF_SUB, R0, R0),
1057 BPF_ALU64_REG(BPF_SUB, R0, R1),
1058 BPF_ALU64_REG(BPF_SUB, R0, R2),
1059 BPF_ALU64_REG(BPF_SUB, R0, R3),
1060 BPF_ALU64_REG(BPF_SUB, R0, R4),
1061 BPF_ALU64_REG(BPF_SUB, R0, R5),
1062 BPF_ALU64_REG(BPF_SUB, R0, R6),
1063 BPF_ALU64_REG(BPF_SUB, R0, R7),
1064 BPF_ALU64_REG(BPF_SUB, R0, R8),
1065 BPF_ALU64_REG(BPF_SUB, R0, R9),
1066 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1067 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1068 BPF_EXIT_INSN(),
1069 BPF_ALU64_REG(BPF_SUB, R1, R0),
1070 BPF_ALU64_REG(BPF_SUB, R1, R2),
1071 BPF_ALU64_REG(BPF_SUB, R1, R3),
1072 BPF_ALU64_REG(BPF_SUB, R1, R4),
1073 BPF_ALU64_REG(BPF_SUB, R1, R5),
1074 BPF_ALU64_REG(BPF_SUB, R1, R6),
1075 BPF_ALU64_REG(BPF_SUB, R1, R7),
1076 BPF_ALU64_REG(BPF_SUB, R1, R8),
1077 BPF_ALU64_REG(BPF_SUB, R1, R9),
1078 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1079 BPF_ALU64_REG(BPF_SUB, R2, R0),
1080 BPF_ALU64_REG(BPF_SUB, R2, R1),
1081 BPF_ALU64_REG(BPF_SUB, R2, R3),
1082 BPF_ALU64_REG(BPF_SUB, R2, R4),
1083 BPF_ALU64_REG(BPF_SUB, R2, R5),
1084 BPF_ALU64_REG(BPF_SUB, R2, R6),
1085 BPF_ALU64_REG(BPF_SUB, R2, R7),
1086 BPF_ALU64_REG(BPF_SUB, R2, R8),
1087 BPF_ALU64_REG(BPF_SUB, R2, R9),
1088 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1089 BPF_ALU64_REG(BPF_SUB, R3, R0),
1090 BPF_ALU64_REG(BPF_SUB, R3, R1),
1091 BPF_ALU64_REG(BPF_SUB, R3, R2),
1092 BPF_ALU64_REG(BPF_SUB, R3, R4),
1093 BPF_ALU64_REG(BPF_SUB, R3, R5),
1094 BPF_ALU64_REG(BPF_SUB, R3, R6),
1095 BPF_ALU64_REG(BPF_SUB, R3, R7),
1096 BPF_ALU64_REG(BPF_SUB, R3, R8),
1097 BPF_ALU64_REG(BPF_SUB, R3, R9),
1098 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1099 BPF_ALU64_REG(BPF_SUB, R4, R0),
1100 BPF_ALU64_REG(BPF_SUB, R4, R1),
1101 BPF_ALU64_REG(BPF_SUB, R4, R2),
1102 BPF_ALU64_REG(BPF_SUB, R4, R3),
1103 BPF_ALU64_REG(BPF_SUB, R4, R5),
1104 BPF_ALU64_REG(BPF_SUB, R4, R6),
1105 BPF_ALU64_REG(BPF_SUB, R4, R7),
1106 BPF_ALU64_REG(BPF_SUB, R4, R8),
1107 BPF_ALU64_REG(BPF_SUB, R4, R9),
1108 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1109 BPF_ALU64_REG(BPF_SUB, R5, R0),
1110 BPF_ALU64_REG(BPF_SUB, R5, R1),
1111 BPF_ALU64_REG(BPF_SUB, R5, R2),
1112 BPF_ALU64_REG(BPF_SUB, R5, R3),
1113 BPF_ALU64_REG(BPF_SUB, R5, R4),
1114 BPF_ALU64_REG(BPF_SUB, R5, R6),
1115 BPF_ALU64_REG(BPF_SUB, R5, R7),
1116 BPF_ALU64_REG(BPF_SUB, R5, R8),
1117 BPF_ALU64_REG(BPF_SUB, R5, R9),
1118 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1119 BPF_ALU64_REG(BPF_SUB, R6, R0),
1120 BPF_ALU64_REG(BPF_SUB, R6, R1),
1121 BPF_ALU64_REG(BPF_SUB, R6, R2),
1122 BPF_ALU64_REG(BPF_SUB, R6, R3),
1123 BPF_ALU64_REG(BPF_SUB, R6, R4),
1124 BPF_ALU64_REG(BPF_SUB, R6, R5),
1125 BPF_ALU64_REG(BPF_SUB, R6, R7),
1126 BPF_ALU64_REG(BPF_SUB, R6, R8),
1127 BPF_ALU64_REG(BPF_SUB, R6, R9),
1128 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1129 BPF_ALU64_REG(BPF_SUB, R7, R0),
1130 BPF_ALU64_REG(BPF_SUB, R7, R1),
1131 BPF_ALU64_REG(BPF_SUB, R7, R2),
1132 BPF_ALU64_REG(BPF_SUB, R7, R3),
1133 BPF_ALU64_REG(BPF_SUB, R7, R4),
1134 BPF_ALU64_REG(BPF_SUB, R7, R5),
1135 BPF_ALU64_REG(BPF_SUB, R7, R6),
1136 BPF_ALU64_REG(BPF_SUB, R7, R8),
1137 BPF_ALU64_REG(BPF_SUB, R7, R9),
1138 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1139 BPF_ALU64_REG(BPF_SUB, R8, R0),
1140 BPF_ALU64_REG(BPF_SUB, R8, R1),
1141 BPF_ALU64_REG(BPF_SUB, R8, R2),
1142 BPF_ALU64_REG(BPF_SUB, R8, R3),
1143 BPF_ALU64_REG(BPF_SUB, R8, R4),
1144 BPF_ALU64_REG(BPF_SUB, R8, R5),
1145 BPF_ALU64_REG(BPF_SUB, R8, R6),
1146 BPF_ALU64_REG(BPF_SUB, R8, R7),
1147 BPF_ALU64_REG(BPF_SUB, R8, R9),
1148 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1149 BPF_ALU64_REG(BPF_SUB, R9, R0),
1150 BPF_ALU64_REG(BPF_SUB, R9, R1),
1151 BPF_ALU64_REG(BPF_SUB, R9, R2),
1152 BPF_ALU64_REG(BPF_SUB, R9, R3),
1153 BPF_ALU64_REG(BPF_SUB, R9, R4),
1154 BPF_ALU64_REG(BPF_SUB, R9, R5),
1155 BPF_ALU64_REG(BPF_SUB, R9, R6),
1156 BPF_ALU64_REG(BPF_SUB, R9, R7),
1157 BPF_ALU64_REG(BPF_SUB, R9, R8),
1158 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1159 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1160 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1161 BPF_ALU64_REG(BPF_SUB, R0, R1),
1162 BPF_ALU64_REG(BPF_SUB, R0, R2),
1163 BPF_ALU64_REG(BPF_SUB, R0, R3),
1164 BPF_ALU64_REG(BPF_SUB, R0, R4),
1165 BPF_ALU64_REG(BPF_SUB, R0, R5),
1166 BPF_ALU64_REG(BPF_SUB, R0, R6),
1167 BPF_ALU64_REG(BPF_SUB, R0, R7),
1168 BPF_ALU64_REG(BPF_SUB, R0, R8),
1169 BPF_ALU64_REG(BPF_SUB, R0, R9),
1170 BPF_EXIT_INSN(),
1171 },
10f18e0b 1172 INTERNAL,
9def624a
AS		 1173 { },
1174 { { 0, 11 } }
1175 },
1176 { /* Mainly checking JIT here. */
1177 "INT: XOR",
ece80490 1178 .u.insns_int = {
9def624a
AS		 1179 BPF_ALU64_REG(BPF_SUB, R0, R0),
1180 BPF_ALU64_REG(BPF_XOR, R1, R1),
1181 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1182 BPF_EXIT_INSN(),
1183 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1184 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1185 BPF_ALU64_REG(BPF_SUB, R1, R1),
1186 BPF_ALU64_REG(BPF_XOR, R2, R2),
1187 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1188 BPF_EXIT_INSN(),
1189 BPF_ALU64_REG(BPF_SUB, R2, R2),
1190 BPF_ALU64_REG(BPF_XOR, R3, R3),
1191 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1192 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1193 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1194 BPF_EXIT_INSN(),
1195 BPF_ALU64_REG(BPF_SUB, R3, R3),
1196 BPF_ALU64_REG(BPF_XOR, R4, R4),
1197 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1198 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1199 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1200 BPF_EXIT_INSN(),
1201 BPF_ALU64_REG(BPF_SUB, R4, R4),
1202 BPF_ALU64_REG(BPF_XOR, R5, R5),
1203 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1204 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1205 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1206 BPF_EXIT_INSN(),
1207 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1208 BPF_ALU64_REG(BPF_SUB, R5, R5),
1209 BPF_ALU64_REG(BPF_XOR, R6, R6),
1210 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1211 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1212 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1213 BPF_EXIT_INSN(),
1214 BPF_ALU64_REG(BPF_SUB, R6, R6),
1215 BPF_ALU64_REG(BPF_XOR, R7, R7),
1216 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1217 BPF_EXIT_INSN(),
1218 BPF_ALU64_REG(BPF_SUB, R7, R7),
1219 BPF_ALU64_REG(BPF_XOR, R8, R8),
1220 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1221 BPF_EXIT_INSN(),
1222 BPF_ALU64_REG(BPF_SUB, R8, R8),
1223 BPF_ALU64_REG(BPF_XOR, R9, R9),
1224 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1225 BPF_EXIT_INSN(),
1226 BPF_ALU64_REG(BPF_SUB, R9, R9),
1227 BPF_ALU64_REG(BPF_XOR, R0, R0),
1228 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1229 BPF_EXIT_INSN(),
1230 BPF_ALU64_REG(BPF_SUB, R1, R1),
1231 BPF_ALU64_REG(BPF_XOR, R0, R0),
1232 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1233 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1234 BPF_EXIT_INSN(),
1235 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1236 BPF_EXIT_INSN(),
1237 },
10f18e0b 1238 INTERNAL,
9def624a
AS		 1239 { },
1240 { { 0, 1 } }
1241 },
1242 { /* Mainly checking JIT here. */
1243 "INT: MUL",
ece80490 1244 .u.insns_int = {
9def624a
AS		 1245 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1246 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1247 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1248 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1249 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1250 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1251 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1252 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1253 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1254 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1255 BPF_ALU64_REG(BPF_MUL, R0, R0),
1256 BPF_ALU64_REG(BPF_MUL, R0, R1),
1257 BPF_ALU64_REG(BPF_MUL, R0, R2),
1258 BPF_ALU64_REG(BPF_MUL, R0, R3),
1259 BPF_ALU64_REG(BPF_MUL, R0, R4),
1260 BPF_ALU64_REG(BPF_MUL, R0, R5),
1261 BPF_ALU64_REG(BPF_MUL, R0, R6),
1262 BPF_ALU64_REG(BPF_MUL, R0, R7),
1263 BPF_ALU64_REG(BPF_MUL, R0, R8),
1264 BPF_ALU64_REG(BPF_MUL, R0, R9),
1265 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1266 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1267 BPF_EXIT_INSN(),
1268 BPF_ALU64_REG(BPF_MUL, R1, R0),
1269 BPF_ALU64_REG(BPF_MUL, R1, R2),
1270 BPF_ALU64_REG(BPF_MUL, R1, R3),
1271 BPF_ALU64_REG(BPF_MUL, R1, R4),
1272 BPF_ALU64_REG(BPF_MUL, R1, R5),
1273 BPF_ALU64_REG(BPF_MUL, R1, R6),
1274 BPF_ALU64_REG(BPF_MUL, R1, R7),
1275 BPF_ALU64_REG(BPF_MUL, R1, R8),
1276 BPF_ALU64_REG(BPF_MUL, R1, R9),
1277 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1278 BPF_ALU64_REG(BPF_MOV, R2, R1),
1279 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1280 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1281 BPF_EXIT_INSN(),
1282 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1283 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1284 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1285 BPF_EXIT_INSN(),
1286 BPF_ALU64_REG(BPF_MUL, R2, R0),
1287 BPF_ALU64_REG(BPF_MUL, R2, R1),
1288 BPF_ALU64_REG(BPF_MUL, R2, R3),
1289 BPF_ALU64_REG(BPF_MUL, R2, R4),
1290 BPF_ALU64_REG(BPF_MUL, R2, R5),
1291 BPF_ALU64_REG(BPF_MUL, R2, R6),
1292 BPF_ALU64_REG(BPF_MUL, R2, R7),
1293 BPF_ALU64_REG(BPF_MUL, R2, R8),
1294 BPF_ALU64_REG(BPF_MUL, R2, R9),
1295 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1296 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1297 BPF_ALU64_REG(BPF_MOV, R0, R2),
1298 BPF_EXIT_INSN(),
1299 },
10f18e0b 1300 INTERNAL,
9def624a
AS		 1301 { },
1302 { { 0, 0x35d97ef2 } }
1303 },
1304 {
1305 "INT: ALU MIX",
ece80490 1306 .u.insns_int = {
9def624a
AS		 1307 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1308 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1309 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1310 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1311 BPF_ALU64_REG(BPF_DIV, R0, R2),
1312 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1313 BPF_EXIT_INSN(),
1314 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1315 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1316 BPF_EXIT_INSN(),
1317 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1318 BPF_EXIT_INSN(),
1319 },
10f18e0b 1320 INTERNAL,
9def624a
AS		 1321 { },
1322 { { 0, -1 } }
1323 },
64a8946b
AS		 1324 {
1325 "INT: DIV + ABS",
ece80490 1326 .u.insns_int = {
64a8946b
AS		 1327 BPF_ALU64_REG(BPF_MOV, R6, R1),
1328 BPF_LD_ABS(BPF_B, 3),
1329 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1330 BPF_ALU32_REG(BPF_DIV, R0, R2),
1331 BPF_ALU64_REG(BPF_MOV, R8, R0),
1332 BPF_LD_ABS(BPF_B, 4),
1333 BPF_ALU64_REG(BPF_ADD, R8, R0),
1334 BPF_LD_IND(BPF_B, R8, -70),
1335 BPF_EXIT_INSN(),
1336 },
10f18e0b 1337 INTERNAL,
64a8946b
AS		 1338 { 10, 20, 30, 40, 50 },
1339 { { 4, 0 }, { 5, 10 } }
1340 },
9def624a
AS		 1341 {
1342 "INT: DIV by zero",
ece80490 1343 .u.insns_int = {
9def624a
AS		 1344 BPF_ALU64_REG(BPF_MOV, R6, R1),
1345 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1346 BPF_LD_ABS(BPF_B, 3),
1347 BPF_ALU32_REG(BPF_DIV, R0, R7),
1348 BPF_EXIT_INSN(),
1349 },
10f18e0b 1350 INTERNAL,
9def624a
AS		 1351 { 10, 20, 30, 40, 50 },
1352 { { 3, 0 }, { 4, 0 } }
1353 },
64a8946b
AS		 1354 {
1355 "check: missing ret",
ece80490 1356 .u.insns = {
64a8946b
AS		 1357 BPF_STMT(BPF_LD | BPF_IMM, 1),
1358 },
10f18e0b 1359 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
64a8946b
AS		 1360 { },
1361 { }
1362 },
9def624a
AS		 1363 {
1364 "check: div_k_0",
ece80490 1365 .u.insns = {
9def624a
AS		 1366 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
1367 BPF_STMT(BPF_RET | BPF_K, 0)
1368 },
10f18e0b 1369 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a
AS		 1370 { },
1371 { }
1372 },
1373 {
1374 "check: unknown insn",
ece80490 1375 .u.insns = {
9def624a
AS		 1376 /* seccomp insn, rejected in socket filter */
1377 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
1378 BPF_STMT(BPF_RET | BPF_K, 0)
1379 },
10f18e0b 1380 CLASSIC | FLAG_EXPECTED_FAIL,
9def624a
AS		 1381 { },
1382 { }
1383 },
1384 {
1385 "check: out of range spill/fill",
ece80490 1386 .u.insns = {
9def624a
AS		 1387 BPF_STMT(BPF_STX, 16),
1388 BPF_STMT(BPF_RET | BPF_K, 0)
1389 },
10f18e0b 1390 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
9def624a
AS		 1391 { },
1392 { }
1393 },
64a8946b
AS		 1394};
1395
10f18e0b 1396static struct net_device dev;
64a8946b 1397
10f18e0b 1398static struct sk_buff *populate_skb(char *buf, int size)
64a8946b
AS		 1399{
1400 struct sk_buff *skb;
1401
1402 if (size >= MAX_DATA)
1403 return NULL;
1404
1405 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
1406 if (!skb)
1407 return NULL;
1408
1409 memcpy(__skb_put(skb, size), buf, size);
10f18e0b
DB		 1410
1411 /* Initialize a fake skb with test pattern. */
64a8946b
AS		 1412 skb_reset_mac_header(skb);
1413 skb->protocol = htons(ETH_P_IP);
1414 skb->pkt_type = SKB_TYPE;
1415 skb->mark = SKB_MARK;
1416 skb->hash = SKB_HASH;
1417 skb->queue_mapping = SKB_QUEUE_MAP;
1418 skb->vlan_tci = SKB_VLAN_TCI;
1419 skb->dev = &dev;
1420 skb->dev->ifindex = SKB_DEV_IFINDEX;
1421 skb->dev->type = SKB_DEV_TYPE;
1422 skb_set_network_header(skb, min(size, ETH_HLEN));
1423
1424 return skb;
1425}
1426
10f18e0b 1427static void *generate_test_data(struct bpf_test *test, int sub)
64a8946b 1428{
10f18e0b
DB		 1429 if (test->aux & FLAG_NO_DATA)
1430 return NULL;
64a8946b 1431
10f18e0b
DB		 1432 /* Test case expects an skb, so populate one. Various
1433 * subtests generate skbs of different sizes based on
1434 * the same data.
1435 */
1436 return populate_skb(test->data, test->test[sub].data_size);
1437}
1438
1439static void release_test_data(const struct bpf_test *test, void *data)
1440{
1441 if (test->aux & FLAG_NO_DATA)
1442 return;
1443
1444 kfree_skb(data);
1445}
1446
1447static int probe_filter_length(struct sock_filter *fp)
1448{
1449 int len = 0;
1450
1451 while (fp->code != 0 || fp->k != 0) {
1452 fp++;
1453 len++;
1454 }
1455
1456 return len;
1457}
1458
1459static struct sk_filter *generate_filter(int which, int *err)
1460{
1461 struct sk_filter *fp;
1462 struct sock_fprog_kern fprog;
1463 unsigned int flen = probe_filter_length(tests[which].u.insns);
1464 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
1465
1466 switch (test_type) {
1467 case CLASSIC:
1468 fprog.filter = tests[which].u.insns;
1469 fprog.len = flen;
1470
1471 *err = sk_unattached_filter_create(&fp, &fprog);
1472 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
1473 if (*err == -EINVAL) {
1474 pr_cont("PASS\n");
1475 /* Verifier rejected filter as expected. */
1476 *err = 0;
1477 return NULL;
1478 } else {
1479 pr_cont("UNEXPECTED_PASS\n");
1480 /* Verifier didn't reject the test that's
1481 * bad enough, just return!
1482 */
1483 *err = -EINVAL;
1484 return NULL;
1485 }
1486 }
1487 /* We don't expect to fail. */
1488 if (*err) {
1489 pr_cont("FAIL to attach err=%d len=%d\n",
1490 *err, fprog.len);
1491 return NULL;
1492 }
1493 break;
1494
1495 case INTERNAL:
1496 fp = kzalloc(sk_filter_size(flen), GFP_KERNEL);
1497 if (fp == NULL) {
1498 pr_cont("UNEXPECTED_FAIL no memory left\n");
1499 *err = -ENOMEM;
1500 return NULL;
64a8946b
AS		 1501 }
1502
10f18e0b
DB		 1503 fp->len = flen;
1504 memcpy(fp->insnsi, tests[which].u.insns_int,
1505 fp->len * sizeof(struct sock_filter_int));
64a8946b 1506
10f18e0b
DB		 1507 sk_filter_select_runtime(fp);
1508 break;
1509 }
64a8946b 1510
10f18e0b
DB		 1511 *err = 0;
1512 return fp;
1513}
64a8946b 1514
10f18e0b
DB		 1515static void release_filter(struct sk_filter *fp, int which)
1516{
1517 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
64a8946b 1518
10f18e0b
DB		 1519 switch (test_type) {
1520 case CLASSIC:
1521 sk_unattached_filter_destroy(fp);
1522 break;
1523 case INTERNAL:
1524 sk_filter_free(fp);
1525 break;
1526 }
1527}
1528
1529static int __run_one(const struct sk_filter *fp, const void *data,
1530 int runs, u64 *duration)
1531{
1532 u64 start, finish;
1533 int ret, i;
1534
1535 start = ktime_to_us(ktime_get());
1536
1537 for (i = 0; i < runs; i++)
1538 ret = SK_RUN_FILTER(fp, data);
1539
1540 finish = ktime_to_us(ktime_get());
1541
1542 *duration = (finish - start) * 1000ULL;
1543 do_div(*duration, runs);
1544
1545 return ret;
1546}
1547
1548static int run_one(const struct sk_filter *fp, struct bpf_test *test)
1549{
1550 int err_cnt = 0, i, runs = MAX_TESTRUNS;
1551
1552 for (i = 0; i < MAX_SUBTESTS; i++) {
1553 void *data;
1554 u64 duration;
1555 u32 ret;
1556
1557 if (test->test[i].data_size == 0 &&
1558 test->test[i].result == 0)
1559 break;
1560
1561 data = generate_test_data(test, i);
1562 ret = __run_one(fp, data, runs, &duration);
1563 release_test_data(test, data);
1564
1565 if (ret == test->test[i].result) {
1566 pr_cont("%lld ", duration);
1567 } else {
1568 pr_cont("ret %d != %d ", ret,
1569 test->test[i].result);
64a8946b
AS		 1570 err_cnt++;
1571 }
1572 }
1573
1574 return err_cnt;
1575}
1576
1577static __init int test_bpf(void)
1578{
10f18e0b 1579 int i, err_cnt = 0, pass_cnt = 0;
64a8946b
AS		 1580
1581 for (i = 0; i < ARRAY_SIZE(tests); i++) {
10f18e0b
DB		 1582 struct sk_filter *fp;
1583 int err;
64a8946b 1584
10f18e0b 1585 pr_info("#%d %s ", i, tests[i].descr);
64a8946b 1586
10f18e0b
DB		 1587 fp = generate_filter(i, &err);
1588 if (fp == NULL) {
1589 if (err == 0) {
1590 pass_cnt++;
1591 continue;
64a8946b 1592 }
64a8946b 1593
10f18e0b
DB		 1594 return err;
1595 }
64a8946b 1596 err = run_one(fp, &tests[i]);
10f18e0b 1597 release_filter(fp, i);
64a8946b
AS		 1598
1599 if (err) {
10f18e0b 1600 pr_cont("FAIL (%d times)\n", err);
64a8946b
AS		 1601 err_cnt++;
1602 } else {
1603 pr_cont("PASS\n");
10f18e0b 1604 pass_cnt++;
64a8946b
AS		 1605 }
1606 }
1607
10f18e0b
DB		 1608 pr_info("Summary: %d PASSED, %d FAILED\n", pass_cnt, err_cnt);
1609 return err_cnt ? -EINVAL : 0;
64a8946b
AS		 1610}
1611
1612static int __init test_bpf_init(void)
1613{
1614 return test_bpf();
1615}
1616
1617static void __exit test_bpf_exit(void)
1618{
1619}
1620
1621module_init(test_bpf_init);
1622module_exit(test_bpf_exit);
10f18e0b 1623
64a8946b 1624MODULE_LICENSE("GPL");