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