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