1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Testsuite for BPF interpreter and BPF JIT compiler 4 * 5 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/init.h> 11 #include <linux/module.h> 12 #include <linux/filter.h> 13 #include <linux/bpf.h> 14 #include <linux/skbuff.h> 15 #include <linux/netdevice.h> 16 #include <linux/if_vlan.h> 17 #include <linux/random.h> 18 #include <linux/highmem.h> 19 #include <linux/sched.h> 20 21 /* General test specific settings */ 22 #define MAX_SUBTESTS 3 23 #define MAX_TESTRUNS 1000 24 #define MAX_DATA 128 25 #define MAX_INSNS 512 26 #define MAX_K 0xffffFFFF 27 28 /* Few constants used to init test 'skb' */ 29 #define SKB_TYPE 3 30 #define SKB_MARK 0x1234aaaa 31 #define SKB_HASH 0x1234aaab 32 #define SKB_QUEUE_MAP 123 33 #define SKB_VLAN_TCI 0xffff 34 #define SKB_VLAN_PRESENT 1 35 #define SKB_DEV_IFINDEX 577 36 #define SKB_DEV_TYPE 588 37 38 /* Redefine REGs to make tests less verbose */ 39 #define R0 BPF_REG_0 40 #define R1 BPF_REG_1 41 #define R2 BPF_REG_2 42 #define R3 BPF_REG_3 43 #define R4 BPF_REG_4 44 #define R5 BPF_REG_5 45 #define R6 BPF_REG_6 46 #define R7 BPF_REG_7 47 #define R8 BPF_REG_8 48 #define R9 BPF_REG_9 49 #define R10 BPF_REG_10 50 51 /* Flags that can be passed to test cases */ 52 #define FLAG_NO_DATA BIT(0) 53 #define FLAG_EXPECTED_FAIL BIT(1) 54 #define FLAG_SKB_FRAG BIT(2) 55 56 enum { 57 CLASSIC = BIT(6), /* Old BPF instructions only. */ 58 INTERNAL = BIT(7), /* Extended instruction set. */ 59 }; 60 61 #define TEST_TYPE_MASK (CLASSIC | INTERNAL) 62 63 struct bpf_test { 64 const char *descr; 65 union { 66 struct sock_filter insns[MAX_INSNS]; 67 struct bpf_insn insns_int[MAX_INSNS]; 68 struct { 69 void *insns; 70 unsigned int len; 71 } ptr; 72 } u; 73 __u8 aux; 74 __u8 data[MAX_DATA]; 75 struct { 76 int data_size; 77 __u32 result; 78 } test[MAX_SUBTESTS]; 79 int (*fill_helper)(struct bpf_test *self); 80 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */ 81 __u8 frag_data[MAX_DATA]; 82 int stack_depth; /* for eBPF only, since tests don't call verifier */ 83 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */ 84 }; 85 86 /* Large test cases need separate allocation and fill handler. */ 87 88 static int bpf_fill_maxinsns1(struct bpf_test *self) 89 { 90 unsigned int len = BPF_MAXINSNS; 91 struct sock_filter *insn; 92 __u32 k = ~0; 93 int i; 94 95 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 96 if (!insn) 97 return -ENOMEM; 98 99 for (i = 0; i < len; i++, k--) 100 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k); 101 102 self->u.ptr.insns = insn; 103 self->u.ptr.len = len; 104 105 return 0; 106 } 107 108 static int bpf_fill_maxinsns2(struct bpf_test *self) 109 { 110 unsigned int len = BPF_MAXINSNS; 111 struct sock_filter *insn; 112 int i; 113 114 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 115 if (!insn) 116 return -ENOMEM; 117 118 for (i = 0; i < len; i++) 119 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 120 121 self->u.ptr.insns = insn; 122 self->u.ptr.len = len; 123 124 return 0; 125 } 126 127 static int bpf_fill_maxinsns3(struct bpf_test *self) 128 { 129 unsigned int len = BPF_MAXINSNS; 130 struct sock_filter *insn; 131 struct rnd_state rnd; 132 int i; 133 134 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 135 if (!insn) 136 return -ENOMEM; 137 138 prandom_seed_state(&rnd, 3141592653589793238ULL); 139 140 for (i = 0; i < len - 1; i++) { 141 __u32 k = prandom_u32_state(&rnd); 142 143 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k); 144 } 145 146 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 147 148 self->u.ptr.insns = insn; 149 self->u.ptr.len = len; 150 151 return 0; 152 } 153 154 static int bpf_fill_maxinsns4(struct bpf_test *self) 155 { 156 unsigned int len = BPF_MAXINSNS + 1; 157 struct sock_filter *insn; 158 int i; 159 160 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 161 if (!insn) 162 return -ENOMEM; 163 164 for (i = 0; i < len; i++) 165 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 166 167 self->u.ptr.insns = insn; 168 self->u.ptr.len = len; 169 170 return 0; 171 } 172 173 static int bpf_fill_maxinsns5(struct bpf_test *self) 174 { 175 unsigned int len = BPF_MAXINSNS; 176 struct sock_filter *insn; 177 int i; 178 179 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 180 if (!insn) 181 return -ENOMEM; 182 183 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 184 185 for (i = 1; i < len - 1; i++) 186 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 187 188 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 189 190 self->u.ptr.insns = insn; 191 self->u.ptr.len = len; 192 193 return 0; 194 } 195 196 static int bpf_fill_maxinsns6(struct bpf_test *self) 197 { 198 unsigned int len = BPF_MAXINSNS; 199 struct sock_filter *insn; 200 int i; 201 202 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 203 if (!insn) 204 return -ENOMEM; 205 206 for (i = 0; i < len - 1; i++) 207 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 208 SKF_AD_VLAN_TAG_PRESENT); 209 210 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 211 212 self->u.ptr.insns = insn; 213 self->u.ptr.len = len; 214 215 return 0; 216 } 217 218 static int bpf_fill_maxinsns7(struct bpf_test *self) 219 { 220 unsigned int len = BPF_MAXINSNS; 221 struct sock_filter *insn; 222 int i; 223 224 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 225 if (!insn) 226 return -ENOMEM; 227 228 for (i = 0; i < len - 4; i++) 229 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 230 SKF_AD_CPU); 231 232 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0); 233 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 234 SKF_AD_CPU); 235 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0); 236 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 237 238 self->u.ptr.insns = insn; 239 self->u.ptr.len = len; 240 241 return 0; 242 } 243 244 static int bpf_fill_maxinsns8(struct bpf_test *self) 245 { 246 unsigned int len = BPF_MAXINSNS; 247 struct sock_filter *insn; 248 int i, jmp_off = len - 3; 249 250 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 251 if (!insn) 252 return -ENOMEM; 253 254 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff); 255 256 for (i = 1; i < len - 1; i++) 257 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0); 258 259 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 260 261 self->u.ptr.insns = insn; 262 self->u.ptr.len = len; 263 264 return 0; 265 } 266 267 static int bpf_fill_maxinsns9(struct bpf_test *self) 268 { 269 unsigned int len = BPF_MAXINSNS; 270 struct bpf_insn *insn; 271 int i; 272 273 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 274 if (!insn) 275 return -ENOMEM; 276 277 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2); 278 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab); 279 insn[2] = BPF_EXIT_INSN(); 280 281 for (i = 3; i < len - 2; i++) 282 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe); 283 284 insn[len - 2] = BPF_EXIT_INSN(); 285 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1)); 286 287 self->u.ptr.insns = insn; 288 self->u.ptr.len = len; 289 290 return 0; 291 } 292 293 static int bpf_fill_maxinsns10(struct bpf_test *self) 294 { 295 unsigned int len = BPF_MAXINSNS, hlen = len - 2; 296 struct bpf_insn *insn; 297 int i; 298 299 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 300 if (!insn) 301 return -ENOMEM; 302 303 for (i = 0; i < hlen / 2; i++) 304 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i); 305 for (i = hlen - 1; i > hlen / 2; i--) 306 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i); 307 308 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1); 309 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac); 310 insn[hlen + 1] = BPF_EXIT_INSN(); 311 312 self->u.ptr.insns = insn; 313 self->u.ptr.len = len; 314 315 return 0; 316 } 317 318 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len, 319 unsigned int plen) 320 { 321 struct sock_filter *insn; 322 unsigned int rlen; 323 int i, j; 324 325 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 326 if (!insn) 327 return -ENOMEM; 328 329 rlen = (len % plen) - 1; 330 331 for (i = 0; i + plen < len; i += plen) 332 for (j = 0; j < plen; j++) 333 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, 334 plen - 1 - j, 0, 0); 335 for (j = 0; j < rlen; j++) 336 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j, 337 0, 0); 338 339 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac); 340 341 self->u.ptr.insns = insn; 342 self->u.ptr.len = len; 343 344 return 0; 345 } 346 347 static int bpf_fill_maxinsns11(struct bpf_test *self) 348 { 349 /* Hits 70 passes on x86_64 and triggers NOPs padding. */ 350 return __bpf_fill_ja(self, BPF_MAXINSNS, 68); 351 } 352 353 static int bpf_fill_maxinsns12(struct bpf_test *self) 354 { 355 unsigned int len = BPF_MAXINSNS; 356 struct sock_filter *insn; 357 int i = 0; 358 359 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 360 if (!insn) 361 return -ENOMEM; 362 363 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 364 365 for (i = 1; i < len - 1; i++) 366 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 367 368 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 369 370 self->u.ptr.insns = insn; 371 self->u.ptr.len = len; 372 373 return 0; 374 } 375 376 static int bpf_fill_maxinsns13(struct bpf_test *self) 377 { 378 unsigned int len = BPF_MAXINSNS; 379 struct sock_filter *insn; 380 int i = 0; 381 382 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 383 if (!insn) 384 return -ENOMEM; 385 386 for (i = 0; i < len - 3; i++) 387 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 388 389 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab); 390 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0); 391 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 392 393 self->u.ptr.insns = insn; 394 self->u.ptr.len = len; 395 396 return 0; 397 } 398 399 static int bpf_fill_ja(struct bpf_test *self) 400 { 401 /* Hits exactly 11 passes on x86_64 JIT. */ 402 return __bpf_fill_ja(self, 12, 9); 403 } 404 405 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self) 406 { 407 unsigned int len = BPF_MAXINSNS; 408 struct sock_filter *insn; 409 int i; 410 411 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 412 if (!insn) 413 return -ENOMEM; 414 415 for (i = 0; i < len - 1; i += 2) { 416 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0); 417 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 418 SKF_AD_OFF + SKF_AD_CPU); 419 } 420 421 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee); 422 423 self->u.ptr.insns = insn; 424 self->u.ptr.len = len; 425 426 return 0; 427 } 428 429 static int __bpf_fill_stxdw(struct bpf_test *self, int size) 430 { 431 unsigned int len = BPF_MAXINSNS; 432 struct bpf_insn *insn; 433 int i; 434 435 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 436 if (!insn) 437 return -ENOMEM; 438 439 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1); 440 insn[1] = BPF_ST_MEM(size, R10, -40, 42); 441 442 for (i = 2; i < len - 2; i++) 443 insn[i] = BPF_STX_XADD(size, R10, R0, -40); 444 445 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40); 446 insn[len - 1] = BPF_EXIT_INSN(); 447 448 self->u.ptr.insns = insn; 449 self->u.ptr.len = len; 450 self->stack_depth = 40; 451 452 return 0; 453 } 454 455 static int bpf_fill_stxw(struct bpf_test *self) 456 { 457 return __bpf_fill_stxdw(self, BPF_W); 458 } 459 460 static int bpf_fill_stxdw(struct bpf_test *self) 461 { 462 return __bpf_fill_stxdw(self, BPF_DW); 463 } 464 465 static int bpf_fill_long_jmp(struct bpf_test *self) 466 { 467 unsigned int len = BPF_MAXINSNS; 468 struct bpf_insn *insn; 469 int i; 470 471 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 472 if (!insn) 473 return -ENOMEM; 474 475 insn[0] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 476 insn[1] = BPF_JMP_IMM(BPF_JEQ, R0, 1, len - 2 - 1); 477 478 /* 479 * Fill with a complex 64-bit operation that expands to a lot of 480 * instructions on 32-bit JITs. The large jump offset can then 481 * overflow the conditional branch field size, triggering a branch 482 * conversion mechanism in some JITs. 483 * 484 * Note: BPF_MAXINSNS of ALU64 MUL is enough to trigger such branch 485 * conversion on the 32-bit MIPS JIT. For other JITs, the instruction 486 * count and/or operation may need to be modified to trigger the 487 * branch conversion. 488 */ 489 for (i = 2; i < len - 1; i++) 490 insn[i] = BPF_ALU64_IMM(BPF_MUL, R0, (i << 16) + i); 491 492 insn[len - 1] = BPF_EXIT_INSN(); 493 494 self->u.ptr.insns = insn; 495 self->u.ptr.len = len; 496 497 return 0; 498 } 499 500 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64) 501 { 502 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)}; 503 504 memcpy(insns, tmp, sizeof(tmp)); 505 return 2; 506 } 507 508 /* Test an ALU shift operation for all valid shift values */ 509 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op, 510 u8 mode, bool alu32) 511 { 512 static const s64 regs[] = { 513 0x0123456789abcdefLL, /* dword > 0, word < 0 */ 514 0xfedcba9876543210LL, /* dowrd < 0, word > 0 */ 515 0xfedcba0198765432LL, /* dowrd < 0, word < 0 */ 516 0x0123458967abcdefLL, /* dword > 0, word > 0 */ 517 }; 518 int bits = alu32 ? 32 : 64; 519 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3; 520 struct bpf_insn *insn; 521 int imm, k; 522 int i = 0; 523 524 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 525 if (!insn) 526 return -ENOMEM; 527 528 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 529 530 for (k = 0; k < ARRAY_SIZE(regs); k++) { 531 s64 reg = regs[k]; 532 533 i += __bpf_ld_imm64(&insn[i], R3, reg); 534 535 for (imm = 0; imm < bits; imm++) { 536 u64 val; 537 538 /* Perform operation */ 539 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3); 540 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm); 541 if (alu32) { 542 if (mode == BPF_K) 543 insn[i++] = BPF_ALU32_IMM(op, R1, imm); 544 else 545 insn[i++] = BPF_ALU32_REG(op, R1, R2); 546 switch (op) { 547 case BPF_LSH: 548 val = (u32)reg << imm; 549 break; 550 case BPF_RSH: 551 val = (u32)reg >> imm; 552 break; 553 case BPF_ARSH: 554 val = (u32)reg >> imm; 555 if (imm > 0 && (reg & 0x80000000)) 556 val |= ~(u32)0 << (32 - imm); 557 break; 558 } 559 } else { 560 if (mode == BPF_K) 561 insn[i++] = BPF_ALU64_IMM(op, R1, imm); 562 else 563 insn[i++] = BPF_ALU64_REG(op, R1, R2); 564 switch (op) { 565 case BPF_LSH: 566 val = (u64)reg << imm; 567 break; 568 case BPF_RSH: 569 val = (u64)reg >> imm; 570 break; 571 case BPF_ARSH: 572 val = (u64)reg >> imm; 573 if (imm > 0 && reg < 0) 574 val |= ~(u64)0 << (64 - imm); 575 break; 576 } 577 } 578 579 /* 580 * When debugging a JIT that fails this test, one 581 * can write the immediate value to R0 here to find 582 * out which operand values that fail. 583 */ 584 585 /* Load reference and check the result */ 586 i += __bpf_ld_imm64(&insn[i], R4, val); 587 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1); 588 insn[i++] = BPF_EXIT_INSN(); 589 } 590 } 591 592 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 593 insn[i++] = BPF_EXIT_INSN(); 594 595 self->u.ptr.insns = insn; 596 self->u.ptr.len = len; 597 BUG_ON(i > len); 598 599 return 0; 600 } 601 602 static int bpf_fill_alu_lsh_imm(struct bpf_test *self) 603 { 604 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false); 605 } 606 607 static int bpf_fill_alu_rsh_imm(struct bpf_test *self) 608 { 609 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false); 610 } 611 612 static int bpf_fill_alu_arsh_imm(struct bpf_test *self) 613 { 614 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false); 615 } 616 617 static int bpf_fill_alu_lsh_reg(struct bpf_test *self) 618 { 619 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false); 620 } 621 622 static int bpf_fill_alu_rsh_reg(struct bpf_test *self) 623 { 624 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false); 625 } 626 627 static int bpf_fill_alu_arsh_reg(struct bpf_test *self) 628 { 629 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false); 630 } 631 632 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self) 633 { 634 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true); 635 } 636 637 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self) 638 { 639 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true); 640 } 641 642 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self) 643 { 644 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true); 645 } 646 647 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self) 648 { 649 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true); 650 } 651 652 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self) 653 { 654 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true); 655 } 656 657 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self) 658 { 659 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true); 660 } 661 662 /* 663 * Common operand pattern generator for exhaustive power-of-two magnitudes 664 * tests. The block size parameters can be adjusted to increase/reduce the 665 * number of combinatons tested and thereby execution speed and memory 666 * footprint. 667 */ 668 669 static inline s64 value(int msb, int delta, int sign) 670 { 671 return sign * (1LL << msb) + delta; 672 } 673 674 static int __bpf_fill_pattern(struct bpf_test *self, void *arg, 675 int dbits, int sbits, int block1, int block2, 676 int (*emit)(struct bpf_test*, void*, 677 struct bpf_insn*, s64, s64)) 678 { 679 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}; 680 struct bpf_insn *insns; 681 int di, si, bt, db, sb; 682 int count, len, k; 683 int extra = 1 + 2; 684 int i = 0; 685 686 /* Total number of iterations for the two pattern */ 687 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn); 688 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn); 689 690 /* Compute the maximum number of insns and allocate the buffer */ 691 len = extra + count * (*emit)(self, arg, NULL, 0, 0); 692 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 693 if (!insns) 694 return -ENOMEM; 695 696 /* Add head instruction(s) */ 697 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 698 699 /* 700 * Pattern 1: all combinations of power-of-two magnitudes and sign, 701 * and with a block of contiguous values around each magnitude. 702 */ 703 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */ 704 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */ 705 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 706 for (db = -(block1 / 2); 707 db < (block1 + 1) / 2; db++) 708 for (sb = -(block1 / 2); 709 sb < (block1 + 1) / 2; sb++) { 710 s64 dst, src; 711 712 dst = value(di, db, sgn[k][0]); 713 src = value(si, sb, sgn[k][1]); 714 i += (*emit)(self, arg, 715 &insns[i], 716 dst, src); 717 } 718 /* 719 * Pattern 2: all combinations for a larger block of values 720 * for each power-of-two magnitude and sign, where the magnitude is 721 * the same for both operands. 722 */ 723 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */ 724 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 725 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++) 726 for (sb = -(block2 / 2); 727 sb < (block2 + 1) / 2; sb++) { 728 s64 dst, src; 729 730 dst = value(bt % dbits, db, sgn[k][0]); 731 src = value(bt % sbits, sb, sgn[k][1]); 732 i += (*emit)(self, arg, &insns[i], 733 dst, src); 734 } 735 736 /* Append tail instructions */ 737 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 738 insns[i++] = BPF_EXIT_INSN(); 739 BUG_ON(i > len); 740 741 self->u.ptr.insns = insns; 742 self->u.ptr.len = i; 743 744 return 0; 745 } 746 747 /* 748 * Block size parameters used in pattern tests below. une as needed to 749 * increase/reduce the number combinations tested, see following examples. 750 * block values per operand MSB 751 * ---------------------------------------- 752 * 0 none 753 * 1 (1 << MSB) 754 * 2 (1 << MSB) + [-1, 0] 755 * 3 (1 << MSB) + [-1, 0, 1] 756 */ 757 #define PATTERN_BLOCK1 1 758 #define PATTERN_BLOCK2 5 759 760 /* Number of test runs for a pattern test */ 761 #define NR_PATTERN_RUNS 1 762 763 /* 764 * Exhaustive tests of ALU operations for all combinations of power-of-two 765 * magnitudes of the operands, both for positive and negative values. The 766 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that 767 * emit different code depending on the magnitude of the immediate value. 768 */ 769 770 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op) 771 { 772 *res = 0; 773 switch (op) { 774 case BPF_MOV: 775 *res = v2; 776 break; 777 case BPF_AND: 778 *res = v1 & v2; 779 break; 780 case BPF_OR: 781 *res = v1 | v2; 782 break; 783 case BPF_XOR: 784 *res = v1 ^ v2; 785 break; 786 case BPF_ADD: 787 *res = v1 + v2; 788 break; 789 case BPF_SUB: 790 *res = v1 - v2; 791 break; 792 case BPF_MUL: 793 *res = v1 * v2; 794 break; 795 case BPF_DIV: 796 if (v2 == 0) 797 return false; 798 *res = div64_u64(v1, v2); 799 break; 800 case BPF_MOD: 801 if (v2 == 0) 802 return false; 803 div64_u64_rem(v1, v2, res); 804 break; 805 } 806 return true; 807 } 808 809 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg, 810 struct bpf_insn *insns, s64 dst, s64 imm) 811 { 812 int op = *(int *)arg; 813 int i = 0; 814 u64 res; 815 816 if (!insns) 817 return 7; 818 819 if (__bpf_alu_result(&res, dst, (s32)imm, op)) { 820 i += __bpf_ld_imm64(&insns[i], R1, dst); 821 i += __bpf_ld_imm64(&insns[i], R3, res); 822 insns[i++] = BPF_ALU64_IMM(op, R1, imm); 823 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 824 insns[i++] = BPF_EXIT_INSN(); 825 } 826 827 return i; 828 } 829 830 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg, 831 struct bpf_insn *insns, s64 dst, s64 imm) 832 { 833 int op = *(int *)arg; 834 int i = 0; 835 u64 res; 836 837 if (!insns) 838 return 7; 839 840 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) { 841 i += __bpf_ld_imm64(&insns[i], R1, dst); 842 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 843 insns[i++] = BPF_ALU32_IMM(op, R1, imm); 844 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 845 insns[i++] = BPF_EXIT_INSN(); 846 } 847 848 return i; 849 } 850 851 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg, 852 struct bpf_insn *insns, s64 dst, s64 src) 853 { 854 int op = *(int *)arg; 855 int i = 0; 856 u64 res; 857 858 if (!insns) 859 return 9; 860 861 if (__bpf_alu_result(&res, dst, src, op)) { 862 i += __bpf_ld_imm64(&insns[i], R1, dst); 863 i += __bpf_ld_imm64(&insns[i], R2, src); 864 i += __bpf_ld_imm64(&insns[i], R3, res); 865 insns[i++] = BPF_ALU64_REG(op, R1, R2); 866 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 867 insns[i++] = BPF_EXIT_INSN(); 868 } 869 870 return i; 871 } 872 873 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg, 874 struct bpf_insn *insns, s64 dst, s64 src) 875 { 876 int op = *(int *)arg; 877 int i = 0; 878 u64 res; 879 880 if (!insns) 881 return 9; 882 883 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) { 884 i += __bpf_ld_imm64(&insns[i], R1, dst); 885 i += __bpf_ld_imm64(&insns[i], R2, src); 886 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 887 insns[i++] = BPF_ALU32_REG(op, R1, R2); 888 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 889 insns[i++] = BPF_EXIT_INSN(); 890 } 891 892 return i; 893 } 894 895 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op) 896 { 897 return __bpf_fill_pattern(self, &op, 64, 32, 898 PATTERN_BLOCK1, PATTERN_BLOCK2, 899 &__bpf_emit_alu64_imm); 900 } 901 902 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op) 903 { 904 return __bpf_fill_pattern(self, &op, 64, 32, 905 PATTERN_BLOCK1, PATTERN_BLOCK2, 906 &__bpf_emit_alu32_imm); 907 } 908 909 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op) 910 { 911 return __bpf_fill_pattern(self, &op, 64, 64, 912 PATTERN_BLOCK1, PATTERN_BLOCK2, 913 &__bpf_emit_alu64_reg); 914 } 915 916 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op) 917 { 918 return __bpf_fill_pattern(self, &op, 64, 64, 919 PATTERN_BLOCK1, PATTERN_BLOCK2, 920 &__bpf_emit_alu32_reg); 921 } 922 923 /* ALU64 immediate operations */ 924 static int bpf_fill_alu64_mov_imm(struct bpf_test *self) 925 { 926 return __bpf_fill_alu64_imm(self, BPF_MOV); 927 } 928 929 static int bpf_fill_alu64_and_imm(struct bpf_test *self) 930 { 931 return __bpf_fill_alu64_imm(self, BPF_AND); 932 } 933 934 static int bpf_fill_alu64_or_imm(struct bpf_test *self) 935 { 936 return __bpf_fill_alu64_imm(self, BPF_OR); 937 } 938 939 static int bpf_fill_alu64_xor_imm(struct bpf_test *self) 940 { 941 return __bpf_fill_alu64_imm(self, BPF_XOR); 942 } 943 944 static int bpf_fill_alu64_add_imm(struct bpf_test *self) 945 { 946 return __bpf_fill_alu64_imm(self, BPF_ADD); 947 } 948 949 static int bpf_fill_alu64_sub_imm(struct bpf_test *self) 950 { 951 return __bpf_fill_alu64_imm(self, BPF_SUB); 952 } 953 954 static int bpf_fill_alu64_mul_imm(struct bpf_test *self) 955 { 956 return __bpf_fill_alu64_imm(self, BPF_MUL); 957 } 958 959 static int bpf_fill_alu64_div_imm(struct bpf_test *self) 960 { 961 return __bpf_fill_alu64_imm(self, BPF_DIV); 962 } 963 964 static int bpf_fill_alu64_mod_imm(struct bpf_test *self) 965 { 966 return __bpf_fill_alu64_imm(self, BPF_MOD); 967 } 968 969 /* ALU32 immediate operations */ 970 static int bpf_fill_alu32_mov_imm(struct bpf_test *self) 971 { 972 return __bpf_fill_alu32_imm(self, BPF_MOV); 973 } 974 975 static int bpf_fill_alu32_and_imm(struct bpf_test *self) 976 { 977 return __bpf_fill_alu32_imm(self, BPF_AND); 978 } 979 980 static int bpf_fill_alu32_or_imm(struct bpf_test *self) 981 { 982 return __bpf_fill_alu32_imm(self, BPF_OR); 983 } 984 985 static int bpf_fill_alu32_xor_imm(struct bpf_test *self) 986 { 987 return __bpf_fill_alu32_imm(self, BPF_XOR); 988 } 989 990 static int bpf_fill_alu32_add_imm(struct bpf_test *self) 991 { 992 return __bpf_fill_alu32_imm(self, BPF_ADD); 993 } 994 995 static int bpf_fill_alu32_sub_imm(struct bpf_test *self) 996 { 997 return __bpf_fill_alu32_imm(self, BPF_SUB); 998 } 999 1000 static int bpf_fill_alu32_mul_imm(struct bpf_test *self) 1001 { 1002 return __bpf_fill_alu32_imm(self, BPF_MUL); 1003 } 1004 1005 static int bpf_fill_alu32_div_imm(struct bpf_test *self) 1006 { 1007 return __bpf_fill_alu32_imm(self, BPF_DIV); 1008 } 1009 1010 static int bpf_fill_alu32_mod_imm(struct bpf_test *self) 1011 { 1012 return __bpf_fill_alu32_imm(self, BPF_MOD); 1013 } 1014 1015 /* ALU64 register operations */ 1016 static int bpf_fill_alu64_mov_reg(struct bpf_test *self) 1017 { 1018 return __bpf_fill_alu64_reg(self, BPF_MOV); 1019 } 1020 1021 static int bpf_fill_alu64_and_reg(struct bpf_test *self) 1022 { 1023 return __bpf_fill_alu64_reg(self, BPF_AND); 1024 } 1025 1026 static int bpf_fill_alu64_or_reg(struct bpf_test *self) 1027 { 1028 return __bpf_fill_alu64_reg(self, BPF_OR); 1029 } 1030 1031 static int bpf_fill_alu64_xor_reg(struct bpf_test *self) 1032 { 1033 return __bpf_fill_alu64_reg(self, BPF_XOR); 1034 } 1035 1036 static int bpf_fill_alu64_add_reg(struct bpf_test *self) 1037 { 1038 return __bpf_fill_alu64_reg(self, BPF_ADD); 1039 } 1040 1041 static int bpf_fill_alu64_sub_reg(struct bpf_test *self) 1042 { 1043 return __bpf_fill_alu64_reg(self, BPF_SUB); 1044 } 1045 1046 static int bpf_fill_alu64_mul_reg(struct bpf_test *self) 1047 { 1048 return __bpf_fill_alu64_reg(self, BPF_MUL); 1049 } 1050 1051 static int bpf_fill_alu64_div_reg(struct bpf_test *self) 1052 { 1053 return __bpf_fill_alu64_reg(self, BPF_DIV); 1054 } 1055 1056 static int bpf_fill_alu64_mod_reg(struct bpf_test *self) 1057 { 1058 return __bpf_fill_alu64_reg(self, BPF_MOD); 1059 } 1060 1061 /* ALU32 register operations */ 1062 static int bpf_fill_alu32_mov_reg(struct bpf_test *self) 1063 { 1064 return __bpf_fill_alu32_reg(self, BPF_MOV); 1065 } 1066 1067 static int bpf_fill_alu32_and_reg(struct bpf_test *self) 1068 { 1069 return __bpf_fill_alu32_reg(self, BPF_AND); 1070 } 1071 1072 static int bpf_fill_alu32_or_reg(struct bpf_test *self) 1073 { 1074 return __bpf_fill_alu32_reg(self, BPF_OR); 1075 } 1076 1077 static int bpf_fill_alu32_xor_reg(struct bpf_test *self) 1078 { 1079 return __bpf_fill_alu32_reg(self, BPF_XOR); 1080 } 1081 1082 static int bpf_fill_alu32_add_reg(struct bpf_test *self) 1083 { 1084 return __bpf_fill_alu32_reg(self, BPF_ADD); 1085 } 1086 1087 static int bpf_fill_alu32_sub_reg(struct bpf_test *self) 1088 { 1089 return __bpf_fill_alu32_reg(self, BPF_SUB); 1090 } 1091 1092 static int bpf_fill_alu32_mul_reg(struct bpf_test *self) 1093 { 1094 return __bpf_fill_alu32_reg(self, BPF_MUL); 1095 } 1096 1097 static int bpf_fill_alu32_div_reg(struct bpf_test *self) 1098 { 1099 return __bpf_fill_alu32_reg(self, BPF_DIV); 1100 } 1101 1102 static int bpf_fill_alu32_mod_reg(struct bpf_test *self) 1103 { 1104 return __bpf_fill_alu32_reg(self, BPF_MOD); 1105 } 1106 1107 static struct bpf_test tests[] = { 1108 { 1109 "TAX", 1110 .u.insns = { 1111 BPF_STMT(BPF_LD | BPF_IMM, 1), 1112 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1113 BPF_STMT(BPF_LD | BPF_IMM, 2), 1114 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1115 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 1116 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1117 BPF_STMT(BPF_LD | BPF_LEN, 0), 1118 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1119 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 1120 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 1121 BPF_STMT(BPF_RET | BPF_A, 0) 1122 }, 1123 CLASSIC, 1124 { 10, 20, 30, 40, 50 }, 1125 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 1126 }, 1127 { 1128 "TXA", 1129 .u.insns = { 1130 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1131 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1132 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1133 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 1134 }, 1135 CLASSIC, 1136 { 10, 20, 30, 40, 50 }, 1137 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 1138 }, 1139 { 1140 "ADD_SUB_MUL_K", 1141 .u.insns = { 1142 BPF_STMT(BPF_LD | BPF_IMM, 1), 1143 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 1144 BPF_STMT(BPF_LDX | BPF_IMM, 3), 1145 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 1146 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 1147 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 1148 BPF_STMT(BPF_RET | BPF_A, 0) 1149 }, 1150 CLASSIC | FLAG_NO_DATA, 1151 { }, 1152 { { 0, 0xfffffffd } } 1153 }, 1154 { 1155 "DIV_MOD_KX", 1156 .u.insns = { 1157 BPF_STMT(BPF_LD | BPF_IMM, 8), 1158 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 1159 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1160 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 1161 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 1162 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1163 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 1164 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 1165 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1166 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 1167 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 1168 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1169 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 1170 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000), 1171 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1172 BPF_STMT(BPF_RET | BPF_A, 0) 1173 }, 1174 CLASSIC | FLAG_NO_DATA, 1175 { }, 1176 { { 0, 0x20000000 } } 1177 }, 1178 { 1179 "AND_OR_LSH_K", 1180 .u.insns = { 1181 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 1182 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 1183 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 1184 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1185 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 1186 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 1187 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1188 BPF_STMT(BPF_RET | BPF_A, 0) 1189 }, 1190 CLASSIC | FLAG_NO_DATA, 1191 { }, 1192 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 1193 }, 1194 { 1195 "LD_IMM_0", 1196 .u.insns = { 1197 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */ 1198 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), 1199 BPF_STMT(BPF_RET | BPF_K, 0), 1200 BPF_STMT(BPF_RET | BPF_K, 1), 1201 }, 1202 CLASSIC, 1203 { }, 1204 { { 1, 1 } }, 1205 }, 1206 { 1207 "LD_IND", 1208 .u.insns = { 1209 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1210 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 1211 BPF_STMT(BPF_RET | BPF_K, 1) 1212 }, 1213 CLASSIC, 1214 { }, 1215 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 1216 }, 1217 { 1218 "LD_ABS", 1219 .u.insns = { 1220 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 1221 BPF_STMT(BPF_RET | BPF_K, 1) 1222 }, 1223 CLASSIC, 1224 { }, 1225 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 1226 }, 1227 { 1228 "LD_ABS_LL", 1229 .u.insns = { 1230 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 1231 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1232 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 1233 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1234 BPF_STMT(BPF_RET | BPF_A, 0) 1235 }, 1236 CLASSIC, 1237 { 1, 2, 3 }, 1238 { { 1, 0 }, { 2, 3 } }, 1239 }, 1240 { 1241 "LD_IND_LL", 1242 .u.insns = { 1243 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 1244 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1245 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1246 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1247 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 1248 BPF_STMT(BPF_RET | BPF_A, 0) 1249 }, 1250 CLASSIC, 1251 { 1, 2, 3, 0xff }, 1252 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 1253 }, 1254 { 1255 "LD_ABS_NET", 1256 .u.insns = { 1257 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 1258 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1259 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 1260 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1261 BPF_STMT(BPF_RET | BPF_A, 0) 1262 }, 1263 CLASSIC, 1264 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 1265 { { 15, 0 }, { 16, 3 } }, 1266 }, 1267 { 1268 "LD_IND_NET", 1269 .u.insns = { 1270 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 1271 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1272 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1273 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1274 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 1275 BPF_STMT(BPF_RET | BPF_A, 0) 1276 }, 1277 CLASSIC, 1278 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 1279 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 1280 }, 1281 { 1282 "LD_PKTTYPE", 1283 .u.insns = { 1284 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1285 SKF_AD_OFF + SKF_AD_PKTTYPE), 1286 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 1287 BPF_STMT(BPF_RET | BPF_K, 1), 1288 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1289 SKF_AD_OFF + SKF_AD_PKTTYPE), 1290 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 1291 BPF_STMT(BPF_RET | BPF_K, 1), 1292 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1293 SKF_AD_OFF + SKF_AD_PKTTYPE), 1294 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 1295 BPF_STMT(BPF_RET | BPF_K, 1), 1296 BPF_STMT(BPF_RET | BPF_A, 0) 1297 }, 1298 CLASSIC, 1299 { }, 1300 { { 1, 3 }, { 10, 3 } }, 1301 }, 1302 { 1303 "LD_MARK", 1304 .u.insns = { 1305 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1306 SKF_AD_OFF + SKF_AD_MARK), 1307 BPF_STMT(BPF_RET | BPF_A, 0) 1308 }, 1309 CLASSIC, 1310 { }, 1311 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 1312 }, 1313 { 1314 "LD_RXHASH", 1315 .u.insns = { 1316 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1317 SKF_AD_OFF + SKF_AD_RXHASH), 1318 BPF_STMT(BPF_RET | BPF_A, 0) 1319 }, 1320 CLASSIC, 1321 { }, 1322 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 1323 }, 1324 { 1325 "LD_QUEUE", 1326 .u.insns = { 1327 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1328 SKF_AD_OFF + SKF_AD_QUEUE), 1329 BPF_STMT(BPF_RET | BPF_A, 0) 1330 }, 1331 CLASSIC, 1332 { }, 1333 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 1334 }, 1335 { 1336 "LD_PROTOCOL", 1337 .u.insns = { 1338 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 1339 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 1340 BPF_STMT(BPF_RET | BPF_K, 0), 1341 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1342 SKF_AD_OFF + SKF_AD_PROTOCOL), 1343 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1344 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 1345 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 1346 BPF_STMT(BPF_RET | BPF_K, 0), 1347 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1348 BPF_STMT(BPF_RET | BPF_A, 0) 1349 }, 1350 CLASSIC, 1351 { 10, 20, 30 }, 1352 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 1353 }, 1354 { 1355 "LD_VLAN_TAG", 1356 .u.insns = { 1357 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1358 SKF_AD_OFF + SKF_AD_VLAN_TAG), 1359 BPF_STMT(BPF_RET | BPF_A, 0) 1360 }, 1361 CLASSIC, 1362 { }, 1363 { 1364 { 1, SKB_VLAN_TCI }, 1365 { 10, SKB_VLAN_TCI } 1366 }, 1367 }, 1368 { 1369 "LD_VLAN_TAG_PRESENT", 1370 .u.insns = { 1371 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1372 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 1373 BPF_STMT(BPF_RET | BPF_A, 0) 1374 }, 1375 CLASSIC, 1376 { }, 1377 { 1378 { 1, SKB_VLAN_PRESENT }, 1379 { 10, SKB_VLAN_PRESENT } 1380 }, 1381 }, 1382 { 1383 "LD_IFINDEX", 1384 .u.insns = { 1385 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1386 SKF_AD_OFF + SKF_AD_IFINDEX), 1387 BPF_STMT(BPF_RET | BPF_A, 0) 1388 }, 1389 CLASSIC, 1390 { }, 1391 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 1392 }, 1393 { 1394 "LD_HATYPE", 1395 .u.insns = { 1396 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1397 SKF_AD_OFF + SKF_AD_HATYPE), 1398 BPF_STMT(BPF_RET | BPF_A, 0) 1399 }, 1400 CLASSIC, 1401 { }, 1402 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 1403 }, 1404 { 1405 "LD_CPU", 1406 .u.insns = { 1407 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1408 SKF_AD_OFF + SKF_AD_CPU), 1409 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1410 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1411 SKF_AD_OFF + SKF_AD_CPU), 1412 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 1413 BPF_STMT(BPF_RET | BPF_A, 0) 1414 }, 1415 CLASSIC, 1416 { }, 1417 { { 1, 0 }, { 10, 0 } }, 1418 }, 1419 { 1420 "LD_NLATTR", 1421 .u.insns = { 1422 BPF_STMT(BPF_LDX | BPF_IMM, 2), 1423 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1424 BPF_STMT(BPF_LDX | BPF_IMM, 3), 1425 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1426 SKF_AD_OFF + SKF_AD_NLATTR), 1427 BPF_STMT(BPF_RET | BPF_A, 0) 1428 }, 1429 CLASSIC, 1430 #ifdef __BIG_ENDIAN 1431 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 }, 1432 #else 1433 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 1434 #endif 1435 { { 4, 0 }, { 20, 6 } }, 1436 }, 1437 { 1438 "LD_NLATTR_NEST", 1439 .u.insns = { 1440 BPF_STMT(BPF_LD | BPF_IMM, 2), 1441 BPF_STMT(BPF_LDX | BPF_IMM, 3), 1442 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1443 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1444 BPF_STMT(BPF_LD | BPF_IMM, 2), 1445 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1446 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1447 BPF_STMT(BPF_LD | BPF_IMM, 2), 1448 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1449 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1450 BPF_STMT(BPF_LD | BPF_IMM, 2), 1451 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1452 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1453 BPF_STMT(BPF_LD | BPF_IMM, 2), 1454 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1455 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1456 BPF_STMT(BPF_LD | BPF_IMM, 2), 1457 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1458 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1459 BPF_STMT(BPF_LD | BPF_IMM, 2), 1460 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1461 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1462 BPF_STMT(BPF_LD | BPF_IMM, 2), 1463 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1464 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 1465 BPF_STMT(BPF_RET | BPF_A, 0) 1466 }, 1467 CLASSIC, 1468 #ifdef __BIG_ENDIAN 1469 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 }, 1470 #else 1471 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 1472 #endif 1473 { { 4, 0 }, { 20, 10 } }, 1474 }, 1475 { 1476 "LD_PAYLOAD_OFF", 1477 .u.insns = { 1478 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1479 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 1480 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1481 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 1482 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1483 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 1484 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1485 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 1486 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1487 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 1488 BPF_STMT(BPF_RET | BPF_A, 0) 1489 }, 1490 CLASSIC, 1491 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 1492 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 1493 * id 9737, seq 1, length 64 1494 */ 1495 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1496 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1497 0x08, 0x00, 1498 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 1499 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 1500 { { 30, 0 }, { 100, 42 } }, 1501 }, 1502 { 1503 "LD_ANC_XOR", 1504 .u.insns = { 1505 BPF_STMT(BPF_LD | BPF_IMM, 10), 1506 BPF_STMT(BPF_LDX | BPF_IMM, 300), 1507 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1508 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 1509 BPF_STMT(BPF_RET | BPF_A, 0) 1510 }, 1511 CLASSIC, 1512 { }, 1513 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } }, 1514 }, 1515 { 1516 "SPILL_FILL", 1517 .u.insns = { 1518 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1519 BPF_STMT(BPF_LD | BPF_IMM, 2), 1520 BPF_STMT(BPF_ALU | BPF_RSH, 1), 1521 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 1522 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 1523 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 1524 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 1525 BPF_STMT(BPF_STX, 15), /* M3 = len */ 1526 BPF_STMT(BPF_LDX | BPF_MEM, 1), 1527 BPF_STMT(BPF_LD | BPF_MEM, 2), 1528 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 1529 BPF_STMT(BPF_LDX | BPF_MEM, 15), 1530 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 1531 BPF_STMT(BPF_RET | BPF_A, 0) 1532 }, 1533 CLASSIC, 1534 { }, 1535 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 1536 }, 1537 { 1538 "JEQ", 1539 .u.insns = { 1540 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1541 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 1542 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 1543 BPF_STMT(BPF_RET | BPF_K, 1), 1544 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1545 }, 1546 CLASSIC, 1547 { 3, 3, 3, 3, 3 }, 1548 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 1549 }, 1550 { 1551 "JGT", 1552 .u.insns = { 1553 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1554 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 1555 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 1556 BPF_STMT(BPF_RET | BPF_K, 1), 1557 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1558 }, 1559 CLASSIC, 1560 { 4, 4, 4, 3, 3 }, 1561 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 1562 }, 1563 { 1564 "JGE (jt 0), test 1", 1565 .u.insns = { 1566 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1567 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 1568 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 1569 BPF_STMT(BPF_RET | BPF_K, 1), 1570 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1571 }, 1572 CLASSIC, 1573 { 4, 4, 4, 3, 3 }, 1574 { { 2, 0 }, { 3, 1 }, { 4, 1 } }, 1575 }, 1576 { 1577 "JGE (jt 0), test 2", 1578 .u.insns = { 1579 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1580 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 1581 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 1582 BPF_STMT(BPF_RET | BPF_K, 1), 1583 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1584 }, 1585 CLASSIC, 1586 { 4, 4, 5, 3, 3 }, 1587 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } }, 1588 }, 1589 { 1590 "JGE", 1591 .u.insns = { 1592 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1593 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 1594 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 1595 BPF_STMT(BPF_RET | BPF_K, 10), 1596 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 1597 BPF_STMT(BPF_RET | BPF_K, 20), 1598 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 1599 BPF_STMT(BPF_RET | BPF_K, 30), 1600 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 1601 BPF_STMT(BPF_RET | BPF_K, 40), 1602 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1603 }, 1604 CLASSIC, 1605 { 1, 2, 3, 4, 5 }, 1606 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 1607 }, 1608 { 1609 "JSET", 1610 .u.insns = { 1611 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 1612 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 1613 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 1614 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 1615 BPF_STMT(BPF_LDX | BPF_LEN, 0), 1616 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1617 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 1618 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1619 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 1620 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 1621 BPF_STMT(BPF_RET | BPF_K, 10), 1622 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 1623 BPF_STMT(BPF_RET | BPF_K, 20), 1624 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 1625 BPF_STMT(BPF_RET | BPF_K, 30), 1626 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 1627 BPF_STMT(BPF_RET | BPF_K, 30), 1628 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 1629 BPF_STMT(BPF_RET | BPF_K, 30), 1630 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 1631 BPF_STMT(BPF_RET | BPF_K, 30), 1632 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 1633 BPF_STMT(BPF_RET | BPF_K, 30), 1634 BPF_STMT(BPF_RET | BPF_K, MAX_K) 1635 }, 1636 CLASSIC, 1637 { 0, 0xAA, 0x55, 1 }, 1638 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 1639 }, 1640 { 1641 "tcpdump port 22", 1642 .u.insns = { 1643 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 1644 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */ 1645 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20), 1646 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 1647 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 1648 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17), 1649 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54), 1650 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0), 1651 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56), 1652 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13), 1653 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */ 1654 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 1655 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 1656 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 1657 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8), 1658 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 1659 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0), 1660 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 1661 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 1662 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 1663 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 1664 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1), 1665 BPF_STMT(BPF_RET | BPF_K, 0xffff), 1666 BPF_STMT(BPF_RET | BPF_K, 0), 1667 }, 1668 CLASSIC, 1669 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 1670 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 1671 * seq 1305692979:1305693027, ack 3650467037, win 65535, 1672 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 1673 */ 1674 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 1675 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 1676 0x08, 0x00, 1677 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 1678 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 1679 0x0a, 0x01, 0x01, 0x95, /* ip src */ 1680 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 1681 0xc2, 0x24, 1682 0x00, 0x16 /* dst port */ }, 1683 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 1684 }, 1685 { 1686 "tcpdump complex", 1687 .u.insns = { 1688 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 1689 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 1690 * (len > 115 or len < 30000000000)' -d 1691 */ 1692 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 1693 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0), 1694 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29), 1695 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 1696 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27), 1697 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 1698 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0), 1699 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 1700 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 1701 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 1702 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 1703 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20), 1704 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16), 1705 BPF_STMT(BPF_ST, 1), 1706 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14), 1707 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf), 1708 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2), 1709 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */ 1710 BPF_STMT(BPF_LD | BPF_MEM, 1), 1711 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 1712 BPF_STMT(BPF_ST, 5), 1713 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 1714 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26), 1715 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 1716 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2), 1717 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */ 1718 BPF_STMT(BPF_LD | BPF_MEM, 5), 1719 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0), 1720 BPF_STMT(BPF_LD | BPF_LEN, 0), 1721 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0), 1722 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0), 1723 BPF_STMT(BPF_RET | BPF_K, 0xffff), 1724 BPF_STMT(BPF_RET | BPF_K, 0), 1725 }, 1726 CLASSIC, 1727 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 1728 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 1729 0x08, 0x00, 1730 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 1731 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 1732 0x0a, 0x01, 0x01, 0x95, /* ip src */ 1733 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 1734 0xc2, 0x24, 1735 0x00, 0x16 /* dst port */ }, 1736 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 1737 }, 1738 { 1739 "RET_A", 1740 .u.insns = { 1741 /* check that uninitialized X and A contain zeros */ 1742 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1743 BPF_STMT(BPF_RET | BPF_A, 0) 1744 }, 1745 CLASSIC, 1746 { }, 1747 { {1, 0}, {2, 0} }, 1748 }, 1749 { 1750 "INT: ADD trivial", 1751 .u.insns_int = { 1752 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1753 BPF_ALU64_IMM(BPF_ADD, R1, 2), 1754 BPF_ALU64_IMM(BPF_MOV, R2, 3), 1755 BPF_ALU64_REG(BPF_SUB, R1, R2), 1756 BPF_ALU64_IMM(BPF_ADD, R1, -1), 1757 BPF_ALU64_IMM(BPF_MUL, R1, 3), 1758 BPF_ALU64_REG(BPF_MOV, R0, R1), 1759 BPF_EXIT_INSN(), 1760 }, 1761 INTERNAL, 1762 { }, 1763 { { 0, 0xfffffffd } } 1764 }, 1765 { 1766 "INT: MUL_X", 1767 .u.insns_int = { 1768 BPF_ALU64_IMM(BPF_MOV, R0, -1), 1769 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1770 BPF_ALU64_IMM(BPF_MOV, R2, 3), 1771 BPF_ALU64_REG(BPF_MUL, R1, R2), 1772 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 1773 BPF_EXIT_INSN(), 1774 BPF_ALU64_IMM(BPF_MOV, R0, 1), 1775 BPF_EXIT_INSN(), 1776 }, 1777 INTERNAL, 1778 { }, 1779 { { 0, 1 } } 1780 }, 1781 { 1782 "INT: MUL_X2", 1783 .u.insns_int = { 1784 BPF_ALU32_IMM(BPF_MOV, R0, -1), 1785 BPF_ALU32_IMM(BPF_MOV, R1, -1), 1786 BPF_ALU32_IMM(BPF_MOV, R2, 3), 1787 BPF_ALU64_REG(BPF_MUL, R1, R2), 1788 BPF_ALU64_IMM(BPF_RSH, R1, 8), 1789 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 1790 BPF_EXIT_INSN(), 1791 BPF_ALU32_IMM(BPF_MOV, R0, 1), 1792 BPF_EXIT_INSN(), 1793 }, 1794 INTERNAL, 1795 { }, 1796 { { 0, 1 } } 1797 }, 1798 { 1799 "INT: MUL32_X", 1800 .u.insns_int = { 1801 BPF_ALU32_IMM(BPF_MOV, R0, -1), 1802 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1803 BPF_ALU32_IMM(BPF_MOV, R2, 3), 1804 BPF_ALU32_REG(BPF_MUL, R1, R2), 1805 BPF_ALU64_IMM(BPF_RSH, R1, 8), 1806 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 1807 BPF_EXIT_INSN(), 1808 BPF_ALU32_IMM(BPF_MOV, R0, 1), 1809 BPF_EXIT_INSN(), 1810 }, 1811 INTERNAL, 1812 { }, 1813 { { 0, 1 } } 1814 }, 1815 { 1816 /* Have to test all register combinations, since 1817 * JITing of different registers will produce 1818 * different asm code. 1819 */ 1820 "INT: ADD 64-bit", 1821 .u.insns_int = { 1822 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1823 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1824 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1825 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1826 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1827 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1828 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1829 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1830 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1831 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1832 BPF_ALU64_IMM(BPF_ADD, R0, 20), 1833 BPF_ALU64_IMM(BPF_ADD, R1, 20), 1834 BPF_ALU64_IMM(BPF_ADD, R2, 20), 1835 BPF_ALU64_IMM(BPF_ADD, R3, 20), 1836 BPF_ALU64_IMM(BPF_ADD, R4, 20), 1837 BPF_ALU64_IMM(BPF_ADD, R5, 20), 1838 BPF_ALU64_IMM(BPF_ADD, R6, 20), 1839 BPF_ALU64_IMM(BPF_ADD, R7, 20), 1840 BPF_ALU64_IMM(BPF_ADD, R8, 20), 1841 BPF_ALU64_IMM(BPF_ADD, R9, 20), 1842 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1843 BPF_ALU64_IMM(BPF_SUB, R1, 10), 1844 BPF_ALU64_IMM(BPF_SUB, R2, 10), 1845 BPF_ALU64_IMM(BPF_SUB, R3, 10), 1846 BPF_ALU64_IMM(BPF_SUB, R4, 10), 1847 BPF_ALU64_IMM(BPF_SUB, R5, 10), 1848 BPF_ALU64_IMM(BPF_SUB, R6, 10), 1849 BPF_ALU64_IMM(BPF_SUB, R7, 10), 1850 BPF_ALU64_IMM(BPF_SUB, R8, 10), 1851 BPF_ALU64_IMM(BPF_SUB, R9, 10), 1852 BPF_ALU64_REG(BPF_ADD, R0, R0), 1853 BPF_ALU64_REG(BPF_ADD, R0, R1), 1854 BPF_ALU64_REG(BPF_ADD, R0, R2), 1855 BPF_ALU64_REG(BPF_ADD, R0, R3), 1856 BPF_ALU64_REG(BPF_ADD, R0, R4), 1857 BPF_ALU64_REG(BPF_ADD, R0, R5), 1858 BPF_ALU64_REG(BPF_ADD, R0, R6), 1859 BPF_ALU64_REG(BPF_ADD, R0, R7), 1860 BPF_ALU64_REG(BPF_ADD, R0, R8), 1861 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 1862 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 1863 BPF_EXIT_INSN(), 1864 BPF_ALU64_REG(BPF_ADD, R1, R0), 1865 BPF_ALU64_REG(BPF_ADD, R1, R1), 1866 BPF_ALU64_REG(BPF_ADD, R1, R2), 1867 BPF_ALU64_REG(BPF_ADD, R1, R3), 1868 BPF_ALU64_REG(BPF_ADD, R1, R4), 1869 BPF_ALU64_REG(BPF_ADD, R1, R5), 1870 BPF_ALU64_REG(BPF_ADD, R1, R6), 1871 BPF_ALU64_REG(BPF_ADD, R1, R7), 1872 BPF_ALU64_REG(BPF_ADD, R1, R8), 1873 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 1874 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 1875 BPF_EXIT_INSN(), 1876 BPF_ALU64_REG(BPF_ADD, R2, R0), 1877 BPF_ALU64_REG(BPF_ADD, R2, R1), 1878 BPF_ALU64_REG(BPF_ADD, R2, R2), 1879 BPF_ALU64_REG(BPF_ADD, R2, R3), 1880 BPF_ALU64_REG(BPF_ADD, R2, R4), 1881 BPF_ALU64_REG(BPF_ADD, R2, R5), 1882 BPF_ALU64_REG(BPF_ADD, R2, R6), 1883 BPF_ALU64_REG(BPF_ADD, R2, R7), 1884 BPF_ALU64_REG(BPF_ADD, R2, R8), 1885 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 1886 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 1887 BPF_EXIT_INSN(), 1888 BPF_ALU64_REG(BPF_ADD, R3, R0), 1889 BPF_ALU64_REG(BPF_ADD, R3, R1), 1890 BPF_ALU64_REG(BPF_ADD, R3, R2), 1891 BPF_ALU64_REG(BPF_ADD, R3, R3), 1892 BPF_ALU64_REG(BPF_ADD, R3, R4), 1893 BPF_ALU64_REG(BPF_ADD, R3, R5), 1894 BPF_ALU64_REG(BPF_ADD, R3, R6), 1895 BPF_ALU64_REG(BPF_ADD, R3, R7), 1896 BPF_ALU64_REG(BPF_ADD, R3, R8), 1897 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 1898 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 1899 BPF_EXIT_INSN(), 1900 BPF_ALU64_REG(BPF_ADD, R4, R0), 1901 BPF_ALU64_REG(BPF_ADD, R4, R1), 1902 BPF_ALU64_REG(BPF_ADD, R4, R2), 1903 BPF_ALU64_REG(BPF_ADD, R4, R3), 1904 BPF_ALU64_REG(BPF_ADD, R4, R4), 1905 BPF_ALU64_REG(BPF_ADD, R4, R5), 1906 BPF_ALU64_REG(BPF_ADD, R4, R6), 1907 BPF_ALU64_REG(BPF_ADD, R4, R7), 1908 BPF_ALU64_REG(BPF_ADD, R4, R8), 1909 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 1910 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 1911 BPF_EXIT_INSN(), 1912 BPF_ALU64_REG(BPF_ADD, R5, R0), 1913 BPF_ALU64_REG(BPF_ADD, R5, R1), 1914 BPF_ALU64_REG(BPF_ADD, R5, R2), 1915 BPF_ALU64_REG(BPF_ADD, R5, R3), 1916 BPF_ALU64_REG(BPF_ADD, R5, R4), 1917 BPF_ALU64_REG(BPF_ADD, R5, R5), 1918 BPF_ALU64_REG(BPF_ADD, R5, R6), 1919 BPF_ALU64_REG(BPF_ADD, R5, R7), 1920 BPF_ALU64_REG(BPF_ADD, R5, R8), 1921 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 1922 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 1923 BPF_EXIT_INSN(), 1924 BPF_ALU64_REG(BPF_ADD, R6, R0), 1925 BPF_ALU64_REG(BPF_ADD, R6, R1), 1926 BPF_ALU64_REG(BPF_ADD, R6, R2), 1927 BPF_ALU64_REG(BPF_ADD, R6, R3), 1928 BPF_ALU64_REG(BPF_ADD, R6, R4), 1929 BPF_ALU64_REG(BPF_ADD, R6, R5), 1930 BPF_ALU64_REG(BPF_ADD, R6, R6), 1931 BPF_ALU64_REG(BPF_ADD, R6, R7), 1932 BPF_ALU64_REG(BPF_ADD, R6, R8), 1933 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 1934 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 1935 BPF_EXIT_INSN(), 1936 BPF_ALU64_REG(BPF_ADD, R7, R0), 1937 BPF_ALU64_REG(BPF_ADD, R7, R1), 1938 BPF_ALU64_REG(BPF_ADD, R7, R2), 1939 BPF_ALU64_REG(BPF_ADD, R7, R3), 1940 BPF_ALU64_REG(BPF_ADD, R7, R4), 1941 BPF_ALU64_REG(BPF_ADD, R7, R5), 1942 BPF_ALU64_REG(BPF_ADD, R7, R6), 1943 BPF_ALU64_REG(BPF_ADD, R7, R7), 1944 BPF_ALU64_REG(BPF_ADD, R7, R8), 1945 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 1946 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 1947 BPF_EXIT_INSN(), 1948 BPF_ALU64_REG(BPF_ADD, R8, R0), 1949 BPF_ALU64_REG(BPF_ADD, R8, R1), 1950 BPF_ALU64_REG(BPF_ADD, R8, R2), 1951 BPF_ALU64_REG(BPF_ADD, R8, R3), 1952 BPF_ALU64_REG(BPF_ADD, R8, R4), 1953 BPF_ALU64_REG(BPF_ADD, R8, R5), 1954 BPF_ALU64_REG(BPF_ADD, R8, R6), 1955 BPF_ALU64_REG(BPF_ADD, R8, R7), 1956 BPF_ALU64_REG(BPF_ADD, R8, R8), 1957 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 1958 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 1959 BPF_EXIT_INSN(), 1960 BPF_ALU64_REG(BPF_ADD, R9, R0), 1961 BPF_ALU64_REG(BPF_ADD, R9, R1), 1962 BPF_ALU64_REG(BPF_ADD, R9, R2), 1963 BPF_ALU64_REG(BPF_ADD, R9, R3), 1964 BPF_ALU64_REG(BPF_ADD, R9, R4), 1965 BPF_ALU64_REG(BPF_ADD, R9, R5), 1966 BPF_ALU64_REG(BPF_ADD, R9, R6), 1967 BPF_ALU64_REG(BPF_ADD, R9, R7), 1968 BPF_ALU64_REG(BPF_ADD, R9, R8), 1969 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 1970 BPF_ALU64_REG(BPF_MOV, R0, R9), 1971 BPF_EXIT_INSN(), 1972 }, 1973 INTERNAL, 1974 { }, 1975 { { 0, 2957380 } } 1976 }, 1977 { 1978 "INT: ADD 32-bit", 1979 .u.insns_int = { 1980 BPF_ALU32_IMM(BPF_MOV, R0, 20), 1981 BPF_ALU32_IMM(BPF_MOV, R1, 1), 1982 BPF_ALU32_IMM(BPF_MOV, R2, 2), 1983 BPF_ALU32_IMM(BPF_MOV, R3, 3), 1984 BPF_ALU32_IMM(BPF_MOV, R4, 4), 1985 BPF_ALU32_IMM(BPF_MOV, R5, 5), 1986 BPF_ALU32_IMM(BPF_MOV, R6, 6), 1987 BPF_ALU32_IMM(BPF_MOV, R7, 7), 1988 BPF_ALU32_IMM(BPF_MOV, R8, 8), 1989 BPF_ALU32_IMM(BPF_MOV, R9, 9), 1990 BPF_ALU64_IMM(BPF_ADD, R1, 10), 1991 BPF_ALU64_IMM(BPF_ADD, R2, 10), 1992 BPF_ALU64_IMM(BPF_ADD, R3, 10), 1993 BPF_ALU64_IMM(BPF_ADD, R4, 10), 1994 BPF_ALU64_IMM(BPF_ADD, R5, 10), 1995 BPF_ALU64_IMM(BPF_ADD, R6, 10), 1996 BPF_ALU64_IMM(BPF_ADD, R7, 10), 1997 BPF_ALU64_IMM(BPF_ADD, R8, 10), 1998 BPF_ALU64_IMM(BPF_ADD, R9, 10), 1999 BPF_ALU32_REG(BPF_ADD, R0, R1), 2000 BPF_ALU32_REG(BPF_ADD, R0, R2), 2001 BPF_ALU32_REG(BPF_ADD, R0, R3), 2002 BPF_ALU32_REG(BPF_ADD, R0, R4), 2003 BPF_ALU32_REG(BPF_ADD, R0, R5), 2004 BPF_ALU32_REG(BPF_ADD, R0, R6), 2005 BPF_ALU32_REG(BPF_ADD, R0, R7), 2006 BPF_ALU32_REG(BPF_ADD, R0, R8), 2007 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 2008 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 2009 BPF_EXIT_INSN(), 2010 BPF_ALU32_REG(BPF_ADD, R1, R0), 2011 BPF_ALU32_REG(BPF_ADD, R1, R1), 2012 BPF_ALU32_REG(BPF_ADD, R1, R2), 2013 BPF_ALU32_REG(BPF_ADD, R1, R3), 2014 BPF_ALU32_REG(BPF_ADD, R1, R4), 2015 BPF_ALU32_REG(BPF_ADD, R1, R5), 2016 BPF_ALU32_REG(BPF_ADD, R1, R6), 2017 BPF_ALU32_REG(BPF_ADD, R1, R7), 2018 BPF_ALU32_REG(BPF_ADD, R1, R8), 2019 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 2020 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 2021 BPF_EXIT_INSN(), 2022 BPF_ALU32_REG(BPF_ADD, R2, R0), 2023 BPF_ALU32_REG(BPF_ADD, R2, R1), 2024 BPF_ALU32_REG(BPF_ADD, R2, R2), 2025 BPF_ALU32_REG(BPF_ADD, R2, R3), 2026 BPF_ALU32_REG(BPF_ADD, R2, R4), 2027 BPF_ALU32_REG(BPF_ADD, R2, R5), 2028 BPF_ALU32_REG(BPF_ADD, R2, R6), 2029 BPF_ALU32_REG(BPF_ADD, R2, R7), 2030 BPF_ALU32_REG(BPF_ADD, R2, R8), 2031 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 2032 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 2033 BPF_EXIT_INSN(), 2034 BPF_ALU32_REG(BPF_ADD, R3, R0), 2035 BPF_ALU32_REG(BPF_ADD, R3, R1), 2036 BPF_ALU32_REG(BPF_ADD, R3, R2), 2037 BPF_ALU32_REG(BPF_ADD, R3, R3), 2038 BPF_ALU32_REG(BPF_ADD, R3, R4), 2039 BPF_ALU32_REG(BPF_ADD, R3, R5), 2040 BPF_ALU32_REG(BPF_ADD, R3, R6), 2041 BPF_ALU32_REG(BPF_ADD, R3, R7), 2042 BPF_ALU32_REG(BPF_ADD, R3, R8), 2043 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 2044 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 2045 BPF_EXIT_INSN(), 2046 BPF_ALU32_REG(BPF_ADD, R4, R0), 2047 BPF_ALU32_REG(BPF_ADD, R4, R1), 2048 BPF_ALU32_REG(BPF_ADD, R4, R2), 2049 BPF_ALU32_REG(BPF_ADD, R4, R3), 2050 BPF_ALU32_REG(BPF_ADD, R4, R4), 2051 BPF_ALU32_REG(BPF_ADD, R4, R5), 2052 BPF_ALU32_REG(BPF_ADD, R4, R6), 2053 BPF_ALU32_REG(BPF_ADD, R4, R7), 2054 BPF_ALU32_REG(BPF_ADD, R4, R8), 2055 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 2056 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 2057 BPF_EXIT_INSN(), 2058 BPF_ALU32_REG(BPF_ADD, R5, R0), 2059 BPF_ALU32_REG(BPF_ADD, R5, R1), 2060 BPF_ALU32_REG(BPF_ADD, R5, R2), 2061 BPF_ALU32_REG(BPF_ADD, R5, R3), 2062 BPF_ALU32_REG(BPF_ADD, R5, R4), 2063 BPF_ALU32_REG(BPF_ADD, R5, R5), 2064 BPF_ALU32_REG(BPF_ADD, R5, R6), 2065 BPF_ALU32_REG(BPF_ADD, R5, R7), 2066 BPF_ALU32_REG(BPF_ADD, R5, R8), 2067 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 2068 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 2069 BPF_EXIT_INSN(), 2070 BPF_ALU32_REG(BPF_ADD, R6, R0), 2071 BPF_ALU32_REG(BPF_ADD, R6, R1), 2072 BPF_ALU32_REG(BPF_ADD, R6, R2), 2073 BPF_ALU32_REG(BPF_ADD, R6, R3), 2074 BPF_ALU32_REG(BPF_ADD, R6, R4), 2075 BPF_ALU32_REG(BPF_ADD, R6, R5), 2076 BPF_ALU32_REG(BPF_ADD, R6, R6), 2077 BPF_ALU32_REG(BPF_ADD, R6, R7), 2078 BPF_ALU32_REG(BPF_ADD, R6, R8), 2079 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 2080 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 2081 BPF_EXIT_INSN(), 2082 BPF_ALU32_REG(BPF_ADD, R7, R0), 2083 BPF_ALU32_REG(BPF_ADD, R7, R1), 2084 BPF_ALU32_REG(BPF_ADD, R7, R2), 2085 BPF_ALU32_REG(BPF_ADD, R7, R3), 2086 BPF_ALU32_REG(BPF_ADD, R7, R4), 2087 BPF_ALU32_REG(BPF_ADD, R7, R5), 2088 BPF_ALU32_REG(BPF_ADD, R7, R6), 2089 BPF_ALU32_REG(BPF_ADD, R7, R7), 2090 BPF_ALU32_REG(BPF_ADD, R7, R8), 2091 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 2092 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 2093 BPF_EXIT_INSN(), 2094 BPF_ALU32_REG(BPF_ADD, R8, R0), 2095 BPF_ALU32_REG(BPF_ADD, R8, R1), 2096 BPF_ALU32_REG(BPF_ADD, R8, R2), 2097 BPF_ALU32_REG(BPF_ADD, R8, R3), 2098 BPF_ALU32_REG(BPF_ADD, R8, R4), 2099 BPF_ALU32_REG(BPF_ADD, R8, R5), 2100 BPF_ALU32_REG(BPF_ADD, R8, R6), 2101 BPF_ALU32_REG(BPF_ADD, R8, R7), 2102 BPF_ALU32_REG(BPF_ADD, R8, R8), 2103 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 2104 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 2105 BPF_EXIT_INSN(), 2106 BPF_ALU32_REG(BPF_ADD, R9, R0), 2107 BPF_ALU32_REG(BPF_ADD, R9, R1), 2108 BPF_ALU32_REG(BPF_ADD, R9, R2), 2109 BPF_ALU32_REG(BPF_ADD, R9, R3), 2110 BPF_ALU32_REG(BPF_ADD, R9, R4), 2111 BPF_ALU32_REG(BPF_ADD, R9, R5), 2112 BPF_ALU32_REG(BPF_ADD, R9, R6), 2113 BPF_ALU32_REG(BPF_ADD, R9, R7), 2114 BPF_ALU32_REG(BPF_ADD, R9, R8), 2115 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 2116 BPF_ALU32_REG(BPF_MOV, R0, R9), 2117 BPF_EXIT_INSN(), 2118 }, 2119 INTERNAL, 2120 { }, 2121 { { 0, 2957380 } } 2122 }, 2123 { /* Mainly checking JIT here. */ 2124 "INT: SUB", 2125 .u.insns_int = { 2126 BPF_ALU64_IMM(BPF_MOV, R0, 0), 2127 BPF_ALU64_IMM(BPF_MOV, R1, 1), 2128 BPF_ALU64_IMM(BPF_MOV, R2, 2), 2129 BPF_ALU64_IMM(BPF_MOV, R3, 3), 2130 BPF_ALU64_IMM(BPF_MOV, R4, 4), 2131 BPF_ALU64_IMM(BPF_MOV, R5, 5), 2132 BPF_ALU64_IMM(BPF_MOV, R6, 6), 2133 BPF_ALU64_IMM(BPF_MOV, R7, 7), 2134 BPF_ALU64_IMM(BPF_MOV, R8, 8), 2135 BPF_ALU64_IMM(BPF_MOV, R9, 9), 2136 BPF_ALU64_REG(BPF_SUB, R0, R0), 2137 BPF_ALU64_REG(BPF_SUB, R0, R1), 2138 BPF_ALU64_REG(BPF_SUB, R0, R2), 2139 BPF_ALU64_REG(BPF_SUB, R0, R3), 2140 BPF_ALU64_REG(BPF_SUB, R0, R4), 2141 BPF_ALU64_REG(BPF_SUB, R0, R5), 2142 BPF_ALU64_REG(BPF_SUB, R0, R6), 2143 BPF_ALU64_REG(BPF_SUB, R0, R7), 2144 BPF_ALU64_REG(BPF_SUB, R0, R8), 2145 BPF_ALU64_REG(BPF_SUB, R0, R9), 2146 BPF_ALU64_IMM(BPF_SUB, R0, 10), 2147 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 2148 BPF_EXIT_INSN(), 2149 BPF_ALU64_REG(BPF_SUB, R1, R0), 2150 BPF_ALU64_REG(BPF_SUB, R1, R2), 2151 BPF_ALU64_REG(BPF_SUB, R1, R3), 2152 BPF_ALU64_REG(BPF_SUB, R1, R4), 2153 BPF_ALU64_REG(BPF_SUB, R1, R5), 2154 BPF_ALU64_REG(BPF_SUB, R1, R6), 2155 BPF_ALU64_REG(BPF_SUB, R1, R7), 2156 BPF_ALU64_REG(BPF_SUB, R1, R8), 2157 BPF_ALU64_REG(BPF_SUB, R1, R9), 2158 BPF_ALU64_IMM(BPF_SUB, R1, 10), 2159 BPF_ALU64_REG(BPF_SUB, R2, R0), 2160 BPF_ALU64_REG(BPF_SUB, R2, R1), 2161 BPF_ALU64_REG(BPF_SUB, R2, R3), 2162 BPF_ALU64_REG(BPF_SUB, R2, R4), 2163 BPF_ALU64_REG(BPF_SUB, R2, R5), 2164 BPF_ALU64_REG(BPF_SUB, R2, R6), 2165 BPF_ALU64_REG(BPF_SUB, R2, R7), 2166 BPF_ALU64_REG(BPF_SUB, R2, R8), 2167 BPF_ALU64_REG(BPF_SUB, R2, R9), 2168 BPF_ALU64_IMM(BPF_SUB, R2, 10), 2169 BPF_ALU64_REG(BPF_SUB, R3, R0), 2170 BPF_ALU64_REG(BPF_SUB, R3, R1), 2171 BPF_ALU64_REG(BPF_SUB, R3, R2), 2172 BPF_ALU64_REG(BPF_SUB, R3, R4), 2173 BPF_ALU64_REG(BPF_SUB, R3, R5), 2174 BPF_ALU64_REG(BPF_SUB, R3, R6), 2175 BPF_ALU64_REG(BPF_SUB, R3, R7), 2176 BPF_ALU64_REG(BPF_SUB, R3, R8), 2177 BPF_ALU64_REG(BPF_SUB, R3, R9), 2178 BPF_ALU64_IMM(BPF_SUB, R3, 10), 2179 BPF_ALU64_REG(BPF_SUB, R4, R0), 2180 BPF_ALU64_REG(BPF_SUB, R4, R1), 2181 BPF_ALU64_REG(BPF_SUB, R4, R2), 2182 BPF_ALU64_REG(BPF_SUB, R4, R3), 2183 BPF_ALU64_REG(BPF_SUB, R4, R5), 2184 BPF_ALU64_REG(BPF_SUB, R4, R6), 2185 BPF_ALU64_REG(BPF_SUB, R4, R7), 2186 BPF_ALU64_REG(BPF_SUB, R4, R8), 2187 BPF_ALU64_REG(BPF_SUB, R4, R9), 2188 BPF_ALU64_IMM(BPF_SUB, R4, 10), 2189 BPF_ALU64_REG(BPF_SUB, R5, R0), 2190 BPF_ALU64_REG(BPF_SUB, R5, R1), 2191 BPF_ALU64_REG(BPF_SUB, R5, R2), 2192 BPF_ALU64_REG(BPF_SUB, R5, R3), 2193 BPF_ALU64_REG(BPF_SUB, R5, R4), 2194 BPF_ALU64_REG(BPF_SUB, R5, R6), 2195 BPF_ALU64_REG(BPF_SUB, R5, R7), 2196 BPF_ALU64_REG(BPF_SUB, R5, R8), 2197 BPF_ALU64_REG(BPF_SUB, R5, R9), 2198 BPF_ALU64_IMM(BPF_SUB, R5, 10), 2199 BPF_ALU64_REG(BPF_SUB, R6, R0), 2200 BPF_ALU64_REG(BPF_SUB, R6, R1), 2201 BPF_ALU64_REG(BPF_SUB, R6, R2), 2202 BPF_ALU64_REG(BPF_SUB, R6, R3), 2203 BPF_ALU64_REG(BPF_SUB, R6, R4), 2204 BPF_ALU64_REG(BPF_SUB, R6, R5), 2205 BPF_ALU64_REG(BPF_SUB, R6, R7), 2206 BPF_ALU64_REG(BPF_SUB, R6, R8), 2207 BPF_ALU64_REG(BPF_SUB, R6, R9), 2208 BPF_ALU64_IMM(BPF_SUB, R6, 10), 2209 BPF_ALU64_REG(BPF_SUB, R7, R0), 2210 BPF_ALU64_REG(BPF_SUB, R7, R1), 2211 BPF_ALU64_REG(BPF_SUB, R7, R2), 2212 BPF_ALU64_REG(BPF_SUB, R7, R3), 2213 BPF_ALU64_REG(BPF_SUB, R7, R4), 2214 BPF_ALU64_REG(BPF_SUB, R7, R5), 2215 BPF_ALU64_REG(BPF_SUB, R7, R6), 2216 BPF_ALU64_REG(BPF_SUB, R7, R8), 2217 BPF_ALU64_REG(BPF_SUB, R7, R9), 2218 BPF_ALU64_IMM(BPF_SUB, R7, 10), 2219 BPF_ALU64_REG(BPF_SUB, R8, R0), 2220 BPF_ALU64_REG(BPF_SUB, R8, R1), 2221 BPF_ALU64_REG(BPF_SUB, R8, R2), 2222 BPF_ALU64_REG(BPF_SUB, R8, R3), 2223 BPF_ALU64_REG(BPF_SUB, R8, R4), 2224 BPF_ALU64_REG(BPF_SUB, R8, R5), 2225 BPF_ALU64_REG(BPF_SUB, R8, R6), 2226 BPF_ALU64_REG(BPF_SUB, R8, R7), 2227 BPF_ALU64_REG(BPF_SUB, R8, R9), 2228 BPF_ALU64_IMM(BPF_SUB, R8, 10), 2229 BPF_ALU64_REG(BPF_SUB, R9, R0), 2230 BPF_ALU64_REG(BPF_SUB, R9, R1), 2231 BPF_ALU64_REG(BPF_SUB, R9, R2), 2232 BPF_ALU64_REG(BPF_SUB, R9, R3), 2233 BPF_ALU64_REG(BPF_SUB, R9, R4), 2234 BPF_ALU64_REG(BPF_SUB, R9, R5), 2235 BPF_ALU64_REG(BPF_SUB, R9, R6), 2236 BPF_ALU64_REG(BPF_SUB, R9, R7), 2237 BPF_ALU64_REG(BPF_SUB, R9, R8), 2238 BPF_ALU64_IMM(BPF_SUB, R9, 10), 2239 BPF_ALU64_IMM(BPF_SUB, R0, 10), 2240 BPF_ALU64_IMM(BPF_NEG, R0, 0), 2241 BPF_ALU64_REG(BPF_SUB, R0, R1), 2242 BPF_ALU64_REG(BPF_SUB, R0, R2), 2243 BPF_ALU64_REG(BPF_SUB, R0, R3), 2244 BPF_ALU64_REG(BPF_SUB, R0, R4), 2245 BPF_ALU64_REG(BPF_SUB, R0, R5), 2246 BPF_ALU64_REG(BPF_SUB, R0, R6), 2247 BPF_ALU64_REG(BPF_SUB, R0, R7), 2248 BPF_ALU64_REG(BPF_SUB, R0, R8), 2249 BPF_ALU64_REG(BPF_SUB, R0, R9), 2250 BPF_EXIT_INSN(), 2251 }, 2252 INTERNAL, 2253 { }, 2254 { { 0, 11 } } 2255 }, 2256 { /* Mainly checking JIT here. */ 2257 "INT: XOR", 2258 .u.insns_int = { 2259 BPF_ALU64_REG(BPF_SUB, R0, R0), 2260 BPF_ALU64_REG(BPF_XOR, R1, R1), 2261 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 2262 BPF_EXIT_INSN(), 2263 BPF_ALU64_IMM(BPF_MOV, R0, 10), 2264 BPF_ALU64_IMM(BPF_MOV, R1, -1), 2265 BPF_ALU64_REG(BPF_SUB, R1, R1), 2266 BPF_ALU64_REG(BPF_XOR, R2, R2), 2267 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 2268 BPF_EXIT_INSN(), 2269 BPF_ALU64_REG(BPF_SUB, R2, R2), 2270 BPF_ALU64_REG(BPF_XOR, R3, R3), 2271 BPF_ALU64_IMM(BPF_MOV, R0, 10), 2272 BPF_ALU64_IMM(BPF_MOV, R1, -1), 2273 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 2274 BPF_EXIT_INSN(), 2275 BPF_ALU64_REG(BPF_SUB, R3, R3), 2276 BPF_ALU64_REG(BPF_XOR, R4, R4), 2277 BPF_ALU64_IMM(BPF_MOV, R2, 1), 2278 BPF_ALU64_IMM(BPF_MOV, R5, -1), 2279 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 2280 BPF_EXIT_INSN(), 2281 BPF_ALU64_REG(BPF_SUB, R4, R4), 2282 BPF_ALU64_REG(BPF_XOR, R5, R5), 2283 BPF_ALU64_IMM(BPF_MOV, R3, 1), 2284 BPF_ALU64_IMM(BPF_MOV, R7, -1), 2285 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 2286 BPF_EXIT_INSN(), 2287 BPF_ALU64_IMM(BPF_MOV, R5, 1), 2288 BPF_ALU64_REG(BPF_SUB, R5, R5), 2289 BPF_ALU64_REG(BPF_XOR, R6, R6), 2290 BPF_ALU64_IMM(BPF_MOV, R1, 1), 2291 BPF_ALU64_IMM(BPF_MOV, R8, -1), 2292 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 2293 BPF_EXIT_INSN(), 2294 BPF_ALU64_REG(BPF_SUB, R6, R6), 2295 BPF_ALU64_REG(BPF_XOR, R7, R7), 2296 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 2297 BPF_EXIT_INSN(), 2298 BPF_ALU64_REG(BPF_SUB, R7, R7), 2299 BPF_ALU64_REG(BPF_XOR, R8, R8), 2300 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 2301 BPF_EXIT_INSN(), 2302 BPF_ALU64_REG(BPF_SUB, R8, R8), 2303 BPF_ALU64_REG(BPF_XOR, R9, R9), 2304 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 2305 BPF_EXIT_INSN(), 2306 BPF_ALU64_REG(BPF_SUB, R9, R9), 2307 BPF_ALU64_REG(BPF_XOR, R0, R0), 2308 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 2309 BPF_EXIT_INSN(), 2310 BPF_ALU64_REG(BPF_SUB, R1, R1), 2311 BPF_ALU64_REG(BPF_XOR, R0, R0), 2312 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 2313 BPF_ALU64_IMM(BPF_MOV, R0, 0), 2314 BPF_EXIT_INSN(), 2315 BPF_ALU64_IMM(BPF_MOV, R0, 1), 2316 BPF_EXIT_INSN(), 2317 }, 2318 INTERNAL, 2319 { }, 2320 { { 0, 1 } } 2321 }, 2322 { /* Mainly checking JIT here. */ 2323 "INT: MUL", 2324 .u.insns_int = { 2325 BPF_ALU64_IMM(BPF_MOV, R0, 11), 2326 BPF_ALU64_IMM(BPF_MOV, R1, 1), 2327 BPF_ALU64_IMM(BPF_MOV, R2, 2), 2328 BPF_ALU64_IMM(BPF_MOV, R3, 3), 2329 BPF_ALU64_IMM(BPF_MOV, R4, 4), 2330 BPF_ALU64_IMM(BPF_MOV, R5, 5), 2331 BPF_ALU64_IMM(BPF_MOV, R6, 6), 2332 BPF_ALU64_IMM(BPF_MOV, R7, 7), 2333 BPF_ALU64_IMM(BPF_MOV, R8, 8), 2334 BPF_ALU64_IMM(BPF_MOV, R9, 9), 2335 BPF_ALU64_REG(BPF_MUL, R0, R0), 2336 BPF_ALU64_REG(BPF_MUL, R0, R1), 2337 BPF_ALU64_REG(BPF_MUL, R0, R2), 2338 BPF_ALU64_REG(BPF_MUL, R0, R3), 2339 BPF_ALU64_REG(BPF_MUL, R0, R4), 2340 BPF_ALU64_REG(BPF_MUL, R0, R5), 2341 BPF_ALU64_REG(BPF_MUL, R0, R6), 2342 BPF_ALU64_REG(BPF_MUL, R0, R7), 2343 BPF_ALU64_REG(BPF_MUL, R0, R8), 2344 BPF_ALU64_REG(BPF_MUL, R0, R9), 2345 BPF_ALU64_IMM(BPF_MUL, R0, 10), 2346 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 2347 BPF_EXIT_INSN(), 2348 BPF_ALU64_REG(BPF_MUL, R1, R0), 2349 BPF_ALU64_REG(BPF_MUL, R1, R2), 2350 BPF_ALU64_REG(BPF_MUL, R1, R3), 2351 BPF_ALU64_REG(BPF_MUL, R1, R4), 2352 BPF_ALU64_REG(BPF_MUL, R1, R5), 2353 BPF_ALU64_REG(BPF_MUL, R1, R6), 2354 BPF_ALU64_REG(BPF_MUL, R1, R7), 2355 BPF_ALU64_REG(BPF_MUL, R1, R8), 2356 BPF_ALU64_REG(BPF_MUL, R1, R9), 2357 BPF_ALU64_IMM(BPF_MUL, R1, 10), 2358 BPF_ALU64_REG(BPF_MOV, R2, R1), 2359 BPF_ALU64_IMM(BPF_RSH, R2, 32), 2360 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 2361 BPF_EXIT_INSN(), 2362 BPF_ALU64_IMM(BPF_LSH, R1, 32), 2363 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 2364 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 2365 BPF_EXIT_INSN(), 2366 BPF_ALU64_REG(BPF_MUL, R2, R0), 2367 BPF_ALU64_REG(BPF_MUL, R2, R1), 2368 BPF_ALU64_REG(BPF_MUL, R2, R3), 2369 BPF_ALU64_REG(BPF_MUL, R2, R4), 2370 BPF_ALU64_REG(BPF_MUL, R2, R5), 2371 BPF_ALU64_REG(BPF_MUL, R2, R6), 2372 BPF_ALU64_REG(BPF_MUL, R2, R7), 2373 BPF_ALU64_REG(BPF_MUL, R2, R8), 2374 BPF_ALU64_REG(BPF_MUL, R2, R9), 2375 BPF_ALU64_IMM(BPF_MUL, R2, 10), 2376 BPF_ALU64_IMM(BPF_RSH, R2, 32), 2377 BPF_ALU64_REG(BPF_MOV, R0, R2), 2378 BPF_EXIT_INSN(), 2379 }, 2380 INTERNAL, 2381 { }, 2382 { { 0, 0x35d97ef2 } } 2383 }, 2384 { /* Mainly checking JIT here. */ 2385 "MOV REG64", 2386 .u.insns_int = { 2387 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 2388 BPF_MOV64_REG(R1, R0), 2389 BPF_MOV64_REG(R2, R1), 2390 BPF_MOV64_REG(R3, R2), 2391 BPF_MOV64_REG(R4, R3), 2392 BPF_MOV64_REG(R5, R4), 2393 BPF_MOV64_REG(R6, R5), 2394 BPF_MOV64_REG(R7, R6), 2395 BPF_MOV64_REG(R8, R7), 2396 BPF_MOV64_REG(R9, R8), 2397 BPF_ALU64_IMM(BPF_MOV, R0, 0), 2398 BPF_ALU64_IMM(BPF_MOV, R1, 0), 2399 BPF_ALU64_IMM(BPF_MOV, R2, 0), 2400 BPF_ALU64_IMM(BPF_MOV, R3, 0), 2401 BPF_ALU64_IMM(BPF_MOV, R4, 0), 2402 BPF_ALU64_IMM(BPF_MOV, R5, 0), 2403 BPF_ALU64_IMM(BPF_MOV, R6, 0), 2404 BPF_ALU64_IMM(BPF_MOV, R7, 0), 2405 BPF_ALU64_IMM(BPF_MOV, R8, 0), 2406 BPF_ALU64_IMM(BPF_MOV, R9, 0), 2407 BPF_ALU64_REG(BPF_ADD, R0, R0), 2408 BPF_ALU64_REG(BPF_ADD, R0, R1), 2409 BPF_ALU64_REG(BPF_ADD, R0, R2), 2410 BPF_ALU64_REG(BPF_ADD, R0, R3), 2411 BPF_ALU64_REG(BPF_ADD, R0, R4), 2412 BPF_ALU64_REG(BPF_ADD, R0, R5), 2413 BPF_ALU64_REG(BPF_ADD, R0, R6), 2414 BPF_ALU64_REG(BPF_ADD, R0, R7), 2415 BPF_ALU64_REG(BPF_ADD, R0, R8), 2416 BPF_ALU64_REG(BPF_ADD, R0, R9), 2417 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 2418 BPF_EXIT_INSN(), 2419 }, 2420 INTERNAL, 2421 { }, 2422 { { 0, 0xfefe } } 2423 }, 2424 { /* Mainly checking JIT here. */ 2425 "MOV REG32", 2426 .u.insns_int = { 2427 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 2428 BPF_MOV64_REG(R1, R0), 2429 BPF_MOV64_REG(R2, R1), 2430 BPF_MOV64_REG(R3, R2), 2431 BPF_MOV64_REG(R4, R3), 2432 BPF_MOV64_REG(R5, R4), 2433 BPF_MOV64_REG(R6, R5), 2434 BPF_MOV64_REG(R7, R6), 2435 BPF_MOV64_REG(R8, R7), 2436 BPF_MOV64_REG(R9, R8), 2437 BPF_ALU32_IMM(BPF_MOV, R0, 0), 2438 BPF_ALU32_IMM(BPF_MOV, R1, 0), 2439 BPF_ALU32_IMM(BPF_MOV, R2, 0), 2440 BPF_ALU32_IMM(BPF_MOV, R3, 0), 2441 BPF_ALU32_IMM(BPF_MOV, R4, 0), 2442 BPF_ALU32_IMM(BPF_MOV, R5, 0), 2443 BPF_ALU32_IMM(BPF_MOV, R6, 0), 2444 BPF_ALU32_IMM(BPF_MOV, R7, 0), 2445 BPF_ALU32_IMM(BPF_MOV, R8, 0), 2446 BPF_ALU32_IMM(BPF_MOV, R9, 0), 2447 BPF_ALU64_REG(BPF_ADD, R0, R0), 2448 BPF_ALU64_REG(BPF_ADD, R0, R1), 2449 BPF_ALU64_REG(BPF_ADD, R0, R2), 2450 BPF_ALU64_REG(BPF_ADD, R0, R3), 2451 BPF_ALU64_REG(BPF_ADD, R0, R4), 2452 BPF_ALU64_REG(BPF_ADD, R0, R5), 2453 BPF_ALU64_REG(BPF_ADD, R0, R6), 2454 BPF_ALU64_REG(BPF_ADD, R0, R7), 2455 BPF_ALU64_REG(BPF_ADD, R0, R8), 2456 BPF_ALU64_REG(BPF_ADD, R0, R9), 2457 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 2458 BPF_EXIT_INSN(), 2459 }, 2460 INTERNAL, 2461 { }, 2462 { { 0, 0xfefe } } 2463 }, 2464 { /* Mainly checking JIT here. */ 2465 "LD IMM64", 2466 .u.insns_int = { 2467 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 2468 BPF_MOV64_REG(R1, R0), 2469 BPF_MOV64_REG(R2, R1), 2470 BPF_MOV64_REG(R3, R2), 2471 BPF_MOV64_REG(R4, R3), 2472 BPF_MOV64_REG(R5, R4), 2473 BPF_MOV64_REG(R6, R5), 2474 BPF_MOV64_REG(R7, R6), 2475 BPF_MOV64_REG(R8, R7), 2476 BPF_MOV64_REG(R9, R8), 2477 BPF_LD_IMM64(R0, 0x0LL), 2478 BPF_LD_IMM64(R1, 0x0LL), 2479 BPF_LD_IMM64(R2, 0x0LL), 2480 BPF_LD_IMM64(R3, 0x0LL), 2481 BPF_LD_IMM64(R4, 0x0LL), 2482 BPF_LD_IMM64(R5, 0x0LL), 2483 BPF_LD_IMM64(R6, 0x0LL), 2484 BPF_LD_IMM64(R7, 0x0LL), 2485 BPF_LD_IMM64(R8, 0x0LL), 2486 BPF_LD_IMM64(R9, 0x0LL), 2487 BPF_ALU64_REG(BPF_ADD, R0, R0), 2488 BPF_ALU64_REG(BPF_ADD, R0, R1), 2489 BPF_ALU64_REG(BPF_ADD, R0, R2), 2490 BPF_ALU64_REG(BPF_ADD, R0, R3), 2491 BPF_ALU64_REG(BPF_ADD, R0, R4), 2492 BPF_ALU64_REG(BPF_ADD, R0, R5), 2493 BPF_ALU64_REG(BPF_ADD, R0, R6), 2494 BPF_ALU64_REG(BPF_ADD, R0, R7), 2495 BPF_ALU64_REG(BPF_ADD, R0, R8), 2496 BPF_ALU64_REG(BPF_ADD, R0, R9), 2497 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 2498 BPF_EXIT_INSN(), 2499 }, 2500 INTERNAL, 2501 { }, 2502 { { 0, 0xfefe } } 2503 }, 2504 { 2505 "INT: ALU MIX", 2506 .u.insns_int = { 2507 BPF_ALU64_IMM(BPF_MOV, R0, 11), 2508 BPF_ALU64_IMM(BPF_ADD, R0, -1), 2509 BPF_ALU64_IMM(BPF_MOV, R2, 2), 2510 BPF_ALU64_IMM(BPF_XOR, R2, 3), 2511 BPF_ALU64_REG(BPF_DIV, R0, R2), 2512 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 2513 BPF_EXIT_INSN(), 2514 BPF_ALU64_IMM(BPF_MOD, R0, 3), 2515 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 2516 BPF_EXIT_INSN(), 2517 BPF_ALU64_IMM(BPF_MOV, R0, -1), 2518 BPF_EXIT_INSN(), 2519 }, 2520 INTERNAL, 2521 { }, 2522 { { 0, -1 } } 2523 }, 2524 { 2525 "INT: shifts by register", 2526 .u.insns_int = { 2527 BPF_MOV64_IMM(R0, -1234), 2528 BPF_MOV64_IMM(R1, 1), 2529 BPF_ALU32_REG(BPF_RSH, R0, R1), 2530 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1), 2531 BPF_EXIT_INSN(), 2532 BPF_MOV64_IMM(R2, 1), 2533 BPF_ALU64_REG(BPF_LSH, R0, R2), 2534 BPF_MOV32_IMM(R4, -1234), 2535 BPF_JMP_REG(BPF_JEQ, R0, R4, 1), 2536 BPF_EXIT_INSN(), 2537 BPF_ALU64_IMM(BPF_AND, R4, 63), 2538 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */ 2539 BPF_MOV64_IMM(R3, 47), 2540 BPF_ALU64_REG(BPF_ARSH, R0, R3), 2541 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1), 2542 BPF_EXIT_INSN(), 2543 BPF_MOV64_IMM(R2, 1), 2544 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */ 2545 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1), 2546 BPF_EXIT_INSN(), 2547 BPF_MOV64_IMM(R4, 4), 2548 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */ 2549 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1), 2550 BPF_EXIT_INSN(), 2551 BPF_MOV64_IMM(R4, 5), 2552 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */ 2553 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1), 2554 BPF_EXIT_INSN(), 2555 BPF_MOV64_IMM(R0, -1), 2556 BPF_EXIT_INSN(), 2557 }, 2558 INTERNAL, 2559 { }, 2560 { { 0, -1 } } 2561 }, 2562 { 2563 /* 2564 * Register (non-)clobbering test, in the case where a 32-bit 2565 * JIT implements complex ALU64 operations via function calls. 2566 * If so, the function call must be invisible in the eBPF 2567 * registers. The JIT must then save and restore relevant 2568 * registers during the call. The following tests check that 2569 * the eBPF registers retain their values after such a call. 2570 */ 2571 "INT: Register clobbering, R1 updated", 2572 .u.insns_int = { 2573 BPF_ALU32_IMM(BPF_MOV, R0, 0), 2574 BPF_ALU32_IMM(BPF_MOV, R1, 123456789), 2575 BPF_ALU32_IMM(BPF_MOV, R2, 2), 2576 BPF_ALU32_IMM(BPF_MOV, R3, 3), 2577 BPF_ALU32_IMM(BPF_MOV, R4, 4), 2578 BPF_ALU32_IMM(BPF_MOV, R5, 5), 2579 BPF_ALU32_IMM(BPF_MOV, R6, 6), 2580 BPF_ALU32_IMM(BPF_MOV, R7, 7), 2581 BPF_ALU32_IMM(BPF_MOV, R8, 8), 2582 BPF_ALU32_IMM(BPF_MOV, R9, 9), 2583 BPF_ALU64_IMM(BPF_DIV, R1, 123456789), 2584 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), 2585 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), 2586 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), 2587 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), 2588 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), 2589 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), 2590 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), 2591 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), 2592 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), 2593 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), 2594 BPF_ALU32_IMM(BPF_MOV, R0, 1), 2595 BPF_EXIT_INSN(), 2596 }, 2597 INTERNAL, 2598 { }, 2599 { { 0, 1 } } 2600 }, 2601 { 2602 "INT: Register clobbering, R2 updated", 2603 .u.insns_int = { 2604 BPF_ALU32_IMM(BPF_MOV, R0, 0), 2605 BPF_ALU32_IMM(BPF_MOV, R1, 1), 2606 BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789), 2607 BPF_ALU32_IMM(BPF_MOV, R3, 3), 2608 BPF_ALU32_IMM(BPF_MOV, R4, 4), 2609 BPF_ALU32_IMM(BPF_MOV, R5, 5), 2610 BPF_ALU32_IMM(BPF_MOV, R6, 6), 2611 BPF_ALU32_IMM(BPF_MOV, R7, 7), 2612 BPF_ALU32_IMM(BPF_MOV, R8, 8), 2613 BPF_ALU32_IMM(BPF_MOV, R9, 9), 2614 BPF_ALU64_IMM(BPF_DIV, R2, 123456789), 2615 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), 2616 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), 2617 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), 2618 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), 2619 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), 2620 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), 2621 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), 2622 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), 2623 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), 2624 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), 2625 BPF_ALU32_IMM(BPF_MOV, R0, 1), 2626 BPF_EXIT_INSN(), 2627 }, 2628 INTERNAL, 2629 { }, 2630 { { 0, 1 } } 2631 }, 2632 { 2633 /* 2634 * Test 32-bit JITs that implement complex ALU64 operations as 2635 * function calls R0 = f(R1, R2), and must re-arrange operands. 2636 */ 2637 #define NUMER 0xfedcba9876543210ULL 2638 #define DENOM 0x0123456789abcdefULL 2639 "ALU64_DIV X: Operand register permutations", 2640 .u.insns_int = { 2641 /* R0 / R2 */ 2642 BPF_LD_IMM64(R0, NUMER), 2643 BPF_LD_IMM64(R2, DENOM), 2644 BPF_ALU64_REG(BPF_DIV, R0, R2), 2645 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1), 2646 BPF_EXIT_INSN(), 2647 /* R1 / R0 */ 2648 BPF_LD_IMM64(R1, NUMER), 2649 BPF_LD_IMM64(R0, DENOM), 2650 BPF_ALU64_REG(BPF_DIV, R1, R0), 2651 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1), 2652 BPF_EXIT_INSN(), 2653 /* R0 / R1 */ 2654 BPF_LD_IMM64(R0, NUMER), 2655 BPF_LD_IMM64(R1, DENOM), 2656 BPF_ALU64_REG(BPF_DIV, R0, R1), 2657 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1), 2658 BPF_EXIT_INSN(), 2659 /* R2 / R0 */ 2660 BPF_LD_IMM64(R2, NUMER), 2661 BPF_LD_IMM64(R0, DENOM), 2662 BPF_ALU64_REG(BPF_DIV, R2, R0), 2663 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1), 2664 BPF_EXIT_INSN(), 2665 /* R2 / R1 */ 2666 BPF_LD_IMM64(R2, NUMER), 2667 BPF_LD_IMM64(R1, DENOM), 2668 BPF_ALU64_REG(BPF_DIV, R2, R1), 2669 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1), 2670 BPF_EXIT_INSN(), 2671 /* R1 / R2 */ 2672 BPF_LD_IMM64(R1, NUMER), 2673 BPF_LD_IMM64(R2, DENOM), 2674 BPF_ALU64_REG(BPF_DIV, R1, R2), 2675 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1), 2676 BPF_EXIT_INSN(), 2677 /* R1 / R1 */ 2678 BPF_LD_IMM64(R1, NUMER), 2679 BPF_ALU64_REG(BPF_DIV, R1, R1), 2680 BPF_JMP_IMM(BPF_JEQ, R1, 1, 1), 2681 BPF_EXIT_INSN(), 2682 /* R2 / R2 */ 2683 BPF_LD_IMM64(R2, DENOM), 2684 BPF_ALU64_REG(BPF_DIV, R2, R2), 2685 BPF_JMP_IMM(BPF_JEQ, R2, 1, 1), 2686 BPF_EXIT_INSN(), 2687 /* R3 / R4 */ 2688 BPF_LD_IMM64(R3, NUMER), 2689 BPF_LD_IMM64(R4, DENOM), 2690 BPF_ALU64_REG(BPF_DIV, R3, R4), 2691 BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1), 2692 BPF_EXIT_INSN(), 2693 /* Successful return */ 2694 BPF_LD_IMM64(R0, 1), 2695 BPF_EXIT_INSN(), 2696 }, 2697 INTERNAL, 2698 { }, 2699 { { 0, 1 } }, 2700 #undef NUMER 2701 #undef DENOM 2702 }, 2703 #ifdef CONFIG_32BIT 2704 { 2705 "INT: 32-bit context pointer word order and zero-extension", 2706 .u.insns_int = { 2707 BPF_ALU32_IMM(BPF_MOV, R0, 0), 2708 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3), 2709 BPF_ALU64_IMM(BPF_RSH, R1, 32), 2710 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1), 2711 BPF_ALU32_IMM(BPF_MOV, R0, 1), 2712 BPF_EXIT_INSN(), 2713 }, 2714 INTERNAL, 2715 { }, 2716 { { 0, 1 } } 2717 }, 2718 #endif 2719 { 2720 "check: missing ret", 2721 .u.insns = { 2722 BPF_STMT(BPF_LD | BPF_IMM, 1), 2723 }, 2724 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 2725 { }, 2726 { }, 2727 .fill_helper = NULL, 2728 .expected_errcode = -EINVAL, 2729 }, 2730 { 2731 "check: div_k_0", 2732 .u.insns = { 2733 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 2734 BPF_STMT(BPF_RET | BPF_K, 0) 2735 }, 2736 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 2737 { }, 2738 { }, 2739 .fill_helper = NULL, 2740 .expected_errcode = -EINVAL, 2741 }, 2742 { 2743 "check: unknown insn", 2744 .u.insns = { 2745 /* seccomp insn, rejected in socket filter */ 2746 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 2747 BPF_STMT(BPF_RET | BPF_K, 0) 2748 }, 2749 CLASSIC | FLAG_EXPECTED_FAIL, 2750 { }, 2751 { }, 2752 .fill_helper = NULL, 2753 .expected_errcode = -EINVAL, 2754 }, 2755 { 2756 "check: out of range spill/fill", 2757 .u.insns = { 2758 BPF_STMT(BPF_STX, 16), 2759 BPF_STMT(BPF_RET | BPF_K, 0) 2760 }, 2761 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 2762 { }, 2763 { }, 2764 .fill_helper = NULL, 2765 .expected_errcode = -EINVAL, 2766 }, 2767 { 2768 "JUMPS + HOLES", 2769 .u.insns = { 2770 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2771 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15), 2772 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2773 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2774 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2775 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2776 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2777 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2778 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2779 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2780 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2781 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2782 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2783 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2784 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2785 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4), 2786 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2787 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2), 2788 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2789 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 2790 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 2791 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2792 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2793 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2794 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2795 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2796 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2797 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2798 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2799 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2800 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2801 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2802 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2803 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2804 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3), 2805 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2), 2806 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2807 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 2808 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 2809 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2810 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2811 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2812 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2813 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2814 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2815 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2816 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2817 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2818 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2819 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2820 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2821 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2822 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3), 2823 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2), 2824 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 2825 BPF_STMT(BPF_RET | BPF_A, 0), 2826 BPF_STMT(BPF_RET | BPF_A, 0), 2827 }, 2828 CLASSIC, 2829 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 2830 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4, 2831 0x08, 0x00, 2832 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 2833 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */ 2834 0xc0, 0xa8, 0x33, 0x01, 2835 0xc0, 0xa8, 0x33, 0x02, 2836 0xbb, 0xb6, 2837 0xa9, 0xfa, 2838 0x00, 0x14, 0x00, 0x00, 2839 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2840 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2841 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2842 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2843 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2844 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2845 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 2846 0xcc, 0xcc, 0xcc, 0xcc }, 2847 { { 88, 0x001b } } 2848 }, 2849 { 2850 "check: RET X", 2851 .u.insns = { 2852 BPF_STMT(BPF_RET | BPF_X, 0), 2853 }, 2854 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 2855 { }, 2856 { }, 2857 .fill_helper = NULL, 2858 .expected_errcode = -EINVAL, 2859 }, 2860 { 2861 "check: LDX + RET X", 2862 .u.insns = { 2863 BPF_STMT(BPF_LDX | BPF_IMM, 42), 2864 BPF_STMT(BPF_RET | BPF_X, 0), 2865 }, 2866 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 2867 { }, 2868 { }, 2869 .fill_helper = NULL, 2870 .expected_errcode = -EINVAL, 2871 }, 2872 { /* Mainly checking JIT here. */ 2873 "M[]: alt STX + LDX", 2874 .u.insns = { 2875 BPF_STMT(BPF_LDX | BPF_IMM, 100), 2876 BPF_STMT(BPF_STX, 0), 2877 BPF_STMT(BPF_LDX | BPF_MEM, 0), 2878 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2879 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2880 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2881 BPF_STMT(BPF_STX, 1), 2882 BPF_STMT(BPF_LDX | BPF_MEM, 1), 2883 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2884 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2885 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2886 BPF_STMT(BPF_STX, 2), 2887 BPF_STMT(BPF_LDX | BPF_MEM, 2), 2888 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2889 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2890 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2891 BPF_STMT(BPF_STX, 3), 2892 BPF_STMT(BPF_LDX | BPF_MEM, 3), 2893 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2894 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2895 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2896 BPF_STMT(BPF_STX, 4), 2897 BPF_STMT(BPF_LDX | BPF_MEM, 4), 2898 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2899 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2900 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2901 BPF_STMT(BPF_STX, 5), 2902 BPF_STMT(BPF_LDX | BPF_MEM, 5), 2903 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2904 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2905 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2906 BPF_STMT(BPF_STX, 6), 2907 BPF_STMT(BPF_LDX | BPF_MEM, 6), 2908 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2909 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2910 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2911 BPF_STMT(BPF_STX, 7), 2912 BPF_STMT(BPF_LDX | BPF_MEM, 7), 2913 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2914 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2915 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2916 BPF_STMT(BPF_STX, 8), 2917 BPF_STMT(BPF_LDX | BPF_MEM, 8), 2918 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2919 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2920 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2921 BPF_STMT(BPF_STX, 9), 2922 BPF_STMT(BPF_LDX | BPF_MEM, 9), 2923 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2924 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2925 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2926 BPF_STMT(BPF_STX, 10), 2927 BPF_STMT(BPF_LDX | BPF_MEM, 10), 2928 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2929 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2930 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2931 BPF_STMT(BPF_STX, 11), 2932 BPF_STMT(BPF_LDX | BPF_MEM, 11), 2933 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2934 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2935 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2936 BPF_STMT(BPF_STX, 12), 2937 BPF_STMT(BPF_LDX | BPF_MEM, 12), 2938 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2939 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2940 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2941 BPF_STMT(BPF_STX, 13), 2942 BPF_STMT(BPF_LDX | BPF_MEM, 13), 2943 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2944 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2945 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2946 BPF_STMT(BPF_STX, 14), 2947 BPF_STMT(BPF_LDX | BPF_MEM, 14), 2948 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2949 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2950 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2951 BPF_STMT(BPF_STX, 15), 2952 BPF_STMT(BPF_LDX | BPF_MEM, 15), 2953 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2954 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 2955 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2956 BPF_STMT(BPF_RET | BPF_A, 0), 2957 }, 2958 CLASSIC | FLAG_NO_DATA, 2959 { }, 2960 { { 0, 116 } }, 2961 }, 2962 { /* Mainly checking JIT here. */ 2963 "M[]: full STX + full LDX", 2964 .u.insns = { 2965 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb), 2966 BPF_STMT(BPF_STX, 0), 2967 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae), 2968 BPF_STMT(BPF_STX, 1), 2969 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf), 2970 BPF_STMT(BPF_STX, 2), 2971 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc), 2972 BPF_STMT(BPF_STX, 3), 2973 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb), 2974 BPF_STMT(BPF_STX, 4), 2975 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda), 2976 BPF_STMT(BPF_STX, 5), 2977 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb), 2978 BPF_STMT(BPF_STX, 6), 2979 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade), 2980 BPF_STMT(BPF_STX, 7), 2981 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec), 2982 BPF_STMT(BPF_STX, 8), 2983 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc), 2984 BPF_STMT(BPF_STX, 9), 2985 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac), 2986 BPF_STMT(BPF_STX, 10), 2987 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea), 2988 BPF_STMT(BPF_STX, 11), 2989 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb), 2990 BPF_STMT(BPF_STX, 12), 2991 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf), 2992 BPF_STMT(BPF_STX, 13), 2993 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde), 2994 BPF_STMT(BPF_STX, 14), 2995 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad), 2996 BPF_STMT(BPF_STX, 15), 2997 BPF_STMT(BPF_LDX | BPF_MEM, 0), 2998 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2999 BPF_STMT(BPF_LDX | BPF_MEM, 1), 3000 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3001 BPF_STMT(BPF_LDX | BPF_MEM, 2), 3002 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3003 BPF_STMT(BPF_LDX | BPF_MEM, 3), 3004 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3005 BPF_STMT(BPF_LDX | BPF_MEM, 4), 3006 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3007 BPF_STMT(BPF_LDX | BPF_MEM, 5), 3008 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3009 BPF_STMT(BPF_LDX | BPF_MEM, 6), 3010 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3011 BPF_STMT(BPF_LDX | BPF_MEM, 7), 3012 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3013 BPF_STMT(BPF_LDX | BPF_MEM, 8), 3014 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3015 BPF_STMT(BPF_LDX | BPF_MEM, 9), 3016 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3017 BPF_STMT(BPF_LDX | BPF_MEM, 10), 3018 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3019 BPF_STMT(BPF_LDX | BPF_MEM, 11), 3020 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3021 BPF_STMT(BPF_LDX | BPF_MEM, 12), 3022 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3023 BPF_STMT(BPF_LDX | BPF_MEM, 13), 3024 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3025 BPF_STMT(BPF_LDX | BPF_MEM, 14), 3026 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3027 BPF_STMT(BPF_LDX | BPF_MEM, 15), 3028 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 3029 BPF_STMT(BPF_RET | BPF_A, 0), 3030 }, 3031 CLASSIC | FLAG_NO_DATA, 3032 { }, 3033 { { 0, 0x2a5a5e5 } }, 3034 }, 3035 { 3036 "check: SKF_AD_MAX", 3037 .u.insns = { 3038 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3039 SKF_AD_OFF + SKF_AD_MAX), 3040 BPF_STMT(BPF_RET | BPF_A, 0), 3041 }, 3042 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 3043 { }, 3044 { }, 3045 .fill_helper = NULL, 3046 .expected_errcode = -EINVAL, 3047 }, 3048 { /* Passes checker but fails during runtime. */ 3049 "LD [SKF_AD_OFF-1]", 3050 .u.insns = { 3051 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 3052 SKF_AD_OFF - 1), 3053 BPF_STMT(BPF_RET | BPF_K, 1), 3054 }, 3055 CLASSIC, 3056 { }, 3057 { { 1, 0 } }, 3058 }, 3059 { 3060 "load 64-bit immediate", 3061 .u.insns_int = { 3062 BPF_LD_IMM64(R1, 0x567800001234LL), 3063 BPF_MOV64_REG(R2, R1), 3064 BPF_MOV64_REG(R3, R2), 3065 BPF_ALU64_IMM(BPF_RSH, R2, 32), 3066 BPF_ALU64_IMM(BPF_LSH, R3, 32), 3067 BPF_ALU64_IMM(BPF_RSH, R3, 32), 3068 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3069 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1), 3070 BPF_EXIT_INSN(), 3071 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1), 3072 BPF_EXIT_INSN(), 3073 BPF_LD_IMM64(R0, 0x1ffffffffLL), 3074 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */ 3075 BPF_EXIT_INSN(), 3076 }, 3077 INTERNAL, 3078 { }, 3079 { { 0, 1 } } 3080 }, 3081 /* BPF_ALU | BPF_MOV | BPF_X */ 3082 { 3083 "ALU_MOV_X: dst = 2", 3084 .u.insns_int = { 3085 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3086 BPF_ALU32_REG(BPF_MOV, R0, R1), 3087 BPF_EXIT_INSN(), 3088 }, 3089 INTERNAL, 3090 { }, 3091 { { 0, 2 } }, 3092 }, 3093 { 3094 "ALU_MOV_X: dst = 4294967295", 3095 .u.insns_int = { 3096 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 3097 BPF_ALU32_REG(BPF_MOV, R0, R1), 3098 BPF_EXIT_INSN(), 3099 }, 3100 INTERNAL, 3101 { }, 3102 { { 0, 4294967295U } }, 3103 }, 3104 { 3105 "ALU64_MOV_X: dst = 2", 3106 .u.insns_int = { 3107 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3108 BPF_ALU64_REG(BPF_MOV, R0, R1), 3109 BPF_EXIT_INSN(), 3110 }, 3111 INTERNAL, 3112 { }, 3113 { { 0, 2 } }, 3114 }, 3115 { 3116 "ALU64_MOV_X: dst = 4294967295", 3117 .u.insns_int = { 3118 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 3119 BPF_ALU64_REG(BPF_MOV, R0, R1), 3120 BPF_EXIT_INSN(), 3121 }, 3122 INTERNAL, 3123 { }, 3124 { { 0, 4294967295U } }, 3125 }, 3126 /* BPF_ALU | BPF_MOV | BPF_K */ 3127 { 3128 "ALU_MOV_K: dst = 2", 3129 .u.insns_int = { 3130 BPF_ALU32_IMM(BPF_MOV, R0, 2), 3131 BPF_EXIT_INSN(), 3132 }, 3133 INTERNAL, 3134 { }, 3135 { { 0, 2 } }, 3136 }, 3137 { 3138 "ALU_MOV_K: dst = 4294967295", 3139 .u.insns_int = { 3140 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U), 3141 BPF_EXIT_INSN(), 3142 }, 3143 INTERNAL, 3144 { }, 3145 { { 0, 4294967295U } }, 3146 }, 3147 { 3148 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff", 3149 .u.insns_int = { 3150 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3151 BPF_LD_IMM64(R3, 0x00000000ffffffffLL), 3152 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff), 3153 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3154 BPF_MOV32_IMM(R0, 2), 3155 BPF_EXIT_INSN(), 3156 BPF_MOV32_IMM(R0, 1), 3157 BPF_EXIT_INSN(), 3158 }, 3159 INTERNAL, 3160 { }, 3161 { { 0, 0x1 } }, 3162 }, 3163 { 3164 "ALU_MOV_K: small negative", 3165 .u.insns_int = { 3166 BPF_ALU32_IMM(BPF_MOV, R0, -123), 3167 BPF_EXIT_INSN(), 3168 }, 3169 INTERNAL, 3170 { }, 3171 { { 0, -123 } } 3172 }, 3173 { 3174 "ALU_MOV_K: small negative zero extension", 3175 .u.insns_int = { 3176 BPF_ALU32_IMM(BPF_MOV, R0, -123), 3177 BPF_ALU64_IMM(BPF_RSH, R0, 32), 3178 BPF_EXIT_INSN(), 3179 }, 3180 INTERNAL, 3181 { }, 3182 { { 0, 0 } } 3183 }, 3184 { 3185 "ALU_MOV_K: large negative", 3186 .u.insns_int = { 3187 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 3188 BPF_EXIT_INSN(), 3189 }, 3190 INTERNAL, 3191 { }, 3192 { { 0, -123456789 } } 3193 }, 3194 { 3195 "ALU_MOV_K: large negative zero extension", 3196 .u.insns_int = { 3197 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 3198 BPF_ALU64_IMM(BPF_RSH, R0, 32), 3199 BPF_EXIT_INSN(), 3200 }, 3201 INTERNAL, 3202 { }, 3203 { { 0, 0 } } 3204 }, 3205 { 3206 "ALU64_MOV_K: dst = 2", 3207 .u.insns_int = { 3208 BPF_ALU64_IMM(BPF_MOV, R0, 2), 3209 BPF_EXIT_INSN(), 3210 }, 3211 INTERNAL, 3212 { }, 3213 { { 0, 2 } }, 3214 }, 3215 { 3216 "ALU64_MOV_K: dst = 2147483647", 3217 .u.insns_int = { 3218 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647), 3219 BPF_EXIT_INSN(), 3220 }, 3221 INTERNAL, 3222 { }, 3223 { { 0, 2147483647 } }, 3224 }, 3225 { 3226 "ALU64_OR_K: dst = 0x0", 3227 .u.insns_int = { 3228 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3229 BPF_LD_IMM64(R3, 0x0), 3230 BPF_ALU64_IMM(BPF_MOV, R2, 0x0), 3231 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3232 BPF_MOV32_IMM(R0, 2), 3233 BPF_EXIT_INSN(), 3234 BPF_MOV32_IMM(R0, 1), 3235 BPF_EXIT_INSN(), 3236 }, 3237 INTERNAL, 3238 { }, 3239 { { 0, 0x1 } }, 3240 }, 3241 { 3242 "ALU64_MOV_K: dst = -1", 3243 .u.insns_int = { 3244 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3245 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3246 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff), 3247 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3248 BPF_MOV32_IMM(R0, 2), 3249 BPF_EXIT_INSN(), 3250 BPF_MOV32_IMM(R0, 1), 3251 BPF_EXIT_INSN(), 3252 }, 3253 INTERNAL, 3254 { }, 3255 { { 0, 0x1 } }, 3256 }, 3257 { 3258 "ALU64_MOV_K: small negative", 3259 .u.insns_int = { 3260 BPF_ALU64_IMM(BPF_MOV, R0, -123), 3261 BPF_EXIT_INSN(), 3262 }, 3263 INTERNAL, 3264 { }, 3265 { { 0, -123 } } 3266 }, 3267 { 3268 "ALU64_MOV_K: small negative sign extension", 3269 .u.insns_int = { 3270 BPF_ALU64_IMM(BPF_MOV, R0, -123), 3271 BPF_ALU64_IMM(BPF_RSH, R0, 32), 3272 BPF_EXIT_INSN(), 3273 }, 3274 INTERNAL, 3275 { }, 3276 { { 0, 0xffffffff } } 3277 }, 3278 { 3279 "ALU64_MOV_K: large negative", 3280 .u.insns_int = { 3281 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 3282 BPF_EXIT_INSN(), 3283 }, 3284 INTERNAL, 3285 { }, 3286 { { 0, -123456789 } } 3287 }, 3288 { 3289 "ALU64_MOV_K: large negative sign extension", 3290 .u.insns_int = { 3291 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 3292 BPF_ALU64_IMM(BPF_RSH, R0, 32), 3293 BPF_EXIT_INSN(), 3294 }, 3295 INTERNAL, 3296 { }, 3297 { { 0, 0xffffffff } } 3298 }, 3299 /* BPF_ALU | BPF_ADD | BPF_X */ 3300 { 3301 "ALU_ADD_X: 1 + 2 = 3", 3302 .u.insns_int = { 3303 BPF_LD_IMM64(R0, 1), 3304 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3305 BPF_ALU32_REG(BPF_ADD, R0, R1), 3306 BPF_EXIT_INSN(), 3307 }, 3308 INTERNAL, 3309 { }, 3310 { { 0, 3 } }, 3311 }, 3312 { 3313 "ALU_ADD_X: 1 + 4294967294 = 4294967295", 3314 .u.insns_int = { 3315 BPF_LD_IMM64(R0, 1), 3316 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 3317 BPF_ALU32_REG(BPF_ADD, R0, R1), 3318 BPF_EXIT_INSN(), 3319 }, 3320 INTERNAL, 3321 { }, 3322 { { 0, 4294967295U } }, 3323 }, 3324 { 3325 "ALU_ADD_X: 2 + 4294967294 = 0", 3326 .u.insns_int = { 3327 BPF_LD_IMM64(R0, 2), 3328 BPF_LD_IMM64(R1, 4294967294U), 3329 BPF_ALU32_REG(BPF_ADD, R0, R1), 3330 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 3331 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3332 BPF_EXIT_INSN(), 3333 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3334 BPF_EXIT_INSN(), 3335 }, 3336 INTERNAL, 3337 { }, 3338 { { 0, 1 } }, 3339 }, 3340 { 3341 "ALU64_ADD_X: 1 + 2 = 3", 3342 .u.insns_int = { 3343 BPF_LD_IMM64(R0, 1), 3344 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3345 BPF_ALU64_REG(BPF_ADD, R0, R1), 3346 BPF_EXIT_INSN(), 3347 }, 3348 INTERNAL, 3349 { }, 3350 { { 0, 3 } }, 3351 }, 3352 { 3353 "ALU64_ADD_X: 1 + 4294967294 = 4294967295", 3354 .u.insns_int = { 3355 BPF_LD_IMM64(R0, 1), 3356 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 3357 BPF_ALU64_REG(BPF_ADD, R0, R1), 3358 BPF_EXIT_INSN(), 3359 }, 3360 INTERNAL, 3361 { }, 3362 { { 0, 4294967295U } }, 3363 }, 3364 { 3365 "ALU64_ADD_X: 2 + 4294967294 = 4294967296", 3366 .u.insns_int = { 3367 BPF_LD_IMM64(R0, 2), 3368 BPF_LD_IMM64(R1, 4294967294U), 3369 BPF_LD_IMM64(R2, 4294967296ULL), 3370 BPF_ALU64_REG(BPF_ADD, R0, R1), 3371 BPF_JMP_REG(BPF_JEQ, R0, R2, 2), 3372 BPF_MOV32_IMM(R0, 0), 3373 BPF_EXIT_INSN(), 3374 BPF_MOV32_IMM(R0, 1), 3375 BPF_EXIT_INSN(), 3376 }, 3377 INTERNAL, 3378 { }, 3379 { { 0, 1 } }, 3380 }, 3381 /* BPF_ALU | BPF_ADD | BPF_K */ 3382 { 3383 "ALU_ADD_K: 1 + 2 = 3", 3384 .u.insns_int = { 3385 BPF_LD_IMM64(R0, 1), 3386 BPF_ALU32_IMM(BPF_ADD, R0, 2), 3387 BPF_EXIT_INSN(), 3388 }, 3389 INTERNAL, 3390 { }, 3391 { { 0, 3 } }, 3392 }, 3393 { 3394 "ALU_ADD_K: 3 + 0 = 3", 3395 .u.insns_int = { 3396 BPF_LD_IMM64(R0, 3), 3397 BPF_ALU32_IMM(BPF_ADD, R0, 0), 3398 BPF_EXIT_INSN(), 3399 }, 3400 INTERNAL, 3401 { }, 3402 { { 0, 3 } }, 3403 }, 3404 { 3405 "ALU_ADD_K: 1 + 4294967294 = 4294967295", 3406 .u.insns_int = { 3407 BPF_LD_IMM64(R0, 1), 3408 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U), 3409 BPF_EXIT_INSN(), 3410 }, 3411 INTERNAL, 3412 { }, 3413 { { 0, 4294967295U } }, 3414 }, 3415 { 3416 "ALU_ADD_K: 4294967294 + 2 = 0", 3417 .u.insns_int = { 3418 BPF_LD_IMM64(R0, 4294967294U), 3419 BPF_ALU32_IMM(BPF_ADD, R0, 2), 3420 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 3421 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3422 BPF_EXIT_INSN(), 3423 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3424 BPF_EXIT_INSN(), 3425 }, 3426 INTERNAL, 3427 { }, 3428 { { 0, 1 } }, 3429 }, 3430 { 3431 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff", 3432 .u.insns_int = { 3433 BPF_LD_IMM64(R2, 0x0), 3434 BPF_LD_IMM64(R3, 0x00000000ffffffff), 3435 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff), 3436 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3437 BPF_MOV32_IMM(R0, 2), 3438 BPF_EXIT_INSN(), 3439 BPF_MOV32_IMM(R0, 1), 3440 BPF_EXIT_INSN(), 3441 }, 3442 INTERNAL, 3443 { }, 3444 { { 0, 0x1 } }, 3445 }, 3446 { 3447 "ALU_ADD_K: 0 + 0xffff = 0xffff", 3448 .u.insns_int = { 3449 BPF_LD_IMM64(R2, 0x0), 3450 BPF_LD_IMM64(R3, 0xffff), 3451 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff), 3452 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3453 BPF_MOV32_IMM(R0, 2), 3454 BPF_EXIT_INSN(), 3455 BPF_MOV32_IMM(R0, 1), 3456 BPF_EXIT_INSN(), 3457 }, 3458 INTERNAL, 3459 { }, 3460 { { 0, 0x1 } }, 3461 }, 3462 { 3463 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 3464 .u.insns_int = { 3465 BPF_LD_IMM64(R2, 0x0), 3466 BPF_LD_IMM64(R3, 0x7fffffff), 3467 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff), 3468 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3469 BPF_MOV32_IMM(R0, 2), 3470 BPF_EXIT_INSN(), 3471 BPF_MOV32_IMM(R0, 1), 3472 BPF_EXIT_INSN(), 3473 }, 3474 INTERNAL, 3475 { }, 3476 { { 0, 0x1 } }, 3477 }, 3478 { 3479 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000", 3480 .u.insns_int = { 3481 BPF_LD_IMM64(R2, 0x0), 3482 BPF_LD_IMM64(R3, 0x80000000), 3483 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000), 3484 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3485 BPF_MOV32_IMM(R0, 2), 3486 BPF_EXIT_INSN(), 3487 BPF_MOV32_IMM(R0, 1), 3488 BPF_EXIT_INSN(), 3489 }, 3490 INTERNAL, 3491 { }, 3492 { { 0, 0x1 } }, 3493 }, 3494 { 3495 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000", 3496 .u.insns_int = { 3497 BPF_LD_IMM64(R2, 0x0), 3498 BPF_LD_IMM64(R3, 0x80008000), 3499 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000), 3500 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3501 BPF_MOV32_IMM(R0, 2), 3502 BPF_EXIT_INSN(), 3503 BPF_MOV32_IMM(R0, 1), 3504 BPF_EXIT_INSN(), 3505 }, 3506 INTERNAL, 3507 { }, 3508 { { 0, 0x1 } }, 3509 }, 3510 { 3511 "ALU64_ADD_K: 1 + 2 = 3", 3512 .u.insns_int = { 3513 BPF_LD_IMM64(R0, 1), 3514 BPF_ALU64_IMM(BPF_ADD, R0, 2), 3515 BPF_EXIT_INSN(), 3516 }, 3517 INTERNAL, 3518 { }, 3519 { { 0, 3 } }, 3520 }, 3521 { 3522 "ALU64_ADD_K: 3 + 0 = 3", 3523 .u.insns_int = { 3524 BPF_LD_IMM64(R0, 3), 3525 BPF_ALU64_IMM(BPF_ADD, R0, 0), 3526 BPF_EXIT_INSN(), 3527 }, 3528 INTERNAL, 3529 { }, 3530 { { 0, 3 } }, 3531 }, 3532 { 3533 "ALU64_ADD_K: 1 + 2147483646 = 2147483647", 3534 .u.insns_int = { 3535 BPF_LD_IMM64(R0, 1), 3536 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646), 3537 BPF_EXIT_INSN(), 3538 }, 3539 INTERNAL, 3540 { }, 3541 { { 0, 2147483647 } }, 3542 }, 3543 { 3544 "ALU64_ADD_K: 4294967294 + 2 = 4294967296", 3545 .u.insns_int = { 3546 BPF_LD_IMM64(R0, 4294967294U), 3547 BPF_LD_IMM64(R1, 4294967296ULL), 3548 BPF_ALU64_IMM(BPF_ADD, R0, 2), 3549 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 3550 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3551 BPF_EXIT_INSN(), 3552 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3553 BPF_EXIT_INSN(), 3554 }, 3555 INTERNAL, 3556 { }, 3557 { { 0, 1 } }, 3558 }, 3559 { 3560 "ALU64_ADD_K: 2147483646 + -2147483647 = -1", 3561 .u.insns_int = { 3562 BPF_LD_IMM64(R0, 2147483646), 3563 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647), 3564 BPF_EXIT_INSN(), 3565 }, 3566 INTERNAL, 3567 { }, 3568 { { 0, -1 } }, 3569 }, 3570 { 3571 "ALU64_ADD_K: 1 + 0 = 1", 3572 .u.insns_int = { 3573 BPF_LD_IMM64(R2, 0x1), 3574 BPF_LD_IMM64(R3, 0x1), 3575 BPF_ALU64_IMM(BPF_ADD, R2, 0x0), 3576 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3577 BPF_MOV32_IMM(R0, 2), 3578 BPF_EXIT_INSN(), 3579 BPF_MOV32_IMM(R0, 1), 3580 BPF_EXIT_INSN(), 3581 }, 3582 INTERNAL, 3583 { }, 3584 { { 0, 0x1 } }, 3585 }, 3586 { 3587 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff", 3588 .u.insns_int = { 3589 BPF_LD_IMM64(R2, 0x0), 3590 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3591 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff), 3592 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3593 BPF_MOV32_IMM(R0, 2), 3594 BPF_EXIT_INSN(), 3595 BPF_MOV32_IMM(R0, 1), 3596 BPF_EXIT_INSN(), 3597 }, 3598 INTERNAL, 3599 { }, 3600 { { 0, 0x1 } }, 3601 }, 3602 { 3603 "ALU64_ADD_K: 0 + 0xffff = 0xffff", 3604 .u.insns_int = { 3605 BPF_LD_IMM64(R2, 0x0), 3606 BPF_LD_IMM64(R3, 0xffff), 3607 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff), 3608 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3609 BPF_MOV32_IMM(R0, 2), 3610 BPF_EXIT_INSN(), 3611 BPF_MOV32_IMM(R0, 1), 3612 BPF_EXIT_INSN(), 3613 }, 3614 INTERNAL, 3615 { }, 3616 { { 0, 0x1 } }, 3617 }, 3618 { 3619 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 3620 .u.insns_int = { 3621 BPF_LD_IMM64(R2, 0x0), 3622 BPF_LD_IMM64(R3, 0x7fffffff), 3623 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff), 3624 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3625 BPF_MOV32_IMM(R0, 2), 3626 BPF_EXIT_INSN(), 3627 BPF_MOV32_IMM(R0, 1), 3628 BPF_EXIT_INSN(), 3629 }, 3630 INTERNAL, 3631 { }, 3632 { { 0, 0x1 } }, 3633 }, 3634 { 3635 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000", 3636 .u.insns_int = { 3637 BPF_LD_IMM64(R2, 0x0), 3638 BPF_LD_IMM64(R3, 0xffffffff80000000LL), 3639 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000), 3640 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3641 BPF_MOV32_IMM(R0, 2), 3642 BPF_EXIT_INSN(), 3643 BPF_MOV32_IMM(R0, 1), 3644 BPF_EXIT_INSN(), 3645 }, 3646 INTERNAL, 3647 { }, 3648 { { 0, 0x1 } }, 3649 }, 3650 { 3651 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000", 3652 .u.insns_int = { 3653 BPF_LD_IMM64(R2, 0x0), 3654 BPF_LD_IMM64(R3, 0xffffffff80008000LL), 3655 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000), 3656 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3657 BPF_MOV32_IMM(R0, 2), 3658 BPF_EXIT_INSN(), 3659 BPF_MOV32_IMM(R0, 1), 3660 BPF_EXIT_INSN(), 3661 }, 3662 INTERNAL, 3663 { }, 3664 { { 0, 0x1 } }, 3665 }, 3666 /* BPF_ALU | BPF_SUB | BPF_X */ 3667 { 3668 "ALU_SUB_X: 3 - 1 = 2", 3669 .u.insns_int = { 3670 BPF_LD_IMM64(R0, 3), 3671 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3672 BPF_ALU32_REG(BPF_SUB, R0, R1), 3673 BPF_EXIT_INSN(), 3674 }, 3675 INTERNAL, 3676 { }, 3677 { { 0, 2 } }, 3678 }, 3679 { 3680 "ALU_SUB_X: 4294967295 - 4294967294 = 1", 3681 .u.insns_int = { 3682 BPF_LD_IMM64(R0, 4294967295U), 3683 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 3684 BPF_ALU32_REG(BPF_SUB, R0, R1), 3685 BPF_EXIT_INSN(), 3686 }, 3687 INTERNAL, 3688 { }, 3689 { { 0, 1 } }, 3690 }, 3691 { 3692 "ALU64_SUB_X: 3 - 1 = 2", 3693 .u.insns_int = { 3694 BPF_LD_IMM64(R0, 3), 3695 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3696 BPF_ALU64_REG(BPF_SUB, R0, R1), 3697 BPF_EXIT_INSN(), 3698 }, 3699 INTERNAL, 3700 { }, 3701 { { 0, 2 } }, 3702 }, 3703 { 3704 "ALU64_SUB_X: 4294967295 - 4294967294 = 1", 3705 .u.insns_int = { 3706 BPF_LD_IMM64(R0, 4294967295U), 3707 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 3708 BPF_ALU64_REG(BPF_SUB, R0, R1), 3709 BPF_EXIT_INSN(), 3710 }, 3711 INTERNAL, 3712 { }, 3713 { { 0, 1 } }, 3714 }, 3715 /* BPF_ALU | BPF_SUB | BPF_K */ 3716 { 3717 "ALU_SUB_K: 3 - 1 = 2", 3718 .u.insns_int = { 3719 BPF_LD_IMM64(R0, 3), 3720 BPF_ALU32_IMM(BPF_SUB, R0, 1), 3721 BPF_EXIT_INSN(), 3722 }, 3723 INTERNAL, 3724 { }, 3725 { { 0, 2 } }, 3726 }, 3727 { 3728 "ALU_SUB_K: 3 - 0 = 3", 3729 .u.insns_int = { 3730 BPF_LD_IMM64(R0, 3), 3731 BPF_ALU32_IMM(BPF_SUB, R0, 0), 3732 BPF_EXIT_INSN(), 3733 }, 3734 INTERNAL, 3735 { }, 3736 { { 0, 3 } }, 3737 }, 3738 { 3739 "ALU_SUB_K: 4294967295 - 4294967294 = 1", 3740 .u.insns_int = { 3741 BPF_LD_IMM64(R0, 4294967295U), 3742 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U), 3743 BPF_EXIT_INSN(), 3744 }, 3745 INTERNAL, 3746 { }, 3747 { { 0, 1 } }, 3748 }, 3749 { 3750 "ALU64_SUB_K: 3 - 1 = 2", 3751 .u.insns_int = { 3752 BPF_LD_IMM64(R0, 3), 3753 BPF_ALU64_IMM(BPF_SUB, R0, 1), 3754 BPF_EXIT_INSN(), 3755 }, 3756 INTERNAL, 3757 { }, 3758 { { 0, 2 } }, 3759 }, 3760 { 3761 "ALU64_SUB_K: 3 - 0 = 3", 3762 .u.insns_int = { 3763 BPF_LD_IMM64(R0, 3), 3764 BPF_ALU64_IMM(BPF_SUB, R0, 0), 3765 BPF_EXIT_INSN(), 3766 }, 3767 INTERNAL, 3768 { }, 3769 { { 0, 3 } }, 3770 }, 3771 { 3772 "ALU64_SUB_K: 4294967294 - 4294967295 = -1", 3773 .u.insns_int = { 3774 BPF_LD_IMM64(R0, 4294967294U), 3775 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U), 3776 BPF_EXIT_INSN(), 3777 }, 3778 INTERNAL, 3779 { }, 3780 { { 0, -1 } }, 3781 }, 3782 { 3783 "ALU64_ADD_K: 2147483646 - 2147483647 = -1", 3784 .u.insns_int = { 3785 BPF_LD_IMM64(R0, 2147483646), 3786 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647), 3787 BPF_EXIT_INSN(), 3788 }, 3789 INTERNAL, 3790 { }, 3791 { { 0, -1 } }, 3792 }, 3793 /* BPF_ALU | BPF_MUL | BPF_X */ 3794 { 3795 "ALU_MUL_X: 2 * 3 = 6", 3796 .u.insns_int = { 3797 BPF_LD_IMM64(R0, 2), 3798 BPF_ALU32_IMM(BPF_MOV, R1, 3), 3799 BPF_ALU32_REG(BPF_MUL, R0, R1), 3800 BPF_EXIT_INSN(), 3801 }, 3802 INTERNAL, 3803 { }, 3804 { { 0, 6 } }, 3805 }, 3806 { 3807 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 3808 .u.insns_int = { 3809 BPF_LD_IMM64(R0, 2), 3810 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8), 3811 BPF_ALU32_REG(BPF_MUL, R0, R1), 3812 BPF_EXIT_INSN(), 3813 }, 3814 INTERNAL, 3815 { }, 3816 { { 0, 0xFFFFFFF0 } }, 3817 }, 3818 { 3819 "ALU_MUL_X: -1 * -1 = 1", 3820 .u.insns_int = { 3821 BPF_LD_IMM64(R0, -1), 3822 BPF_ALU32_IMM(BPF_MOV, R1, -1), 3823 BPF_ALU32_REG(BPF_MUL, R0, R1), 3824 BPF_EXIT_INSN(), 3825 }, 3826 INTERNAL, 3827 { }, 3828 { { 0, 1 } }, 3829 }, 3830 { 3831 "ALU64_MUL_X: 2 * 3 = 6", 3832 .u.insns_int = { 3833 BPF_LD_IMM64(R0, 2), 3834 BPF_ALU32_IMM(BPF_MOV, R1, 3), 3835 BPF_ALU64_REG(BPF_MUL, R0, R1), 3836 BPF_EXIT_INSN(), 3837 }, 3838 INTERNAL, 3839 { }, 3840 { { 0, 6 } }, 3841 }, 3842 { 3843 "ALU64_MUL_X: 1 * 2147483647 = 2147483647", 3844 .u.insns_int = { 3845 BPF_LD_IMM64(R0, 1), 3846 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 3847 BPF_ALU64_REG(BPF_MUL, R0, R1), 3848 BPF_EXIT_INSN(), 3849 }, 3850 INTERNAL, 3851 { }, 3852 { { 0, 2147483647 } }, 3853 }, 3854 { 3855 "ALU64_MUL_X: 64x64 multiply, low word", 3856 .u.insns_int = { 3857 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 3858 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 3859 BPF_ALU64_REG(BPF_MUL, R0, R1), 3860 BPF_EXIT_INSN(), 3861 }, 3862 INTERNAL, 3863 { }, 3864 { { 0, 0xe5618cf0 } } 3865 }, 3866 { 3867 "ALU64_MUL_X: 64x64 multiply, high word", 3868 .u.insns_int = { 3869 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 3870 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 3871 BPF_ALU64_REG(BPF_MUL, R0, R1), 3872 BPF_ALU64_IMM(BPF_RSH, R0, 32), 3873 BPF_EXIT_INSN(), 3874 }, 3875 INTERNAL, 3876 { }, 3877 { { 0, 0x2236d88f } } 3878 }, 3879 /* BPF_ALU | BPF_MUL | BPF_K */ 3880 { 3881 "ALU_MUL_K: 2 * 3 = 6", 3882 .u.insns_int = { 3883 BPF_LD_IMM64(R0, 2), 3884 BPF_ALU32_IMM(BPF_MUL, R0, 3), 3885 BPF_EXIT_INSN(), 3886 }, 3887 INTERNAL, 3888 { }, 3889 { { 0, 6 } }, 3890 }, 3891 { 3892 "ALU_MUL_K: 3 * 1 = 3", 3893 .u.insns_int = { 3894 BPF_LD_IMM64(R0, 3), 3895 BPF_ALU32_IMM(BPF_MUL, R0, 1), 3896 BPF_EXIT_INSN(), 3897 }, 3898 INTERNAL, 3899 { }, 3900 { { 0, 3 } }, 3901 }, 3902 { 3903 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 3904 .u.insns_int = { 3905 BPF_LD_IMM64(R0, 2), 3906 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8), 3907 BPF_EXIT_INSN(), 3908 }, 3909 INTERNAL, 3910 { }, 3911 { { 0, 0xFFFFFFF0 } }, 3912 }, 3913 { 3914 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff", 3915 .u.insns_int = { 3916 BPF_LD_IMM64(R2, 0x1), 3917 BPF_LD_IMM64(R3, 0x00000000ffffffff), 3918 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff), 3919 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3920 BPF_MOV32_IMM(R0, 2), 3921 BPF_EXIT_INSN(), 3922 BPF_MOV32_IMM(R0, 1), 3923 BPF_EXIT_INSN(), 3924 }, 3925 INTERNAL, 3926 { }, 3927 { { 0, 0x1 } }, 3928 }, 3929 { 3930 "ALU64_MUL_K: 2 * 3 = 6", 3931 .u.insns_int = { 3932 BPF_LD_IMM64(R0, 2), 3933 BPF_ALU64_IMM(BPF_MUL, R0, 3), 3934 BPF_EXIT_INSN(), 3935 }, 3936 INTERNAL, 3937 { }, 3938 { { 0, 6 } }, 3939 }, 3940 { 3941 "ALU64_MUL_K: 3 * 1 = 3", 3942 .u.insns_int = { 3943 BPF_LD_IMM64(R0, 3), 3944 BPF_ALU64_IMM(BPF_MUL, R0, 1), 3945 BPF_EXIT_INSN(), 3946 }, 3947 INTERNAL, 3948 { }, 3949 { { 0, 3 } }, 3950 }, 3951 { 3952 "ALU64_MUL_K: 1 * 2147483647 = 2147483647", 3953 .u.insns_int = { 3954 BPF_LD_IMM64(R0, 1), 3955 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647), 3956 BPF_EXIT_INSN(), 3957 }, 3958 INTERNAL, 3959 { }, 3960 { { 0, 2147483647 } }, 3961 }, 3962 { 3963 "ALU64_MUL_K: 1 * -2147483647 = -2147483647", 3964 .u.insns_int = { 3965 BPF_LD_IMM64(R0, 1), 3966 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647), 3967 BPF_EXIT_INSN(), 3968 }, 3969 INTERNAL, 3970 { }, 3971 { { 0, -2147483647 } }, 3972 }, 3973 { 3974 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff", 3975 .u.insns_int = { 3976 BPF_LD_IMM64(R2, 0x1), 3977 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3978 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff), 3979 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3980 BPF_MOV32_IMM(R0, 2), 3981 BPF_EXIT_INSN(), 3982 BPF_MOV32_IMM(R0, 1), 3983 BPF_EXIT_INSN(), 3984 }, 3985 INTERNAL, 3986 { }, 3987 { { 0, 0x1 } }, 3988 }, 3989 { 3990 "ALU64_MUL_K: 64x32 multiply, low word", 3991 .u.insns_int = { 3992 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3993 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 3994 BPF_EXIT_INSN(), 3995 }, 3996 INTERNAL, 3997 { }, 3998 { { 0, 0xe242d208 } } 3999 }, 4000 { 4001 "ALU64_MUL_K: 64x32 multiply, high word", 4002 .u.insns_int = { 4003 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4004 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 4005 BPF_ALU64_IMM(BPF_RSH, R0, 32), 4006 BPF_EXIT_INSN(), 4007 }, 4008 INTERNAL, 4009 { }, 4010 { { 0, 0xc28f5c28 } } 4011 }, 4012 /* BPF_ALU | BPF_DIV | BPF_X */ 4013 { 4014 "ALU_DIV_X: 6 / 2 = 3", 4015 .u.insns_int = { 4016 BPF_LD_IMM64(R0, 6), 4017 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4018 BPF_ALU32_REG(BPF_DIV, R0, R1), 4019 BPF_EXIT_INSN(), 4020 }, 4021 INTERNAL, 4022 { }, 4023 { { 0, 3 } }, 4024 }, 4025 { 4026 "ALU_DIV_X: 4294967295 / 4294967295 = 1", 4027 .u.insns_int = { 4028 BPF_LD_IMM64(R0, 4294967295U), 4029 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 4030 BPF_ALU32_REG(BPF_DIV, R0, R1), 4031 BPF_EXIT_INSN(), 4032 }, 4033 INTERNAL, 4034 { }, 4035 { { 0, 1 } }, 4036 }, 4037 { 4038 "ALU64_DIV_X: 6 / 2 = 3", 4039 .u.insns_int = { 4040 BPF_LD_IMM64(R0, 6), 4041 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4042 BPF_ALU64_REG(BPF_DIV, R0, R1), 4043 BPF_EXIT_INSN(), 4044 }, 4045 INTERNAL, 4046 { }, 4047 { { 0, 3 } }, 4048 }, 4049 { 4050 "ALU64_DIV_X: 2147483647 / 2147483647 = 1", 4051 .u.insns_int = { 4052 BPF_LD_IMM64(R0, 2147483647), 4053 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 4054 BPF_ALU64_REG(BPF_DIV, R0, R1), 4055 BPF_EXIT_INSN(), 4056 }, 4057 INTERNAL, 4058 { }, 4059 { { 0, 1 } }, 4060 }, 4061 { 4062 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001", 4063 .u.insns_int = { 4064 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 4065 BPF_LD_IMM64(R4, 0xffffffffffffffffLL), 4066 BPF_LD_IMM64(R3, 0x0000000000000001LL), 4067 BPF_ALU64_REG(BPF_DIV, R2, R4), 4068 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4069 BPF_MOV32_IMM(R0, 2), 4070 BPF_EXIT_INSN(), 4071 BPF_MOV32_IMM(R0, 1), 4072 BPF_EXIT_INSN(), 4073 }, 4074 INTERNAL, 4075 { }, 4076 { { 0, 0x1 } }, 4077 }, 4078 /* BPF_ALU | BPF_DIV | BPF_K */ 4079 { 4080 "ALU_DIV_K: 6 / 2 = 3", 4081 .u.insns_int = { 4082 BPF_LD_IMM64(R0, 6), 4083 BPF_ALU32_IMM(BPF_DIV, R0, 2), 4084 BPF_EXIT_INSN(), 4085 }, 4086 INTERNAL, 4087 { }, 4088 { { 0, 3 } }, 4089 }, 4090 { 4091 "ALU_DIV_K: 3 / 1 = 3", 4092 .u.insns_int = { 4093 BPF_LD_IMM64(R0, 3), 4094 BPF_ALU32_IMM(BPF_DIV, R0, 1), 4095 BPF_EXIT_INSN(), 4096 }, 4097 INTERNAL, 4098 { }, 4099 { { 0, 3 } }, 4100 }, 4101 { 4102 "ALU_DIV_K: 4294967295 / 4294967295 = 1", 4103 .u.insns_int = { 4104 BPF_LD_IMM64(R0, 4294967295U), 4105 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U), 4106 BPF_EXIT_INSN(), 4107 }, 4108 INTERNAL, 4109 { }, 4110 { { 0, 1 } }, 4111 }, 4112 { 4113 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1", 4114 .u.insns_int = { 4115 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 4116 BPF_LD_IMM64(R3, 0x1UL), 4117 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff), 4118 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4119 BPF_MOV32_IMM(R0, 2), 4120 BPF_EXIT_INSN(), 4121 BPF_MOV32_IMM(R0, 1), 4122 BPF_EXIT_INSN(), 4123 }, 4124 INTERNAL, 4125 { }, 4126 { { 0, 0x1 } }, 4127 }, 4128 { 4129 "ALU64_DIV_K: 6 / 2 = 3", 4130 .u.insns_int = { 4131 BPF_LD_IMM64(R0, 6), 4132 BPF_ALU64_IMM(BPF_DIV, R0, 2), 4133 BPF_EXIT_INSN(), 4134 }, 4135 INTERNAL, 4136 { }, 4137 { { 0, 3 } }, 4138 }, 4139 { 4140 "ALU64_DIV_K: 3 / 1 = 3", 4141 .u.insns_int = { 4142 BPF_LD_IMM64(R0, 3), 4143 BPF_ALU64_IMM(BPF_DIV, R0, 1), 4144 BPF_EXIT_INSN(), 4145 }, 4146 INTERNAL, 4147 { }, 4148 { { 0, 3 } }, 4149 }, 4150 { 4151 "ALU64_DIV_K: 2147483647 / 2147483647 = 1", 4152 .u.insns_int = { 4153 BPF_LD_IMM64(R0, 2147483647), 4154 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647), 4155 BPF_EXIT_INSN(), 4156 }, 4157 INTERNAL, 4158 { }, 4159 { { 0, 1 } }, 4160 }, 4161 { 4162 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001", 4163 .u.insns_int = { 4164 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 4165 BPF_LD_IMM64(R3, 0x0000000000000001LL), 4166 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff), 4167 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4168 BPF_MOV32_IMM(R0, 2), 4169 BPF_EXIT_INSN(), 4170 BPF_MOV32_IMM(R0, 1), 4171 BPF_EXIT_INSN(), 4172 }, 4173 INTERNAL, 4174 { }, 4175 { { 0, 0x1 } }, 4176 }, 4177 /* BPF_ALU | BPF_MOD | BPF_X */ 4178 { 4179 "ALU_MOD_X: 3 % 2 = 1", 4180 .u.insns_int = { 4181 BPF_LD_IMM64(R0, 3), 4182 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4183 BPF_ALU32_REG(BPF_MOD, R0, R1), 4184 BPF_EXIT_INSN(), 4185 }, 4186 INTERNAL, 4187 { }, 4188 { { 0, 1 } }, 4189 }, 4190 { 4191 "ALU_MOD_X: 4294967295 % 4294967293 = 2", 4192 .u.insns_int = { 4193 BPF_LD_IMM64(R0, 4294967295U), 4194 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U), 4195 BPF_ALU32_REG(BPF_MOD, R0, R1), 4196 BPF_EXIT_INSN(), 4197 }, 4198 INTERNAL, 4199 { }, 4200 { { 0, 2 } }, 4201 }, 4202 { 4203 "ALU64_MOD_X: 3 % 2 = 1", 4204 .u.insns_int = { 4205 BPF_LD_IMM64(R0, 3), 4206 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4207 BPF_ALU64_REG(BPF_MOD, R0, R1), 4208 BPF_EXIT_INSN(), 4209 }, 4210 INTERNAL, 4211 { }, 4212 { { 0, 1 } }, 4213 }, 4214 { 4215 "ALU64_MOD_X: 2147483647 % 2147483645 = 2", 4216 .u.insns_int = { 4217 BPF_LD_IMM64(R0, 2147483647), 4218 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645), 4219 BPF_ALU64_REG(BPF_MOD, R0, R1), 4220 BPF_EXIT_INSN(), 4221 }, 4222 INTERNAL, 4223 { }, 4224 { { 0, 2 } }, 4225 }, 4226 /* BPF_ALU | BPF_MOD | BPF_K */ 4227 { 4228 "ALU_MOD_K: 3 % 2 = 1", 4229 .u.insns_int = { 4230 BPF_LD_IMM64(R0, 3), 4231 BPF_ALU32_IMM(BPF_MOD, R0, 2), 4232 BPF_EXIT_INSN(), 4233 }, 4234 INTERNAL, 4235 { }, 4236 { { 0, 1 } }, 4237 }, 4238 { 4239 "ALU_MOD_K: 3 % 1 = 0", 4240 .u.insns_int = { 4241 BPF_LD_IMM64(R0, 3), 4242 BPF_ALU32_IMM(BPF_MOD, R0, 1), 4243 BPF_EXIT_INSN(), 4244 }, 4245 INTERNAL, 4246 { }, 4247 { { 0, 0 } }, 4248 }, 4249 { 4250 "ALU_MOD_K: 4294967295 % 4294967293 = 2", 4251 .u.insns_int = { 4252 BPF_LD_IMM64(R0, 4294967295U), 4253 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U), 4254 BPF_EXIT_INSN(), 4255 }, 4256 INTERNAL, 4257 { }, 4258 { { 0, 2 } }, 4259 }, 4260 { 4261 "ALU64_MOD_K: 3 % 2 = 1", 4262 .u.insns_int = { 4263 BPF_LD_IMM64(R0, 3), 4264 BPF_ALU64_IMM(BPF_MOD, R0, 2), 4265 BPF_EXIT_INSN(), 4266 }, 4267 INTERNAL, 4268 { }, 4269 { { 0, 1 } }, 4270 }, 4271 { 4272 "ALU64_MOD_K: 3 % 1 = 0", 4273 .u.insns_int = { 4274 BPF_LD_IMM64(R0, 3), 4275 BPF_ALU64_IMM(BPF_MOD, R0, 1), 4276 BPF_EXIT_INSN(), 4277 }, 4278 INTERNAL, 4279 { }, 4280 { { 0, 0 } }, 4281 }, 4282 { 4283 "ALU64_MOD_K: 2147483647 % 2147483645 = 2", 4284 .u.insns_int = { 4285 BPF_LD_IMM64(R0, 2147483647), 4286 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645), 4287 BPF_EXIT_INSN(), 4288 }, 4289 INTERNAL, 4290 { }, 4291 { { 0, 2 } }, 4292 }, 4293 /* BPF_ALU | BPF_AND | BPF_X */ 4294 { 4295 "ALU_AND_X: 3 & 2 = 2", 4296 .u.insns_int = { 4297 BPF_LD_IMM64(R0, 3), 4298 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4299 BPF_ALU32_REG(BPF_AND, R0, R1), 4300 BPF_EXIT_INSN(), 4301 }, 4302 INTERNAL, 4303 { }, 4304 { { 0, 2 } }, 4305 }, 4306 { 4307 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 4308 .u.insns_int = { 4309 BPF_LD_IMM64(R0, 0xffffffff), 4310 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4311 BPF_ALU32_REG(BPF_AND, R0, R1), 4312 BPF_EXIT_INSN(), 4313 }, 4314 INTERNAL, 4315 { }, 4316 { { 0, 0xffffffff } }, 4317 }, 4318 { 4319 "ALU64_AND_X: 3 & 2 = 2", 4320 .u.insns_int = { 4321 BPF_LD_IMM64(R0, 3), 4322 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4323 BPF_ALU64_REG(BPF_AND, R0, R1), 4324 BPF_EXIT_INSN(), 4325 }, 4326 INTERNAL, 4327 { }, 4328 { { 0, 2 } }, 4329 }, 4330 { 4331 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 4332 .u.insns_int = { 4333 BPF_LD_IMM64(R0, 0xffffffff), 4334 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4335 BPF_ALU64_REG(BPF_AND, R0, R1), 4336 BPF_EXIT_INSN(), 4337 }, 4338 INTERNAL, 4339 { }, 4340 { { 0, 0xffffffff } }, 4341 }, 4342 /* BPF_ALU | BPF_AND | BPF_K */ 4343 { 4344 "ALU_AND_K: 3 & 2 = 2", 4345 .u.insns_int = { 4346 BPF_LD_IMM64(R0, 3), 4347 BPF_ALU32_IMM(BPF_AND, R0, 2), 4348 BPF_EXIT_INSN(), 4349 }, 4350 INTERNAL, 4351 { }, 4352 { { 0, 2 } }, 4353 }, 4354 { 4355 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 4356 .u.insns_int = { 4357 BPF_LD_IMM64(R0, 0xffffffff), 4358 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff), 4359 BPF_EXIT_INSN(), 4360 }, 4361 INTERNAL, 4362 { }, 4363 { { 0, 0xffffffff } }, 4364 }, 4365 { 4366 "ALU_AND_K: Small immediate", 4367 .u.insns_int = { 4368 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 4369 BPF_ALU32_IMM(BPF_AND, R0, 15), 4370 BPF_EXIT_INSN(), 4371 }, 4372 INTERNAL, 4373 { }, 4374 { { 0, 4 } } 4375 }, 4376 { 4377 "ALU_AND_K: Large immediate", 4378 .u.insns_int = { 4379 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 4380 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf), 4381 BPF_EXIT_INSN(), 4382 }, 4383 INTERNAL, 4384 { }, 4385 { { 0, 0xa1b2c3d4 } } 4386 }, 4387 { 4388 "ALU_AND_K: Zero extension", 4389 .u.insns_int = { 4390 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4391 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL), 4392 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0), 4393 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4394 BPF_MOV32_IMM(R0, 2), 4395 BPF_EXIT_INSN(), 4396 BPF_MOV32_IMM(R0, 1), 4397 BPF_EXIT_INSN(), 4398 }, 4399 INTERNAL, 4400 { }, 4401 { { 0, 1 } } 4402 }, 4403 { 4404 "ALU64_AND_K: 3 & 2 = 2", 4405 .u.insns_int = { 4406 BPF_LD_IMM64(R0, 3), 4407 BPF_ALU64_IMM(BPF_AND, R0, 2), 4408 BPF_EXIT_INSN(), 4409 }, 4410 INTERNAL, 4411 { }, 4412 { { 0, 2 } }, 4413 }, 4414 { 4415 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 4416 .u.insns_int = { 4417 BPF_LD_IMM64(R0, 0xffffffff), 4418 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff), 4419 BPF_EXIT_INSN(), 4420 }, 4421 INTERNAL, 4422 { }, 4423 { { 0, 0xffffffff } }, 4424 }, 4425 { 4426 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000", 4427 .u.insns_int = { 4428 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4429 BPF_LD_IMM64(R3, 0x0000000000000000LL), 4430 BPF_ALU64_IMM(BPF_AND, R2, 0x0), 4431 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4432 BPF_MOV32_IMM(R0, 2), 4433 BPF_EXIT_INSN(), 4434 BPF_MOV32_IMM(R0, 1), 4435 BPF_EXIT_INSN(), 4436 }, 4437 INTERNAL, 4438 { }, 4439 { { 0, 0x1 } }, 4440 }, 4441 { 4442 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000", 4443 .u.insns_int = { 4444 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4445 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 4446 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 4447 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4448 BPF_MOV32_IMM(R0, 2), 4449 BPF_EXIT_INSN(), 4450 BPF_MOV32_IMM(R0, 1), 4451 BPF_EXIT_INSN(), 4452 }, 4453 INTERNAL, 4454 { }, 4455 { { 0, 0x1 } }, 4456 }, 4457 { 4458 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff", 4459 .u.insns_int = { 4460 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 4461 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4462 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 4463 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4464 BPF_MOV32_IMM(R0, 2), 4465 BPF_EXIT_INSN(), 4466 BPF_MOV32_IMM(R0, 1), 4467 BPF_EXIT_INSN(), 4468 }, 4469 INTERNAL, 4470 { }, 4471 { { 0, 0x1 } }, 4472 }, 4473 { 4474 "ALU64_AND_K: Sign extension 1", 4475 .u.insns_int = { 4476 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4477 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL), 4478 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f), 4479 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4480 BPF_MOV32_IMM(R0, 2), 4481 BPF_EXIT_INSN(), 4482 BPF_MOV32_IMM(R0, 1), 4483 BPF_EXIT_INSN(), 4484 }, 4485 INTERNAL, 4486 { }, 4487 { { 0, 1 } } 4488 }, 4489 { 4490 "ALU64_AND_K: Sign extension 2", 4491 .u.insns_int = { 4492 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4493 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL), 4494 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0), 4495 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4496 BPF_MOV32_IMM(R0, 2), 4497 BPF_EXIT_INSN(), 4498 BPF_MOV32_IMM(R0, 1), 4499 BPF_EXIT_INSN(), 4500 }, 4501 INTERNAL, 4502 { }, 4503 { { 0, 1 } } 4504 }, 4505 /* BPF_ALU | BPF_OR | BPF_X */ 4506 { 4507 "ALU_OR_X: 1 | 2 = 3", 4508 .u.insns_int = { 4509 BPF_LD_IMM64(R0, 1), 4510 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4511 BPF_ALU32_REG(BPF_OR, R0, R1), 4512 BPF_EXIT_INSN(), 4513 }, 4514 INTERNAL, 4515 { }, 4516 { { 0, 3 } }, 4517 }, 4518 { 4519 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff", 4520 .u.insns_int = { 4521 BPF_LD_IMM64(R0, 0), 4522 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4523 BPF_ALU32_REG(BPF_OR, R0, R1), 4524 BPF_EXIT_INSN(), 4525 }, 4526 INTERNAL, 4527 { }, 4528 { { 0, 0xffffffff } }, 4529 }, 4530 { 4531 "ALU64_OR_X: 1 | 2 = 3", 4532 .u.insns_int = { 4533 BPF_LD_IMM64(R0, 1), 4534 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4535 BPF_ALU64_REG(BPF_OR, R0, R1), 4536 BPF_EXIT_INSN(), 4537 }, 4538 INTERNAL, 4539 { }, 4540 { { 0, 3 } }, 4541 }, 4542 { 4543 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff", 4544 .u.insns_int = { 4545 BPF_LD_IMM64(R0, 0), 4546 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4547 BPF_ALU64_REG(BPF_OR, R0, R1), 4548 BPF_EXIT_INSN(), 4549 }, 4550 INTERNAL, 4551 { }, 4552 { { 0, 0xffffffff } }, 4553 }, 4554 /* BPF_ALU | BPF_OR | BPF_K */ 4555 { 4556 "ALU_OR_K: 1 | 2 = 3", 4557 .u.insns_int = { 4558 BPF_LD_IMM64(R0, 1), 4559 BPF_ALU32_IMM(BPF_OR, R0, 2), 4560 BPF_EXIT_INSN(), 4561 }, 4562 INTERNAL, 4563 { }, 4564 { { 0, 3 } }, 4565 }, 4566 { 4567 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff", 4568 .u.insns_int = { 4569 BPF_LD_IMM64(R0, 0), 4570 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff), 4571 BPF_EXIT_INSN(), 4572 }, 4573 INTERNAL, 4574 { }, 4575 { { 0, 0xffffffff } }, 4576 }, 4577 { 4578 "ALU_OR_K: Small immediate", 4579 .u.insns_int = { 4580 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 4581 BPF_ALU32_IMM(BPF_OR, R0, 1), 4582 BPF_EXIT_INSN(), 4583 }, 4584 INTERNAL, 4585 { }, 4586 { { 0, 0x01020305 } } 4587 }, 4588 { 4589 "ALU_OR_K: Large immediate", 4590 .u.insns_int = { 4591 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 4592 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0), 4593 BPF_EXIT_INSN(), 4594 }, 4595 INTERNAL, 4596 { }, 4597 { { 0, 0xa1b2c3d4 } } 4598 }, 4599 { 4600 "ALU_OR_K: Zero extension", 4601 .u.insns_int = { 4602 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4603 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL), 4604 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0), 4605 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4606 BPF_MOV32_IMM(R0, 2), 4607 BPF_EXIT_INSN(), 4608 BPF_MOV32_IMM(R0, 1), 4609 BPF_EXIT_INSN(), 4610 }, 4611 INTERNAL, 4612 { }, 4613 { { 0, 1 } } 4614 }, 4615 { 4616 "ALU64_OR_K: 1 | 2 = 3", 4617 .u.insns_int = { 4618 BPF_LD_IMM64(R0, 1), 4619 BPF_ALU64_IMM(BPF_OR, R0, 2), 4620 BPF_EXIT_INSN(), 4621 }, 4622 INTERNAL, 4623 { }, 4624 { { 0, 3 } }, 4625 }, 4626 { 4627 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff", 4628 .u.insns_int = { 4629 BPF_LD_IMM64(R0, 0), 4630 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff), 4631 BPF_EXIT_INSN(), 4632 }, 4633 INTERNAL, 4634 { }, 4635 { { 0, 0xffffffff } }, 4636 }, 4637 { 4638 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000", 4639 .u.insns_int = { 4640 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4641 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 4642 BPF_ALU64_IMM(BPF_OR, R2, 0x0), 4643 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4644 BPF_MOV32_IMM(R0, 2), 4645 BPF_EXIT_INSN(), 4646 BPF_MOV32_IMM(R0, 1), 4647 BPF_EXIT_INSN(), 4648 }, 4649 INTERNAL, 4650 { }, 4651 { { 0, 0x1 } }, 4652 }, 4653 { 4654 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff", 4655 .u.insns_int = { 4656 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4657 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4658 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 4659 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4660 BPF_MOV32_IMM(R0, 2), 4661 BPF_EXIT_INSN(), 4662 BPF_MOV32_IMM(R0, 1), 4663 BPF_EXIT_INSN(), 4664 }, 4665 INTERNAL, 4666 { }, 4667 { { 0, 0x1 } }, 4668 }, 4669 { 4670 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff", 4671 .u.insns_int = { 4672 BPF_LD_IMM64(R2, 0x0000000000000000LL), 4673 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4674 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 4675 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4676 BPF_MOV32_IMM(R0, 2), 4677 BPF_EXIT_INSN(), 4678 BPF_MOV32_IMM(R0, 1), 4679 BPF_EXIT_INSN(), 4680 }, 4681 INTERNAL, 4682 { }, 4683 { { 0, 0x1 } }, 4684 }, 4685 { 4686 "ALU64_OR_K: Sign extension 1", 4687 .u.insns_int = { 4688 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4689 BPF_LD_IMM64(R1, 0x012345678fafcfefLL), 4690 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f), 4691 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4692 BPF_MOV32_IMM(R0, 2), 4693 BPF_EXIT_INSN(), 4694 BPF_MOV32_IMM(R0, 1), 4695 BPF_EXIT_INSN(), 4696 }, 4697 INTERNAL, 4698 { }, 4699 { { 0, 1 } } 4700 }, 4701 { 4702 "ALU64_OR_K: Sign extension 2", 4703 .u.insns_int = { 4704 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4705 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL), 4706 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0), 4707 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4708 BPF_MOV32_IMM(R0, 2), 4709 BPF_EXIT_INSN(), 4710 BPF_MOV32_IMM(R0, 1), 4711 BPF_EXIT_INSN(), 4712 }, 4713 INTERNAL, 4714 { }, 4715 { { 0, 1 } } 4716 }, 4717 /* BPF_ALU | BPF_XOR | BPF_X */ 4718 { 4719 "ALU_XOR_X: 5 ^ 6 = 3", 4720 .u.insns_int = { 4721 BPF_LD_IMM64(R0, 5), 4722 BPF_ALU32_IMM(BPF_MOV, R1, 6), 4723 BPF_ALU32_REG(BPF_XOR, R0, R1), 4724 BPF_EXIT_INSN(), 4725 }, 4726 INTERNAL, 4727 { }, 4728 { { 0, 3 } }, 4729 }, 4730 { 4731 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe", 4732 .u.insns_int = { 4733 BPF_LD_IMM64(R0, 1), 4734 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4735 BPF_ALU32_REG(BPF_XOR, R0, R1), 4736 BPF_EXIT_INSN(), 4737 }, 4738 INTERNAL, 4739 { }, 4740 { { 0, 0xfffffffe } }, 4741 }, 4742 { 4743 "ALU64_XOR_X: 5 ^ 6 = 3", 4744 .u.insns_int = { 4745 BPF_LD_IMM64(R0, 5), 4746 BPF_ALU32_IMM(BPF_MOV, R1, 6), 4747 BPF_ALU64_REG(BPF_XOR, R0, R1), 4748 BPF_EXIT_INSN(), 4749 }, 4750 INTERNAL, 4751 { }, 4752 { { 0, 3 } }, 4753 }, 4754 { 4755 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe", 4756 .u.insns_int = { 4757 BPF_LD_IMM64(R0, 1), 4758 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 4759 BPF_ALU64_REG(BPF_XOR, R0, R1), 4760 BPF_EXIT_INSN(), 4761 }, 4762 INTERNAL, 4763 { }, 4764 { { 0, 0xfffffffe } }, 4765 }, 4766 /* BPF_ALU | BPF_XOR | BPF_K */ 4767 { 4768 "ALU_XOR_K: 5 ^ 6 = 3", 4769 .u.insns_int = { 4770 BPF_LD_IMM64(R0, 5), 4771 BPF_ALU32_IMM(BPF_XOR, R0, 6), 4772 BPF_EXIT_INSN(), 4773 }, 4774 INTERNAL, 4775 { }, 4776 { { 0, 3 } }, 4777 }, 4778 { 4779 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 4780 .u.insns_int = { 4781 BPF_LD_IMM64(R0, 1), 4782 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff), 4783 BPF_EXIT_INSN(), 4784 }, 4785 INTERNAL, 4786 { }, 4787 { { 0, 0xfffffffe } }, 4788 }, 4789 { 4790 "ALU_XOR_K: Small immediate", 4791 .u.insns_int = { 4792 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 4793 BPF_ALU32_IMM(BPF_XOR, R0, 15), 4794 BPF_EXIT_INSN(), 4795 }, 4796 INTERNAL, 4797 { }, 4798 { { 0, 0x0102030b } } 4799 }, 4800 { 4801 "ALU_XOR_K: Large immediate", 4802 .u.insns_int = { 4803 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 4804 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf), 4805 BPF_EXIT_INSN(), 4806 }, 4807 INTERNAL, 4808 { }, 4809 { { 0, 0x5e4d3c2b } } 4810 }, 4811 { 4812 "ALU_XOR_K: Zero extension", 4813 .u.insns_int = { 4814 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4815 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL), 4816 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0), 4817 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4818 BPF_MOV32_IMM(R0, 2), 4819 BPF_EXIT_INSN(), 4820 BPF_MOV32_IMM(R0, 1), 4821 BPF_EXIT_INSN(), 4822 }, 4823 INTERNAL, 4824 { }, 4825 { { 0, 1 } } 4826 }, 4827 { 4828 "ALU64_XOR_K: 5 ^ 6 = 3", 4829 .u.insns_int = { 4830 BPF_LD_IMM64(R0, 5), 4831 BPF_ALU64_IMM(BPF_XOR, R0, 6), 4832 BPF_EXIT_INSN(), 4833 }, 4834 INTERNAL, 4835 { }, 4836 { { 0, 3 } }, 4837 }, 4838 { 4839 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 4840 .u.insns_int = { 4841 BPF_LD_IMM64(R0, 1), 4842 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff), 4843 BPF_EXIT_INSN(), 4844 }, 4845 INTERNAL, 4846 { }, 4847 { { 0, 0xfffffffe } }, 4848 }, 4849 { 4850 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000", 4851 .u.insns_int = { 4852 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4853 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 4854 BPF_ALU64_IMM(BPF_XOR, R2, 0x0), 4855 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4856 BPF_MOV32_IMM(R0, 2), 4857 BPF_EXIT_INSN(), 4858 BPF_MOV32_IMM(R0, 1), 4859 BPF_EXIT_INSN(), 4860 }, 4861 INTERNAL, 4862 { }, 4863 { { 0, 0x1 } }, 4864 }, 4865 { 4866 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff", 4867 .u.insns_int = { 4868 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4869 BPF_LD_IMM64(R3, 0xffff00000000ffffLL), 4870 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 4871 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4872 BPF_MOV32_IMM(R0, 2), 4873 BPF_EXIT_INSN(), 4874 BPF_MOV32_IMM(R0, 1), 4875 BPF_EXIT_INSN(), 4876 }, 4877 INTERNAL, 4878 { }, 4879 { { 0, 0x1 } }, 4880 }, 4881 { 4882 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff", 4883 .u.insns_int = { 4884 BPF_LD_IMM64(R2, 0x0000000000000000LL), 4885 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4886 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 4887 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4888 BPF_MOV32_IMM(R0, 2), 4889 BPF_EXIT_INSN(), 4890 BPF_MOV32_IMM(R0, 1), 4891 BPF_EXIT_INSN(), 4892 }, 4893 INTERNAL, 4894 { }, 4895 { { 0, 0x1 } }, 4896 }, 4897 { 4898 "ALU64_XOR_K: Sign extension 1", 4899 .u.insns_int = { 4900 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4901 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL), 4902 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f), 4903 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4904 BPF_MOV32_IMM(R0, 2), 4905 BPF_EXIT_INSN(), 4906 BPF_MOV32_IMM(R0, 1), 4907 BPF_EXIT_INSN(), 4908 }, 4909 INTERNAL, 4910 { }, 4911 { { 0, 1 } } 4912 }, 4913 { 4914 "ALU64_XOR_K: Sign extension 2", 4915 .u.insns_int = { 4916 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4917 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL), 4918 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0), 4919 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4920 BPF_MOV32_IMM(R0, 2), 4921 BPF_EXIT_INSN(), 4922 BPF_MOV32_IMM(R0, 1), 4923 BPF_EXIT_INSN(), 4924 }, 4925 INTERNAL, 4926 { }, 4927 { { 0, 1 } } 4928 }, 4929 /* BPF_ALU | BPF_LSH | BPF_X */ 4930 { 4931 "ALU_LSH_X: 1 << 1 = 2", 4932 .u.insns_int = { 4933 BPF_LD_IMM64(R0, 1), 4934 BPF_ALU32_IMM(BPF_MOV, R1, 1), 4935 BPF_ALU32_REG(BPF_LSH, R0, R1), 4936 BPF_EXIT_INSN(), 4937 }, 4938 INTERNAL, 4939 { }, 4940 { { 0, 2 } }, 4941 }, 4942 { 4943 "ALU_LSH_X: 1 << 31 = 0x80000000", 4944 .u.insns_int = { 4945 BPF_LD_IMM64(R0, 1), 4946 BPF_ALU32_IMM(BPF_MOV, R1, 31), 4947 BPF_ALU32_REG(BPF_LSH, R0, R1), 4948 BPF_EXIT_INSN(), 4949 }, 4950 INTERNAL, 4951 { }, 4952 { { 0, 0x80000000 } }, 4953 }, 4954 { 4955 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000", 4956 .u.insns_int = { 4957 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 4958 BPF_ALU32_IMM(BPF_MOV, R1, 12), 4959 BPF_ALU32_REG(BPF_LSH, R0, R1), 4960 BPF_EXIT_INSN(), 4961 }, 4962 INTERNAL, 4963 { }, 4964 { { 0, 0x45678000 } } 4965 }, 4966 { 4967 "ALU64_LSH_X: 1 << 1 = 2", 4968 .u.insns_int = { 4969 BPF_LD_IMM64(R0, 1), 4970 BPF_ALU32_IMM(BPF_MOV, R1, 1), 4971 BPF_ALU64_REG(BPF_LSH, R0, R1), 4972 BPF_EXIT_INSN(), 4973 }, 4974 INTERNAL, 4975 { }, 4976 { { 0, 2 } }, 4977 }, 4978 { 4979 "ALU64_LSH_X: 1 << 31 = 0x80000000", 4980 .u.insns_int = { 4981 BPF_LD_IMM64(R0, 1), 4982 BPF_ALU32_IMM(BPF_MOV, R1, 31), 4983 BPF_ALU64_REG(BPF_LSH, R0, R1), 4984 BPF_EXIT_INSN(), 4985 }, 4986 INTERNAL, 4987 { }, 4988 { { 0, 0x80000000 } }, 4989 }, 4990 { 4991 "ALU64_LSH_X: Shift < 32, low word", 4992 .u.insns_int = { 4993 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 4994 BPF_ALU32_IMM(BPF_MOV, R1, 12), 4995 BPF_ALU64_REG(BPF_LSH, R0, R1), 4996 BPF_EXIT_INSN(), 4997 }, 4998 INTERNAL, 4999 { }, 5000 { { 0, 0xbcdef000 } } 5001 }, 5002 { 5003 "ALU64_LSH_X: Shift < 32, high word", 5004 .u.insns_int = { 5005 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5006 BPF_ALU32_IMM(BPF_MOV, R1, 12), 5007 BPF_ALU64_REG(BPF_LSH, R0, R1), 5008 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5009 BPF_EXIT_INSN(), 5010 }, 5011 INTERNAL, 5012 { }, 5013 { { 0, 0x3456789a } } 5014 }, 5015 { 5016 "ALU64_LSH_X: Shift > 32, low word", 5017 .u.insns_int = { 5018 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5019 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5020 BPF_ALU64_REG(BPF_LSH, R0, R1), 5021 BPF_EXIT_INSN(), 5022 }, 5023 INTERNAL, 5024 { }, 5025 { { 0, 0 } } 5026 }, 5027 { 5028 "ALU64_LSH_X: Shift > 32, high word", 5029 .u.insns_int = { 5030 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5031 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5032 BPF_ALU64_REG(BPF_LSH, R0, R1), 5033 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5034 BPF_EXIT_INSN(), 5035 }, 5036 INTERNAL, 5037 { }, 5038 { { 0, 0x9abcdef0 } } 5039 }, 5040 { 5041 "ALU64_LSH_X: Shift == 32, low word", 5042 .u.insns_int = { 5043 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5044 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5045 BPF_ALU64_REG(BPF_LSH, R0, R1), 5046 BPF_EXIT_INSN(), 5047 }, 5048 INTERNAL, 5049 { }, 5050 { { 0, 0 } } 5051 }, 5052 { 5053 "ALU64_LSH_X: Shift == 32, high word", 5054 .u.insns_int = { 5055 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5056 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5057 BPF_ALU64_REG(BPF_LSH, R0, R1), 5058 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5059 BPF_EXIT_INSN(), 5060 }, 5061 INTERNAL, 5062 { }, 5063 { { 0, 0x89abcdef } } 5064 }, 5065 { 5066 "ALU64_LSH_X: Zero shift, low word", 5067 .u.insns_int = { 5068 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5069 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5070 BPF_ALU64_REG(BPF_LSH, R0, R1), 5071 BPF_EXIT_INSN(), 5072 }, 5073 INTERNAL, 5074 { }, 5075 { { 0, 0x89abcdef } } 5076 }, 5077 { 5078 "ALU64_LSH_X: Zero shift, high word", 5079 .u.insns_int = { 5080 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5081 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5082 BPF_ALU64_REG(BPF_LSH, R0, R1), 5083 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5084 BPF_EXIT_INSN(), 5085 }, 5086 INTERNAL, 5087 { }, 5088 { { 0, 0x01234567 } } 5089 }, 5090 /* BPF_ALU | BPF_LSH | BPF_K */ 5091 { 5092 "ALU_LSH_K: 1 << 1 = 2", 5093 .u.insns_int = { 5094 BPF_LD_IMM64(R0, 1), 5095 BPF_ALU32_IMM(BPF_LSH, R0, 1), 5096 BPF_EXIT_INSN(), 5097 }, 5098 INTERNAL, 5099 { }, 5100 { { 0, 2 } }, 5101 }, 5102 { 5103 "ALU_LSH_K: 1 << 31 = 0x80000000", 5104 .u.insns_int = { 5105 BPF_LD_IMM64(R0, 1), 5106 BPF_ALU32_IMM(BPF_LSH, R0, 31), 5107 BPF_EXIT_INSN(), 5108 }, 5109 INTERNAL, 5110 { }, 5111 { { 0, 0x80000000 } }, 5112 }, 5113 { 5114 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000", 5115 .u.insns_int = { 5116 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 5117 BPF_ALU32_IMM(BPF_LSH, R0, 12), 5118 BPF_EXIT_INSN(), 5119 }, 5120 INTERNAL, 5121 { }, 5122 { { 0, 0x45678000 } } 5123 }, 5124 { 5125 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678", 5126 .u.insns_int = { 5127 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 5128 BPF_ALU32_IMM(BPF_LSH, R0, 0), 5129 BPF_EXIT_INSN(), 5130 }, 5131 INTERNAL, 5132 { }, 5133 { { 0, 0x12345678 } } 5134 }, 5135 { 5136 "ALU64_LSH_K: 1 << 1 = 2", 5137 .u.insns_int = { 5138 BPF_LD_IMM64(R0, 1), 5139 BPF_ALU64_IMM(BPF_LSH, R0, 1), 5140 BPF_EXIT_INSN(), 5141 }, 5142 INTERNAL, 5143 { }, 5144 { { 0, 2 } }, 5145 }, 5146 { 5147 "ALU64_LSH_K: 1 << 31 = 0x80000000", 5148 .u.insns_int = { 5149 BPF_LD_IMM64(R0, 1), 5150 BPF_ALU64_IMM(BPF_LSH, R0, 31), 5151 BPF_EXIT_INSN(), 5152 }, 5153 INTERNAL, 5154 { }, 5155 { { 0, 0x80000000 } }, 5156 }, 5157 { 5158 "ALU64_LSH_K: Shift < 32, low word", 5159 .u.insns_int = { 5160 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5161 BPF_ALU64_IMM(BPF_LSH, R0, 12), 5162 BPF_EXIT_INSN(), 5163 }, 5164 INTERNAL, 5165 { }, 5166 { { 0, 0xbcdef000 } } 5167 }, 5168 { 5169 "ALU64_LSH_K: Shift < 32, high word", 5170 .u.insns_int = { 5171 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5172 BPF_ALU64_IMM(BPF_LSH, R0, 12), 5173 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5174 BPF_EXIT_INSN(), 5175 }, 5176 INTERNAL, 5177 { }, 5178 { { 0, 0x3456789a } } 5179 }, 5180 { 5181 "ALU64_LSH_K: Shift > 32, low word", 5182 .u.insns_int = { 5183 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5184 BPF_ALU64_IMM(BPF_LSH, R0, 36), 5185 BPF_EXIT_INSN(), 5186 }, 5187 INTERNAL, 5188 { }, 5189 { { 0, 0 } } 5190 }, 5191 { 5192 "ALU64_LSH_K: Shift > 32, high word", 5193 .u.insns_int = { 5194 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5195 BPF_ALU64_IMM(BPF_LSH, R0, 36), 5196 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5197 BPF_EXIT_INSN(), 5198 }, 5199 INTERNAL, 5200 { }, 5201 { { 0, 0x9abcdef0 } } 5202 }, 5203 { 5204 "ALU64_LSH_K: Shift == 32, low word", 5205 .u.insns_int = { 5206 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5207 BPF_ALU64_IMM(BPF_LSH, R0, 32), 5208 BPF_EXIT_INSN(), 5209 }, 5210 INTERNAL, 5211 { }, 5212 { { 0, 0 } } 5213 }, 5214 { 5215 "ALU64_LSH_K: Shift == 32, high word", 5216 .u.insns_int = { 5217 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5218 BPF_ALU64_IMM(BPF_LSH, R0, 32), 5219 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5220 BPF_EXIT_INSN(), 5221 }, 5222 INTERNAL, 5223 { }, 5224 { { 0, 0x89abcdef } } 5225 }, 5226 { 5227 "ALU64_LSH_K: Zero shift", 5228 .u.insns_int = { 5229 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5230 BPF_ALU64_IMM(BPF_LSH, R0, 0), 5231 BPF_EXIT_INSN(), 5232 }, 5233 INTERNAL, 5234 { }, 5235 { { 0, 0x89abcdef } } 5236 }, 5237 /* BPF_ALU | BPF_RSH | BPF_X */ 5238 { 5239 "ALU_RSH_X: 2 >> 1 = 1", 5240 .u.insns_int = { 5241 BPF_LD_IMM64(R0, 2), 5242 BPF_ALU32_IMM(BPF_MOV, R1, 1), 5243 BPF_ALU32_REG(BPF_RSH, R0, R1), 5244 BPF_EXIT_INSN(), 5245 }, 5246 INTERNAL, 5247 { }, 5248 { { 0, 1 } }, 5249 }, 5250 { 5251 "ALU_RSH_X: 0x80000000 >> 31 = 1", 5252 .u.insns_int = { 5253 BPF_LD_IMM64(R0, 0x80000000), 5254 BPF_ALU32_IMM(BPF_MOV, R1, 31), 5255 BPF_ALU32_REG(BPF_RSH, R0, R1), 5256 BPF_EXIT_INSN(), 5257 }, 5258 INTERNAL, 5259 { }, 5260 { { 0, 1 } }, 5261 }, 5262 { 5263 "ALU_RSH_X: 0x12345678 >> 20 = 0x123", 5264 .u.insns_int = { 5265 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 5266 BPF_ALU32_IMM(BPF_MOV, R1, 20), 5267 BPF_ALU32_REG(BPF_RSH, R0, R1), 5268 BPF_EXIT_INSN(), 5269 }, 5270 INTERNAL, 5271 { }, 5272 { { 0, 0x123 } } 5273 }, 5274 { 5275 "ALU64_RSH_X: 2 >> 1 = 1", 5276 .u.insns_int = { 5277 BPF_LD_IMM64(R0, 2), 5278 BPF_ALU32_IMM(BPF_MOV, R1, 1), 5279 BPF_ALU64_REG(BPF_RSH, R0, R1), 5280 BPF_EXIT_INSN(), 5281 }, 5282 INTERNAL, 5283 { }, 5284 { { 0, 1 } }, 5285 }, 5286 { 5287 "ALU64_RSH_X: 0x80000000 >> 31 = 1", 5288 .u.insns_int = { 5289 BPF_LD_IMM64(R0, 0x80000000), 5290 BPF_ALU32_IMM(BPF_MOV, R1, 31), 5291 BPF_ALU64_REG(BPF_RSH, R0, R1), 5292 BPF_EXIT_INSN(), 5293 }, 5294 INTERNAL, 5295 { }, 5296 { { 0, 1 } }, 5297 }, 5298 { 5299 "ALU64_RSH_X: Shift < 32, low word", 5300 .u.insns_int = { 5301 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5302 BPF_ALU32_IMM(BPF_MOV, R1, 12), 5303 BPF_ALU64_REG(BPF_RSH, R0, R1), 5304 BPF_EXIT_INSN(), 5305 }, 5306 INTERNAL, 5307 { }, 5308 { { 0, 0x56789abc } } 5309 }, 5310 { 5311 "ALU64_RSH_X: Shift < 32, high word", 5312 .u.insns_int = { 5313 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5314 BPF_ALU32_IMM(BPF_MOV, R1, 12), 5315 BPF_ALU64_REG(BPF_RSH, R0, R1), 5316 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5317 BPF_EXIT_INSN(), 5318 }, 5319 INTERNAL, 5320 { }, 5321 { { 0, 0x00081234 } } 5322 }, 5323 { 5324 "ALU64_RSH_X: Shift > 32, low word", 5325 .u.insns_int = { 5326 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5327 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5328 BPF_ALU64_REG(BPF_RSH, R0, R1), 5329 BPF_EXIT_INSN(), 5330 }, 5331 INTERNAL, 5332 { }, 5333 { { 0, 0x08123456 } } 5334 }, 5335 { 5336 "ALU64_RSH_X: Shift > 32, high word", 5337 .u.insns_int = { 5338 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5339 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5340 BPF_ALU64_REG(BPF_RSH, R0, R1), 5341 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5342 BPF_EXIT_INSN(), 5343 }, 5344 INTERNAL, 5345 { }, 5346 { { 0, 0 } } 5347 }, 5348 { 5349 "ALU64_RSH_X: Shift == 32, low word", 5350 .u.insns_int = { 5351 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5352 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5353 BPF_ALU64_REG(BPF_RSH, R0, R1), 5354 BPF_EXIT_INSN(), 5355 }, 5356 INTERNAL, 5357 { }, 5358 { { 0, 0x81234567 } } 5359 }, 5360 { 5361 "ALU64_RSH_X: Shift == 32, high word", 5362 .u.insns_int = { 5363 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5364 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5365 BPF_ALU64_REG(BPF_RSH, R0, R1), 5366 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5367 BPF_EXIT_INSN(), 5368 }, 5369 INTERNAL, 5370 { }, 5371 { { 0, 0 } } 5372 }, 5373 { 5374 "ALU64_RSH_X: Zero shift, low word", 5375 .u.insns_int = { 5376 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5377 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5378 BPF_ALU64_REG(BPF_RSH, R0, R1), 5379 BPF_EXIT_INSN(), 5380 }, 5381 INTERNAL, 5382 { }, 5383 { { 0, 0x89abcdef } } 5384 }, 5385 { 5386 "ALU64_RSH_X: Zero shift, high word", 5387 .u.insns_int = { 5388 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5389 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5390 BPF_ALU64_REG(BPF_RSH, R0, R1), 5391 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5392 BPF_EXIT_INSN(), 5393 }, 5394 INTERNAL, 5395 { }, 5396 { { 0, 0x81234567 } } 5397 }, 5398 /* BPF_ALU | BPF_RSH | BPF_K */ 5399 { 5400 "ALU_RSH_K: 2 >> 1 = 1", 5401 .u.insns_int = { 5402 BPF_LD_IMM64(R0, 2), 5403 BPF_ALU32_IMM(BPF_RSH, R0, 1), 5404 BPF_EXIT_INSN(), 5405 }, 5406 INTERNAL, 5407 { }, 5408 { { 0, 1 } }, 5409 }, 5410 { 5411 "ALU_RSH_K: 0x80000000 >> 31 = 1", 5412 .u.insns_int = { 5413 BPF_LD_IMM64(R0, 0x80000000), 5414 BPF_ALU32_IMM(BPF_RSH, R0, 31), 5415 BPF_EXIT_INSN(), 5416 }, 5417 INTERNAL, 5418 { }, 5419 { { 0, 1 } }, 5420 }, 5421 { 5422 "ALU_RSH_K: 0x12345678 >> 20 = 0x123", 5423 .u.insns_int = { 5424 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 5425 BPF_ALU32_IMM(BPF_RSH, R0, 20), 5426 BPF_EXIT_INSN(), 5427 }, 5428 INTERNAL, 5429 { }, 5430 { { 0, 0x123 } } 5431 }, 5432 { 5433 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678", 5434 .u.insns_int = { 5435 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 5436 BPF_ALU32_IMM(BPF_RSH, R0, 0), 5437 BPF_EXIT_INSN(), 5438 }, 5439 INTERNAL, 5440 { }, 5441 { { 0, 0x12345678 } } 5442 }, 5443 { 5444 "ALU64_RSH_K: 2 >> 1 = 1", 5445 .u.insns_int = { 5446 BPF_LD_IMM64(R0, 2), 5447 BPF_ALU64_IMM(BPF_RSH, R0, 1), 5448 BPF_EXIT_INSN(), 5449 }, 5450 INTERNAL, 5451 { }, 5452 { { 0, 1 } }, 5453 }, 5454 { 5455 "ALU64_RSH_K: 0x80000000 >> 31 = 1", 5456 .u.insns_int = { 5457 BPF_LD_IMM64(R0, 0x80000000), 5458 BPF_ALU64_IMM(BPF_RSH, R0, 31), 5459 BPF_EXIT_INSN(), 5460 }, 5461 INTERNAL, 5462 { }, 5463 { { 0, 1 } }, 5464 }, 5465 { 5466 "ALU64_RSH_K: Shift < 32, low word", 5467 .u.insns_int = { 5468 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5469 BPF_ALU64_IMM(BPF_RSH, R0, 12), 5470 BPF_EXIT_INSN(), 5471 }, 5472 INTERNAL, 5473 { }, 5474 { { 0, 0x56789abc } } 5475 }, 5476 { 5477 "ALU64_RSH_K: Shift < 32, high word", 5478 .u.insns_int = { 5479 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5480 BPF_ALU64_IMM(BPF_RSH, R0, 12), 5481 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5482 BPF_EXIT_INSN(), 5483 }, 5484 INTERNAL, 5485 { }, 5486 { { 0, 0x00081234 } } 5487 }, 5488 { 5489 "ALU64_RSH_K: Shift > 32, low word", 5490 .u.insns_int = { 5491 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5492 BPF_ALU64_IMM(BPF_RSH, R0, 36), 5493 BPF_EXIT_INSN(), 5494 }, 5495 INTERNAL, 5496 { }, 5497 { { 0, 0x08123456 } } 5498 }, 5499 { 5500 "ALU64_RSH_K: Shift > 32, high word", 5501 .u.insns_int = { 5502 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5503 BPF_ALU64_IMM(BPF_RSH, R0, 36), 5504 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5505 BPF_EXIT_INSN(), 5506 }, 5507 INTERNAL, 5508 { }, 5509 { { 0, 0 } } 5510 }, 5511 { 5512 "ALU64_RSH_K: Shift == 32, low word", 5513 .u.insns_int = { 5514 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5515 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5516 BPF_EXIT_INSN(), 5517 }, 5518 INTERNAL, 5519 { }, 5520 { { 0, 0x81234567 } } 5521 }, 5522 { 5523 "ALU64_RSH_K: Shift == 32, high word", 5524 .u.insns_int = { 5525 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5526 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5527 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5528 BPF_EXIT_INSN(), 5529 }, 5530 INTERNAL, 5531 { }, 5532 { { 0, 0 } } 5533 }, 5534 { 5535 "ALU64_RSH_K: Zero shift", 5536 .u.insns_int = { 5537 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5538 BPF_ALU64_IMM(BPF_RSH, R0, 0), 5539 BPF_EXIT_INSN(), 5540 }, 5541 INTERNAL, 5542 { }, 5543 { { 0, 0x89abcdef } } 5544 }, 5545 /* BPF_ALU | BPF_ARSH | BPF_X */ 5546 { 5547 "ALU32_ARSH_X: -1234 >> 7 = -10", 5548 .u.insns_int = { 5549 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 5550 BPF_ALU32_IMM(BPF_MOV, R1, 7), 5551 BPF_ALU32_REG(BPF_ARSH, R0, R1), 5552 BPF_EXIT_INSN(), 5553 }, 5554 INTERNAL, 5555 { }, 5556 { { 0, -10 } } 5557 }, 5558 { 5559 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 5560 .u.insns_int = { 5561 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 5562 BPF_ALU32_IMM(BPF_MOV, R1, 40), 5563 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5564 BPF_EXIT_INSN(), 5565 }, 5566 INTERNAL, 5567 { }, 5568 { { 0, 0xffff00ff } }, 5569 }, 5570 { 5571 "ALU64_ARSH_X: Shift < 32, low word", 5572 .u.insns_int = { 5573 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5574 BPF_ALU32_IMM(BPF_MOV, R1, 12), 5575 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5576 BPF_EXIT_INSN(), 5577 }, 5578 INTERNAL, 5579 { }, 5580 { { 0, 0x56789abc } } 5581 }, 5582 { 5583 "ALU64_ARSH_X: Shift < 32, high word", 5584 .u.insns_int = { 5585 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5586 BPF_ALU32_IMM(BPF_MOV, R1, 12), 5587 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5588 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5589 BPF_EXIT_INSN(), 5590 }, 5591 INTERNAL, 5592 { }, 5593 { { 0, 0xfff81234 } } 5594 }, 5595 { 5596 "ALU64_ARSH_X: Shift > 32, low word", 5597 .u.insns_int = { 5598 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5599 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5600 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5601 BPF_EXIT_INSN(), 5602 }, 5603 INTERNAL, 5604 { }, 5605 { { 0, 0xf8123456 } } 5606 }, 5607 { 5608 "ALU64_ARSH_X: Shift > 32, high word", 5609 .u.insns_int = { 5610 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5611 BPF_ALU32_IMM(BPF_MOV, R1, 36), 5612 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5613 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5614 BPF_EXIT_INSN(), 5615 }, 5616 INTERNAL, 5617 { }, 5618 { { 0, -1 } } 5619 }, 5620 { 5621 "ALU64_ARSH_X: Shift == 32, low word", 5622 .u.insns_int = { 5623 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5624 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5625 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5626 BPF_EXIT_INSN(), 5627 }, 5628 INTERNAL, 5629 { }, 5630 { { 0, 0x81234567 } } 5631 }, 5632 { 5633 "ALU64_ARSH_X: Shift == 32, high word", 5634 .u.insns_int = { 5635 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5636 BPF_ALU32_IMM(BPF_MOV, R1, 32), 5637 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5638 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5639 BPF_EXIT_INSN(), 5640 }, 5641 INTERNAL, 5642 { }, 5643 { { 0, -1 } } 5644 }, 5645 { 5646 "ALU64_ARSH_X: Zero shift, low word", 5647 .u.insns_int = { 5648 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5649 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5650 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5651 BPF_EXIT_INSN(), 5652 }, 5653 INTERNAL, 5654 { }, 5655 { { 0, 0x89abcdef } } 5656 }, 5657 { 5658 "ALU64_ARSH_X: Zero shift, high word", 5659 .u.insns_int = { 5660 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5661 BPF_ALU32_IMM(BPF_MOV, R1, 0), 5662 BPF_ALU64_REG(BPF_ARSH, R0, R1), 5663 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5664 BPF_EXIT_INSN(), 5665 }, 5666 INTERNAL, 5667 { }, 5668 { { 0, 0x81234567 } } 5669 }, 5670 /* BPF_ALU | BPF_ARSH | BPF_K */ 5671 { 5672 "ALU32_ARSH_K: -1234 >> 7 = -10", 5673 .u.insns_int = { 5674 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 5675 BPF_ALU32_IMM(BPF_ARSH, R0, 7), 5676 BPF_EXIT_INSN(), 5677 }, 5678 INTERNAL, 5679 { }, 5680 { { 0, -10 } } 5681 }, 5682 { 5683 "ALU32_ARSH_K: -1234 >> 0 = -1234", 5684 .u.insns_int = { 5685 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 5686 BPF_ALU32_IMM(BPF_ARSH, R0, 0), 5687 BPF_EXIT_INSN(), 5688 }, 5689 INTERNAL, 5690 { }, 5691 { { 0, -1234 } } 5692 }, 5693 { 5694 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 5695 .u.insns_int = { 5696 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 5697 BPF_ALU64_IMM(BPF_ARSH, R0, 40), 5698 BPF_EXIT_INSN(), 5699 }, 5700 INTERNAL, 5701 { }, 5702 { { 0, 0xffff00ff } }, 5703 }, 5704 { 5705 "ALU64_ARSH_K: Shift < 32, low word", 5706 .u.insns_int = { 5707 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5708 BPF_ALU64_IMM(BPF_RSH, R0, 12), 5709 BPF_EXIT_INSN(), 5710 }, 5711 INTERNAL, 5712 { }, 5713 { { 0, 0x56789abc } } 5714 }, 5715 { 5716 "ALU64_ARSH_K: Shift < 32, high word", 5717 .u.insns_int = { 5718 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5719 BPF_ALU64_IMM(BPF_ARSH, R0, 12), 5720 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5721 BPF_EXIT_INSN(), 5722 }, 5723 INTERNAL, 5724 { }, 5725 { { 0, 0xfff81234 } } 5726 }, 5727 { 5728 "ALU64_ARSH_K: Shift > 32, low word", 5729 .u.insns_int = { 5730 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5731 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 5732 BPF_EXIT_INSN(), 5733 }, 5734 INTERNAL, 5735 { }, 5736 { { 0, 0xf8123456 } } 5737 }, 5738 { 5739 "ALU64_ARSH_K: Shift > 32, high word", 5740 .u.insns_int = { 5741 BPF_LD_IMM64(R0, 0xf123456789abcdefLL), 5742 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 5743 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5744 BPF_EXIT_INSN(), 5745 }, 5746 INTERNAL, 5747 { }, 5748 { { 0, -1 } } 5749 }, 5750 { 5751 "ALU64_ARSH_K: Shift == 32, low word", 5752 .u.insns_int = { 5753 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5754 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 5755 BPF_EXIT_INSN(), 5756 }, 5757 INTERNAL, 5758 { }, 5759 { { 0, 0x81234567 } } 5760 }, 5761 { 5762 "ALU64_ARSH_K: Shift == 32, high word", 5763 .u.insns_int = { 5764 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5765 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 5766 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5767 BPF_EXIT_INSN(), 5768 }, 5769 INTERNAL, 5770 { }, 5771 { { 0, -1 } } 5772 }, 5773 { 5774 "ALU64_ARSH_K: Zero shift", 5775 .u.insns_int = { 5776 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 5777 BPF_ALU64_IMM(BPF_ARSH, R0, 0), 5778 BPF_EXIT_INSN(), 5779 }, 5780 INTERNAL, 5781 { }, 5782 { { 0, 0x89abcdef } } 5783 }, 5784 /* BPF_ALU | BPF_NEG */ 5785 { 5786 "ALU_NEG: -(3) = -3", 5787 .u.insns_int = { 5788 BPF_ALU32_IMM(BPF_MOV, R0, 3), 5789 BPF_ALU32_IMM(BPF_NEG, R0, 0), 5790 BPF_EXIT_INSN(), 5791 }, 5792 INTERNAL, 5793 { }, 5794 { { 0, -3 } }, 5795 }, 5796 { 5797 "ALU_NEG: -(-3) = 3", 5798 .u.insns_int = { 5799 BPF_ALU32_IMM(BPF_MOV, R0, -3), 5800 BPF_ALU32_IMM(BPF_NEG, R0, 0), 5801 BPF_EXIT_INSN(), 5802 }, 5803 INTERNAL, 5804 { }, 5805 { { 0, 3 } }, 5806 }, 5807 { 5808 "ALU64_NEG: -(3) = -3", 5809 .u.insns_int = { 5810 BPF_LD_IMM64(R0, 3), 5811 BPF_ALU64_IMM(BPF_NEG, R0, 0), 5812 BPF_EXIT_INSN(), 5813 }, 5814 INTERNAL, 5815 { }, 5816 { { 0, -3 } }, 5817 }, 5818 { 5819 "ALU64_NEG: -(-3) = 3", 5820 .u.insns_int = { 5821 BPF_LD_IMM64(R0, -3), 5822 BPF_ALU64_IMM(BPF_NEG, R0, 0), 5823 BPF_EXIT_INSN(), 5824 }, 5825 INTERNAL, 5826 { }, 5827 { { 0, 3 } }, 5828 }, 5829 /* BPF_ALU | BPF_END | BPF_FROM_BE */ 5830 { 5831 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef", 5832 .u.insns_int = { 5833 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5834 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 5835 BPF_EXIT_INSN(), 5836 }, 5837 INTERNAL, 5838 { }, 5839 { { 0, cpu_to_be16(0xcdef) } }, 5840 }, 5841 { 5842 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef", 5843 .u.insns_int = { 5844 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5845 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 5846 BPF_ALU64_REG(BPF_MOV, R1, R0), 5847 BPF_ALU64_IMM(BPF_RSH, R1, 32), 5848 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 5849 BPF_EXIT_INSN(), 5850 }, 5851 INTERNAL, 5852 { }, 5853 { { 0, cpu_to_be32(0x89abcdef) } }, 5854 }, 5855 { 5856 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef", 5857 .u.insns_int = { 5858 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5859 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 5860 BPF_EXIT_INSN(), 5861 }, 5862 INTERNAL, 5863 { }, 5864 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } }, 5865 }, 5866 /* BPF_ALU | BPF_END | BPF_FROM_LE */ 5867 { 5868 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd", 5869 .u.insns_int = { 5870 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5871 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 5872 BPF_EXIT_INSN(), 5873 }, 5874 INTERNAL, 5875 { }, 5876 { { 0, cpu_to_le16(0xcdef) } }, 5877 }, 5878 { 5879 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89", 5880 .u.insns_int = { 5881 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5882 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 5883 BPF_ALU64_REG(BPF_MOV, R1, R0), 5884 BPF_ALU64_IMM(BPF_RSH, R1, 32), 5885 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 5886 BPF_EXIT_INSN(), 5887 }, 5888 INTERNAL, 5889 { }, 5890 { { 0, cpu_to_le32(0x89abcdef) } }, 5891 }, 5892 { 5893 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301", 5894 .u.insns_int = { 5895 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5896 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 5897 BPF_EXIT_INSN(), 5898 }, 5899 INTERNAL, 5900 { }, 5901 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } }, 5902 }, 5903 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */ 5904 { 5905 "ST_MEM_B: Store/Load byte: max negative", 5906 .u.insns_int = { 5907 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5908 BPF_ST_MEM(BPF_B, R10, -40, 0xff), 5909 BPF_LDX_MEM(BPF_B, R0, R10, -40), 5910 BPF_EXIT_INSN(), 5911 }, 5912 INTERNAL, 5913 { }, 5914 { { 0, 0xff } }, 5915 .stack_depth = 40, 5916 }, 5917 { 5918 "ST_MEM_B: Store/Load byte: max positive", 5919 .u.insns_int = { 5920 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5921 BPF_ST_MEM(BPF_H, R10, -40, 0x7f), 5922 BPF_LDX_MEM(BPF_H, R0, R10, -40), 5923 BPF_EXIT_INSN(), 5924 }, 5925 INTERNAL, 5926 { }, 5927 { { 0, 0x7f } }, 5928 .stack_depth = 40, 5929 }, 5930 { 5931 "STX_MEM_B: Store/Load byte: max negative", 5932 .u.insns_int = { 5933 BPF_LD_IMM64(R0, 0), 5934 BPF_LD_IMM64(R1, 0xffLL), 5935 BPF_STX_MEM(BPF_B, R10, R1, -40), 5936 BPF_LDX_MEM(BPF_B, R0, R10, -40), 5937 BPF_EXIT_INSN(), 5938 }, 5939 INTERNAL, 5940 { }, 5941 { { 0, 0xff } }, 5942 .stack_depth = 40, 5943 }, 5944 { 5945 "ST_MEM_H: Store/Load half word: max negative", 5946 .u.insns_int = { 5947 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5948 BPF_ST_MEM(BPF_H, R10, -40, 0xffff), 5949 BPF_LDX_MEM(BPF_H, R0, R10, -40), 5950 BPF_EXIT_INSN(), 5951 }, 5952 INTERNAL, 5953 { }, 5954 { { 0, 0xffff } }, 5955 .stack_depth = 40, 5956 }, 5957 { 5958 "ST_MEM_H: Store/Load half word: max positive", 5959 .u.insns_int = { 5960 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5961 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff), 5962 BPF_LDX_MEM(BPF_H, R0, R10, -40), 5963 BPF_EXIT_INSN(), 5964 }, 5965 INTERNAL, 5966 { }, 5967 { { 0, 0x7fff } }, 5968 .stack_depth = 40, 5969 }, 5970 { 5971 "STX_MEM_H: Store/Load half word: max negative", 5972 .u.insns_int = { 5973 BPF_LD_IMM64(R0, 0), 5974 BPF_LD_IMM64(R1, 0xffffLL), 5975 BPF_STX_MEM(BPF_H, R10, R1, -40), 5976 BPF_LDX_MEM(BPF_H, R0, R10, -40), 5977 BPF_EXIT_INSN(), 5978 }, 5979 INTERNAL, 5980 { }, 5981 { { 0, 0xffff } }, 5982 .stack_depth = 40, 5983 }, 5984 { 5985 "ST_MEM_W: Store/Load word: max negative", 5986 .u.insns_int = { 5987 BPF_ALU32_IMM(BPF_MOV, R0, 1), 5988 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff), 5989 BPF_LDX_MEM(BPF_W, R0, R10, -40), 5990 BPF_EXIT_INSN(), 5991 }, 5992 INTERNAL, 5993 { }, 5994 { { 0, 0xffffffff } }, 5995 .stack_depth = 40, 5996 }, 5997 { 5998 "ST_MEM_W: Store/Load word: max positive", 5999 .u.insns_int = { 6000 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6001 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff), 6002 BPF_LDX_MEM(BPF_W, R0, R10, -40), 6003 BPF_EXIT_INSN(), 6004 }, 6005 INTERNAL, 6006 { }, 6007 { { 0, 0x7fffffff } }, 6008 .stack_depth = 40, 6009 }, 6010 { 6011 "STX_MEM_W: Store/Load word: max negative", 6012 .u.insns_int = { 6013 BPF_LD_IMM64(R0, 0), 6014 BPF_LD_IMM64(R1, 0xffffffffLL), 6015 BPF_STX_MEM(BPF_W, R10, R1, -40), 6016 BPF_LDX_MEM(BPF_W, R0, R10, -40), 6017 BPF_EXIT_INSN(), 6018 }, 6019 INTERNAL, 6020 { }, 6021 { { 0, 0xffffffff } }, 6022 .stack_depth = 40, 6023 }, 6024 { 6025 "ST_MEM_DW: Store/Load double word: max negative", 6026 .u.insns_int = { 6027 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6028 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 6029 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 6030 BPF_EXIT_INSN(), 6031 }, 6032 INTERNAL, 6033 { }, 6034 { { 0, 0xffffffff } }, 6035 .stack_depth = 40, 6036 }, 6037 { 6038 "ST_MEM_DW: Store/Load double word: max negative 2", 6039 .u.insns_int = { 6040 BPF_LD_IMM64(R2, 0xffff00000000ffffLL), 6041 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6042 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 6043 BPF_LDX_MEM(BPF_DW, R2, R10, -40), 6044 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6045 BPF_MOV32_IMM(R0, 2), 6046 BPF_EXIT_INSN(), 6047 BPF_MOV32_IMM(R0, 1), 6048 BPF_EXIT_INSN(), 6049 }, 6050 INTERNAL, 6051 { }, 6052 { { 0, 0x1 } }, 6053 .stack_depth = 40, 6054 }, 6055 { 6056 "ST_MEM_DW: Store/Load double word: max positive", 6057 .u.insns_int = { 6058 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6059 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff), 6060 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 6061 BPF_EXIT_INSN(), 6062 }, 6063 INTERNAL, 6064 { }, 6065 { { 0, 0x7fffffff } }, 6066 .stack_depth = 40, 6067 }, 6068 { 6069 "STX_MEM_DW: Store/Load double word: max negative", 6070 .u.insns_int = { 6071 BPF_LD_IMM64(R0, 0), 6072 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 6073 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6074 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 6075 BPF_EXIT_INSN(), 6076 }, 6077 INTERNAL, 6078 { }, 6079 { { 0, 0xffffffff } }, 6080 .stack_depth = 40, 6081 }, 6082 { 6083 "STX_MEM_DW: Store double word: first word in memory", 6084 .u.insns_int = { 6085 BPF_LD_IMM64(R0, 0), 6086 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 6087 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6088 BPF_LDX_MEM(BPF_W, R0, R10, -40), 6089 BPF_EXIT_INSN(), 6090 }, 6091 INTERNAL, 6092 { }, 6093 #ifdef __BIG_ENDIAN 6094 { { 0, 0x01234567 } }, 6095 #else 6096 { { 0, 0x89abcdef } }, 6097 #endif 6098 .stack_depth = 40, 6099 }, 6100 { 6101 "STX_MEM_DW: Store double word: second word in memory", 6102 .u.insns_int = { 6103 BPF_LD_IMM64(R0, 0), 6104 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 6105 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6106 BPF_LDX_MEM(BPF_W, R0, R10, -36), 6107 BPF_EXIT_INSN(), 6108 }, 6109 INTERNAL, 6110 { }, 6111 #ifdef __BIG_ENDIAN 6112 { { 0, 0x89abcdef } }, 6113 #else 6114 { { 0, 0x01234567 } }, 6115 #endif 6116 .stack_depth = 40, 6117 }, 6118 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */ 6119 { 6120 "STX_XADD_W: X + 1 + 1 + 1 + ...", 6121 { }, 6122 INTERNAL, 6123 { }, 6124 { { 0, 4134 } }, 6125 .fill_helper = bpf_fill_stxw, 6126 }, 6127 { 6128 "STX_XADD_DW: X + 1 + 1 + 1 + ...", 6129 { }, 6130 INTERNAL, 6131 { }, 6132 { { 0, 4134 } }, 6133 .fill_helper = bpf_fill_stxdw, 6134 }, 6135 /* 6136 * Exhaustive tests of atomic operation variants. 6137 * Individual tests are expanded from template macros for all 6138 * combinations of ALU operation, word size and fetching. 6139 */ 6140 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \ 6141 { \ 6142 "BPF_ATOMIC | " #width ", " #op ": Test: " \ 6143 #old " " #logic " " #update " = " #result, \ 6144 .u.insns_int = { \ 6145 BPF_ALU32_IMM(BPF_MOV, R5, update), \ 6146 BPF_ST_MEM(width, R10, -40, old), \ 6147 BPF_ATOMIC_OP(width, op, R10, R5, -40), \ 6148 BPF_LDX_MEM(width, R0, R10, -40), \ 6149 BPF_EXIT_INSN(), \ 6150 }, \ 6151 INTERNAL, \ 6152 { }, \ 6153 { { 0, result } }, \ 6154 .stack_depth = 40, \ 6155 } 6156 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \ 6157 { \ 6158 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \ 6159 #old " " #logic " " #update " = " #result, \ 6160 .u.insns_int = { \ 6161 BPF_ALU64_REG(BPF_MOV, R1, R10), \ 6162 BPF_ALU32_IMM(BPF_MOV, R0, update), \ 6163 BPF_ST_MEM(BPF_W, R10, -40, old), \ 6164 BPF_ATOMIC_OP(width, op, R10, R0, -40), \ 6165 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 6166 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 6167 BPF_EXIT_INSN(), \ 6168 }, \ 6169 INTERNAL, \ 6170 { }, \ 6171 { { 0, 0 } }, \ 6172 .stack_depth = 40, \ 6173 } 6174 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \ 6175 { \ 6176 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \ 6177 #old " " #logic " " #update " = " #result, \ 6178 .u.insns_int = { \ 6179 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 6180 BPF_ALU32_IMM(BPF_MOV, R1, update), \ 6181 BPF_ST_MEM(width, R10, -40, old), \ 6182 BPF_ATOMIC_OP(width, op, R10, R1, -40), \ 6183 BPF_ALU64_REG(BPF_SUB, R0, R10), \ 6184 BPF_EXIT_INSN(), \ 6185 }, \ 6186 INTERNAL, \ 6187 { }, \ 6188 { { 0, 0 } }, \ 6189 .stack_depth = 40, \ 6190 } 6191 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \ 6192 { \ 6193 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \ 6194 #old " " #logic " " #update " = " #result, \ 6195 .u.insns_int = { \ 6196 BPF_ALU32_IMM(BPF_MOV, R3, update), \ 6197 BPF_ST_MEM(width, R10, -40, old), \ 6198 BPF_ATOMIC_OP(width, op, R10, R3, -40), \ 6199 BPF_ALU64_REG(BPF_MOV, R0, R3), \ 6200 BPF_EXIT_INSN(), \ 6201 }, \ 6202 INTERNAL, \ 6203 { }, \ 6204 { { 0, (op) & BPF_FETCH ? old : update } }, \ 6205 .stack_depth = 40, \ 6206 } 6207 /* BPF_ATOMIC | BPF_W: BPF_ADD */ 6208 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 6209 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 6210 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 6211 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 6212 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */ 6213 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6214 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6215 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6216 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6217 /* BPF_ATOMIC | BPF_DW: BPF_ADD */ 6218 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 6219 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 6220 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 6221 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 6222 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */ 6223 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6224 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6225 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6226 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 6227 /* BPF_ATOMIC | BPF_W: BPF_AND */ 6228 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 6229 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 6230 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 6231 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 6232 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */ 6233 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6234 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6235 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6236 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6237 /* BPF_ATOMIC | BPF_DW: BPF_AND */ 6238 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 6239 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 6240 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 6241 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 6242 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */ 6243 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6244 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6245 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6246 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 6247 /* BPF_ATOMIC | BPF_W: BPF_OR */ 6248 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 6249 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 6250 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 6251 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 6252 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */ 6253 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6254 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6255 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6256 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6257 /* BPF_ATOMIC | BPF_DW: BPF_OR */ 6258 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 6259 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 6260 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 6261 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 6262 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */ 6263 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6264 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6265 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6266 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 6267 /* BPF_ATOMIC | BPF_W: BPF_XOR */ 6268 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6269 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6270 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6271 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6272 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */ 6273 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6274 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6275 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6276 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6277 /* BPF_ATOMIC | BPF_DW: BPF_XOR */ 6278 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6279 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6280 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6281 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 6282 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */ 6283 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6284 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6285 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6286 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 6287 /* BPF_ATOMIC | BPF_W: BPF_XCHG */ 6288 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6289 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6290 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6291 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6292 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */ 6293 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6294 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6295 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6296 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 6297 #undef BPF_ATOMIC_OP_TEST1 6298 #undef BPF_ATOMIC_OP_TEST2 6299 #undef BPF_ATOMIC_OP_TEST3 6300 #undef BPF_ATOMIC_OP_TEST4 6301 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */ 6302 { 6303 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return", 6304 .u.insns_int = { 6305 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 6306 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 6307 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 6308 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6309 BPF_EXIT_INSN(), 6310 }, 6311 INTERNAL, 6312 { }, 6313 { { 0, 0x01234567 } }, 6314 .stack_depth = 40, 6315 }, 6316 { 6317 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store", 6318 .u.insns_int = { 6319 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 6320 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 6321 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 6322 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6323 BPF_LDX_MEM(BPF_W, R0, R10, -40), 6324 BPF_EXIT_INSN(), 6325 }, 6326 INTERNAL, 6327 { }, 6328 { { 0, 0x89abcdef } }, 6329 .stack_depth = 40, 6330 }, 6331 { 6332 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return", 6333 .u.insns_int = { 6334 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 6335 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 6336 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 6337 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6338 BPF_EXIT_INSN(), 6339 }, 6340 INTERNAL, 6341 { }, 6342 { { 0, 0x01234567 } }, 6343 .stack_depth = 40, 6344 }, 6345 { 6346 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store", 6347 .u.insns_int = { 6348 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 6349 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 6350 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 6351 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6352 BPF_LDX_MEM(BPF_W, R0, R10, -40), 6353 BPF_EXIT_INSN(), 6354 }, 6355 INTERNAL, 6356 { }, 6357 { { 0, 0x01234567 } }, 6358 .stack_depth = 40, 6359 }, 6360 { 6361 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects", 6362 .u.insns_int = { 6363 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 6364 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 6365 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 6366 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6367 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 6368 BPF_ALU32_REG(BPF_MOV, R0, R3), 6369 BPF_EXIT_INSN(), 6370 }, 6371 INTERNAL, 6372 { }, 6373 { { 0, 0x89abcdef } }, 6374 .stack_depth = 40, 6375 }, 6376 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */ 6377 { 6378 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return", 6379 .u.insns_int = { 6380 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 6381 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 6382 BPF_ALU64_REG(BPF_MOV, R0, R1), 6383 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6384 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 6385 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 6386 BPF_ALU64_REG(BPF_SUB, R0, R1), 6387 BPF_EXIT_INSN(), 6388 }, 6389 INTERNAL, 6390 { }, 6391 { { 0, 0 } }, 6392 .stack_depth = 40, 6393 }, 6394 { 6395 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store", 6396 .u.insns_int = { 6397 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 6398 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 6399 BPF_ALU64_REG(BPF_MOV, R0, R1), 6400 BPF_STX_MEM(BPF_DW, R10, R0, -40), 6401 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 6402 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 6403 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 6404 BPF_ALU64_REG(BPF_SUB, R0, R2), 6405 BPF_EXIT_INSN(), 6406 }, 6407 INTERNAL, 6408 { }, 6409 { { 0, 0 } }, 6410 .stack_depth = 40, 6411 }, 6412 { 6413 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return", 6414 .u.insns_int = { 6415 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 6416 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 6417 BPF_ALU64_REG(BPF_MOV, R0, R1), 6418 BPF_ALU64_IMM(BPF_ADD, R0, 1), 6419 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6420 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 6421 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 6422 BPF_ALU64_REG(BPF_SUB, R0, R1), 6423 BPF_EXIT_INSN(), 6424 }, 6425 INTERNAL, 6426 { }, 6427 { { 0, 0 } }, 6428 .stack_depth = 40, 6429 }, 6430 { 6431 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store", 6432 .u.insns_int = { 6433 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 6434 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 6435 BPF_ALU64_REG(BPF_MOV, R0, R1), 6436 BPF_ALU64_IMM(BPF_ADD, R0, 1), 6437 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6438 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 6439 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 6440 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 6441 BPF_ALU64_REG(BPF_SUB, R0, R1), 6442 BPF_EXIT_INSN(), 6443 }, 6444 INTERNAL, 6445 { }, 6446 { { 0, 0 } }, 6447 .stack_depth = 40, 6448 }, 6449 { 6450 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects", 6451 .u.insns_int = { 6452 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 6453 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 6454 BPF_ALU64_REG(BPF_MOV, R0, R1), 6455 BPF_STX_MEM(BPF_DW, R10, R1, -40), 6456 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 6457 BPF_LD_IMM64(R0, 0xfecdba9876543210ULL), 6458 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 6459 BPF_ALU64_REG(BPF_SUB, R0, R2), 6460 BPF_EXIT_INSN(), 6461 }, 6462 INTERNAL, 6463 { }, 6464 { { 0, 0 } }, 6465 .stack_depth = 40, 6466 }, 6467 /* BPF_JMP32 | BPF_JEQ | BPF_K */ 6468 { 6469 "JMP32_JEQ_K: Small immediate", 6470 .u.insns_int = { 6471 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6472 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1), 6473 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 6474 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6475 BPF_EXIT_INSN(), 6476 }, 6477 INTERNAL, 6478 { }, 6479 { { 0, 123 } } 6480 }, 6481 { 6482 "JMP32_JEQ_K: Large immediate", 6483 .u.insns_int = { 6484 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 6485 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1), 6486 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1), 6487 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6488 BPF_EXIT_INSN(), 6489 }, 6490 INTERNAL, 6491 { }, 6492 { { 0, 12345678 } } 6493 }, 6494 { 6495 "JMP32_JEQ_K: negative immediate", 6496 .u.insns_int = { 6497 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6498 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 6499 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1), 6500 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6501 BPF_EXIT_INSN(), 6502 }, 6503 INTERNAL, 6504 { }, 6505 { { 0, -123 } } 6506 }, 6507 /* BPF_JMP32 | BPF_JEQ | BPF_X */ 6508 { 6509 "JMP32_JEQ_X", 6510 .u.insns_int = { 6511 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 6512 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 6513 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2), 6514 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 6515 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1), 6516 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6517 BPF_EXIT_INSN(), 6518 }, 6519 INTERNAL, 6520 { }, 6521 { { 0, 1234 } } 6522 }, 6523 /* BPF_JMP32 | BPF_JNE | BPF_K */ 6524 { 6525 "JMP32_JNE_K: Small immediate", 6526 .u.insns_int = { 6527 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6528 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 6529 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1), 6530 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6531 BPF_EXIT_INSN(), 6532 }, 6533 INTERNAL, 6534 { }, 6535 { { 0, 123 } } 6536 }, 6537 { 6538 "JMP32_JNE_K: Large immediate", 6539 .u.insns_int = { 6540 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 6541 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1), 6542 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1), 6543 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6544 BPF_EXIT_INSN(), 6545 }, 6546 INTERNAL, 6547 { }, 6548 { { 0, 12345678 } } 6549 }, 6550 { 6551 "JMP32_JNE_K: negative immediate", 6552 .u.insns_int = { 6553 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6554 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1), 6555 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 6556 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6557 BPF_EXIT_INSN(), 6558 }, 6559 INTERNAL, 6560 { }, 6561 { { 0, -123 } } 6562 }, 6563 /* BPF_JMP32 | BPF_JNE | BPF_X */ 6564 { 6565 "JMP32_JNE_X", 6566 .u.insns_int = { 6567 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 6568 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 6569 BPF_JMP32_REG(BPF_JNE, R0, R1, 2), 6570 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 6571 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 6572 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6573 BPF_EXIT_INSN(), 6574 }, 6575 INTERNAL, 6576 { }, 6577 { { 0, 1234 } } 6578 }, 6579 /* BPF_JMP32 | BPF_JSET | BPF_K */ 6580 { 6581 "JMP32_JSET_K: Small immediate", 6582 .u.insns_int = { 6583 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6584 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1), 6585 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1), 6586 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6587 BPF_EXIT_INSN(), 6588 }, 6589 INTERNAL, 6590 { }, 6591 { { 0, 1 } } 6592 }, 6593 { 6594 "JMP32_JSET_K: Large immediate", 6595 .u.insns_int = { 6596 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000), 6597 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1), 6598 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1), 6599 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6600 BPF_EXIT_INSN(), 6601 }, 6602 INTERNAL, 6603 { }, 6604 { { 0, 0x40000000 } } 6605 }, 6606 { 6607 "JMP32_JSET_K: negative immediate", 6608 .u.insns_int = { 6609 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6610 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1), 6611 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6612 BPF_EXIT_INSN(), 6613 }, 6614 INTERNAL, 6615 { }, 6616 { { 0, -123 } } 6617 }, 6618 /* BPF_JMP32 | BPF_JSET | BPF_X */ 6619 { 6620 "JMP32_JSET_X", 6621 .u.insns_int = { 6622 BPF_ALU32_IMM(BPF_MOV, R0, 8), 6623 BPF_ALU32_IMM(BPF_MOV, R1, 7), 6624 BPF_JMP32_REG(BPF_JSET, R0, R1, 2), 6625 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2), 6626 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 6627 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6628 BPF_EXIT_INSN(), 6629 }, 6630 INTERNAL, 6631 { }, 6632 { { 0, 8 } } 6633 }, 6634 /* BPF_JMP32 | BPF_JGT | BPF_K */ 6635 { 6636 "JMP32_JGT_K: Small immediate", 6637 .u.insns_int = { 6638 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6639 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1), 6640 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1), 6641 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6642 BPF_EXIT_INSN(), 6643 }, 6644 INTERNAL, 6645 { }, 6646 { { 0, 123 } } 6647 }, 6648 { 6649 "JMP32_JGT_K: Large immediate", 6650 .u.insns_int = { 6651 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6652 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1), 6653 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1), 6654 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6655 BPF_EXIT_INSN(), 6656 }, 6657 INTERNAL, 6658 { }, 6659 { { 0, 0xfffffffe } } 6660 }, 6661 /* BPF_JMP32 | BPF_JGT | BPF_X */ 6662 { 6663 "JMP32_JGT_X", 6664 .u.insns_int = { 6665 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6666 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6667 BPF_JMP32_REG(BPF_JGT, R0, R1, 2), 6668 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 6669 BPF_JMP32_REG(BPF_JGT, R0, R1, 1), 6670 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6671 BPF_EXIT_INSN(), 6672 }, 6673 INTERNAL, 6674 { }, 6675 { { 0, 0xfffffffe } } 6676 }, 6677 /* BPF_JMP32 | BPF_JGE | BPF_K */ 6678 { 6679 "JMP32_JGE_K: Small immediate", 6680 .u.insns_int = { 6681 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6682 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1), 6683 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1), 6684 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6685 BPF_EXIT_INSN(), 6686 }, 6687 INTERNAL, 6688 { }, 6689 { { 0, 123 } } 6690 }, 6691 { 6692 "JMP32_JGE_K: Large immediate", 6693 .u.insns_int = { 6694 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6695 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1), 6696 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1), 6697 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6698 BPF_EXIT_INSN(), 6699 }, 6700 INTERNAL, 6701 { }, 6702 { { 0, 0xfffffffe } } 6703 }, 6704 /* BPF_JMP32 | BPF_JGE | BPF_X */ 6705 { 6706 "JMP32_JGE_X", 6707 .u.insns_int = { 6708 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6709 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6710 BPF_JMP32_REG(BPF_JGE, R0, R1, 2), 6711 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 6712 BPF_JMP32_REG(BPF_JGE, R0, R1, 1), 6713 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6714 BPF_EXIT_INSN(), 6715 }, 6716 INTERNAL, 6717 { }, 6718 { { 0, 0xfffffffe } } 6719 }, 6720 /* BPF_JMP32 | BPF_JLT | BPF_K */ 6721 { 6722 "JMP32_JLT_K: Small immediate", 6723 .u.insns_int = { 6724 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6725 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1), 6726 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1), 6727 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6728 BPF_EXIT_INSN(), 6729 }, 6730 INTERNAL, 6731 { }, 6732 { { 0, 123 } } 6733 }, 6734 { 6735 "JMP32_JLT_K: Large immediate", 6736 .u.insns_int = { 6737 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6738 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1), 6739 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1), 6740 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6741 BPF_EXIT_INSN(), 6742 }, 6743 INTERNAL, 6744 { }, 6745 { { 0, 0xfffffffe } } 6746 }, 6747 /* BPF_JMP32 | BPF_JLT | BPF_X */ 6748 { 6749 "JMP32_JLT_X", 6750 .u.insns_int = { 6751 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6752 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 6753 BPF_JMP32_REG(BPF_JLT, R0, R1, 2), 6754 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 6755 BPF_JMP32_REG(BPF_JLT, R0, R1, 1), 6756 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6757 BPF_EXIT_INSN(), 6758 }, 6759 INTERNAL, 6760 { }, 6761 { { 0, 0xfffffffe } } 6762 }, 6763 /* BPF_JMP32 | BPF_JLE | BPF_K */ 6764 { 6765 "JMP32_JLE_K: Small immediate", 6766 .u.insns_int = { 6767 BPF_ALU32_IMM(BPF_MOV, R0, 123), 6768 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1), 6769 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1), 6770 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6771 BPF_EXIT_INSN(), 6772 }, 6773 INTERNAL, 6774 { }, 6775 { { 0, 123 } } 6776 }, 6777 { 6778 "JMP32_JLE_K: Large immediate", 6779 .u.insns_int = { 6780 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6781 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1), 6782 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1), 6783 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6784 BPF_EXIT_INSN(), 6785 }, 6786 INTERNAL, 6787 { }, 6788 { { 0, 0xfffffffe } } 6789 }, 6790 /* BPF_JMP32 | BPF_JLE | BPF_X */ 6791 { 6792 "JMP32_JLE_X", 6793 .u.insns_int = { 6794 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 6795 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 6796 BPF_JMP32_REG(BPF_JLE, R0, R1, 2), 6797 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 6798 BPF_JMP32_REG(BPF_JLE, R0, R1, 1), 6799 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6800 BPF_EXIT_INSN(), 6801 }, 6802 INTERNAL, 6803 { }, 6804 { { 0, 0xfffffffe } } 6805 }, 6806 /* BPF_JMP32 | BPF_JSGT | BPF_K */ 6807 { 6808 "JMP32_JSGT_K: Small immediate", 6809 .u.insns_int = { 6810 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6811 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1), 6812 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1), 6813 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6814 BPF_EXIT_INSN(), 6815 }, 6816 INTERNAL, 6817 { }, 6818 { { 0, -123 } } 6819 }, 6820 { 6821 "JMP32_JSGT_K: Large immediate", 6822 .u.insns_int = { 6823 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6824 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1), 6825 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1), 6826 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6827 BPF_EXIT_INSN(), 6828 }, 6829 INTERNAL, 6830 { }, 6831 { { 0, -12345678 } } 6832 }, 6833 /* BPF_JMP32 | BPF_JSGT | BPF_X */ 6834 { 6835 "JMP32_JSGT_X", 6836 .u.insns_int = { 6837 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6838 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 6839 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2), 6840 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 6841 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1), 6842 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6843 BPF_EXIT_INSN(), 6844 }, 6845 INTERNAL, 6846 { }, 6847 { { 0, -12345678 } } 6848 }, 6849 /* BPF_JMP32 | BPF_JSGE | BPF_K */ 6850 { 6851 "JMP32_JSGE_K: Small immediate", 6852 .u.insns_int = { 6853 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6854 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1), 6855 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1), 6856 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6857 BPF_EXIT_INSN(), 6858 }, 6859 INTERNAL, 6860 { }, 6861 { { 0, -123 } } 6862 }, 6863 { 6864 "JMP32_JSGE_K: Large immediate", 6865 .u.insns_int = { 6866 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6867 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1), 6868 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1), 6869 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6870 BPF_EXIT_INSN(), 6871 }, 6872 INTERNAL, 6873 { }, 6874 { { 0, -12345678 } } 6875 }, 6876 /* BPF_JMP32 | BPF_JSGE | BPF_X */ 6877 { 6878 "JMP32_JSGE_X", 6879 .u.insns_int = { 6880 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6881 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 6882 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2), 6883 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 6884 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1), 6885 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6886 BPF_EXIT_INSN(), 6887 }, 6888 INTERNAL, 6889 { }, 6890 { { 0, -12345678 } } 6891 }, 6892 /* BPF_JMP32 | BPF_JSLT | BPF_K */ 6893 { 6894 "JMP32_JSLT_K: Small immediate", 6895 .u.insns_int = { 6896 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6897 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1), 6898 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1), 6899 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6900 BPF_EXIT_INSN(), 6901 }, 6902 INTERNAL, 6903 { }, 6904 { { 0, -123 } } 6905 }, 6906 { 6907 "JMP32_JSLT_K: Large immediate", 6908 .u.insns_int = { 6909 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6910 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1), 6911 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1), 6912 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6913 BPF_EXIT_INSN(), 6914 }, 6915 INTERNAL, 6916 { }, 6917 { { 0, -12345678 } } 6918 }, 6919 /* BPF_JMP32 | BPF_JSLT | BPF_X */ 6920 { 6921 "JMP32_JSLT_X", 6922 .u.insns_int = { 6923 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6924 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 6925 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2), 6926 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 6927 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1), 6928 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6929 BPF_EXIT_INSN(), 6930 }, 6931 INTERNAL, 6932 { }, 6933 { { 0, -12345678 } } 6934 }, 6935 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 6936 { 6937 "JMP32_JSLE_K: Small immediate", 6938 .u.insns_int = { 6939 BPF_ALU32_IMM(BPF_MOV, R0, -123), 6940 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1), 6941 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1), 6942 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6943 BPF_EXIT_INSN(), 6944 }, 6945 INTERNAL, 6946 { }, 6947 { { 0, -123 } } 6948 }, 6949 { 6950 "JMP32_JSLE_K: Large immediate", 6951 .u.insns_int = { 6952 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6953 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1), 6954 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1), 6955 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6956 BPF_EXIT_INSN(), 6957 }, 6958 INTERNAL, 6959 { }, 6960 { { 0, -12345678 } } 6961 }, 6962 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 6963 { 6964 "JMP32_JSLE_X", 6965 .u.insns_int = { 6966 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 6967 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 6968 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2), 6969 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 6970 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1), 6971 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6972 BPF_EXIT_INSN(), 6973 }, 6974 INTERNAL, 6975 { }, 6976 { { 0, -12345678 } } 6977 }, 6978 /* BPF_JMP | BPF_EXIT */ 6979 { 6980 "JMP_EXIT", 6981 .u.insns_int = { 6982 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711), 6983 BPF_EXIT_INSN(), 6984 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712), 6985 }, 6986 INTERNAL, 6987 { }, 6988 { { 0, 0x4711 } }, 6989 }, 6990 /* BPF_JMP | BPF_JA */ 6991 { 6992 "JMP_JA: Unconditional jump: if (true) return 1", 6993 .u.insns_int = { 6994 BPF_ALU32_IMM(BPF_MOV, R0, 0), 6995 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 6996 BPF_EXIT_INSN(), 6997 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6998 BPF_EXIT_INSN(), 6999 }, 7000 INTERNAL, 7001 { }, 7002 { { 0, 1 } }, 7003 }, 7004 /* BPF_JMP | BPF_JSLT | BPF_K */ 7005 { 7006 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1", 7007 .u.insns_int = { 7008 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7009 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 7010 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 7011 BPF_EXIT_INSN(), 7012 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7013 BPF_EXIT_INSN(), 7014 }, 7015 INTERNAL, 7016 { }, 7017 { { 0, 1 } }, 7018 }, 7019 { 7020 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0", 7021 .u.insns_int = { 7022 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7023 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7024 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 7025 BPF_EXIT_INSN(), 7026 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7027 BPF_EXIT_INSN(), 7028 }, 7029 INTERNAL, 7030 { }, 7031 { { 0, 1 } }, 7032 }, 7033 /* BPF_JMP | BPF_JSGT | BPF_K */ 7034 { 7035 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1", 7036 .u.insns_int = { 7037 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7038 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7039 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1), 7040 BPF_EXIT_INSN(), 7041 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7042 BPF_EXIT_INSN(), 7043 }, 7044 INTERNAL, 7045 { }, 7046 { { 0, 1 } }, 7047 }, 7048 { 7049 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0", 7050 .u.insns_int = { 7051 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7052 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7053 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1), 7054 BPF_EXIT_INSN(), 7055 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7056 BPF_EXIT_INSN(), 7057 }, 7058 INTERNAL, 7059 { }, 7060 { { 0, 1 } }, 7061 }, 7062 /* BPF_JMP | BPF_JSLE | BPF_K */ 7063 { 7064 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1", 7065 .u.insns_int = { 7066 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7067 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 7068 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 7069 BPF_EXIT_INSN(), 7070 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7071 BPF_EXIT_INSN(), 7072 }, 7073 INTERNAL, 7074 { }, 7075 { { 0, 1 } }, 7076 }, 7077 { 7078 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1", 7079 .u.insns_int = { 7080 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7081 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7082 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 7083 BPF_EXIT_INSN(), 7084 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7085 BPF_EXIT_INSN(), 7086 }, 7087 INTERNAL, 7088 { }, 7089 { { 0, 1 } }, 7090 }, 7091 { 7092 "JMP_JSLE_K: Signed jump: value walk 1", 7093 .u.insns_int = { 7094 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7095 BPF_LD_IMM64(R1, 3), 7096 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6), 7097 BPF_ALU64_IMM(BPF_SUB, R1, 1), 7098 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 7099 BPF_ALU64_IMM(BPF_SUB, R1, 1), 7100 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 7101 BPF_ALU64_IMM(BPF_SUB, R1, 1), 7102 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 7103 BPF_EXIT_INSN(), /* bad exit */ 7104 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 7105 BPF_EXIT_INSN(), 7106 }, 7107 INTERNAL, 7108 { }, 7109 { { 0, 1 } }, 7110 }, 7111 { 7112 "JMP_JSLE_K: Signed jump: value walk 2", 7113 .u.insns_int = { 7114 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7115 BPF_LD_IMM64(R1, 3), 7116 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 7117 BPF_ALU64_IMM(BPF_SUB, R1, 2), 7118 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 7119 BPF_ALU64_IMM(BPF_SUB, R1, 2), 7120 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 7121 BPF_EXIT_INSN(), /* bad exit */ 7122 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 7123 BPF_EXIT_INSN(), 7124 }, 7125 INTERNAL, 7126 { }, 7127 { { 0, 1 } }, 7128 }, 7129 /* BPF_JMP | BPF_JSGE | BPF_K */ 7130 { 7131 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1", 7132 .u.insns_int = { 7133 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7134 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7135 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1), 7136 BPF_EXIT_INSN(), 7137 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7138 BPF_EXIT_INSN(), 7139 }, 7140 INTERNAL, 7141 { }, 7142 { { 0, 1 } }, 7143 }, 7144 { 7145 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1", 7146 .u.insns_int = { 7147 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7148 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7149 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1), 7150 BPF_EXIT_INSN(), 7151 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7152 BPF_EXIT_INSN(), 7153 }, 7154 INTERNAL, 7155 { }, 7156 { { 0, 1 } }, 7157 }, 7158 { 7159 "JMP_JSGE_K: Signed jump: value walk 1", 7160 .u.insns_int = { 7161 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7162 BPF_LD_IMM64(R1, -3), 7163 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6), 7164 BPF_ALU64_IMM(BPF_ADD, R1, 1), 7165 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 7166 BPF_ALU64_IMM(BPF_ADD, R1, 1), 7167 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 7168 BPF_ALU64_IMM(BPF_ADD, R1, 1), 7169 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 7170 BPF_EXIT_INSN(), /* bad exit */ 7171 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 7172 BPF_EXIT_INSN(), 7173 }, 7174 INTERNAL, 7175 { }, 7176 { { 0, 1 } }, 7177 }, 7178 { 7179 "JMP_JSGE_K: Signed jump: value walk 2", 7180 .u.insns_int = { 7181 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7182 BPF_LD_IMM64(R1, -3), 7183 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 7184 BPF_ALU64_IMM(BPF_ADD, R1, 2), 7185 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 7186 BPF_ALU64_IMM(BPF_ADD, R1, 2), 7187 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 7188 BPF_EXIT_INSN(), /* bad exit */ 7189 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 7190 BPF_EXIT_INSN(), 7191 }, 7192 INTERNAL, 7193 { }, 7194 { { 0, 1 } }, 7195 }, 7196 /* BPF_JMP | BPF_JGT | BPF_K */ 7197 { 7198 "JMP_JGT_K: if (3 > 2) return 1", 7199 .u.insns_int = { 7200 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7201 BPF_LD_IMM64(R1, 3), 7202 BPF_JMP_IMM(BPF_JGT, R1, 2, 1), 7203 BPF_EXIT_INSN(), 7204 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7205 BPF_EXIT_INSN(), 7206 }, 7207 INTERNAL, 7208 { }, 7209 { { 0, 1 } }, 7210 }, 7211 { 7212 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1", 7213 .u.insns_int = { 7214 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7215 BPF_LD_IMM64(R1, -1), 7216 BPF_JMP_IMM(BPF_JGT, R1, 1, 1), 7217 BPF_EXIT_INSN(), 7218 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7219 BPF_EXIT_INSN(), 7220 }, 7221 INTERNAL, 7222 { }, 7223 { { 0, 1 } }, 7224 }, 7225 /* BPF_JMP | BPF_JLT | BPF_K */ 7226 { 7227 "JMP_JLT_K: if (2 < 3) return 1", 7228 .u.insns_int = { 7229 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7230 BPF_LD_IMM64(R1, 2), 7231 BPF_JMP_IMM(BPF_JLT, R1, 3, 1), 7232 BPF_EXIT_INSN(), 7233 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7234 BPF_EXIT_INSN(), 7235 }, 7236 INTERNAL, 7237 { }, 7238 { { 0, 1 } }, 7239 }, 7240 { 7241 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1", 7242 .u.insns_int = { 7243 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7244 BPF_LD_IMM64(R1, 1), 7245 BPF_JMP_IMM(BPF_JLT, R1, -1, 1), 7246 BPF_EXIT_INSN(), 7247 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7248 BPF_EXIT_INSN(), 7249 }, 7250 INTERNAL, 7251 { }, 7252 { { 0, 1 } }, 7253 }, 7254 /* BPF_JMP | BPF_JGE | BPF_K */ 7255 { 7256 "JMP_JGE_K: if (3 >= 2) return 1", 7257 .u.insns_int = { 7258 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7259 BPF_LD_IMM64(R1, 3), 7260 BPF_JMP_IMM(BPF_JGE, R1, 2, 1), 7261 BPF_EXIT_INSN(), 7262 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7263 BPF_EXIT_INSN(), 7264 }, 7265 INTERNAL, 7266 { }, 7267 { { 0, 1 } }, 7268 }, 7269 /* BPF_JMP | BPF_JLE | BPF_K */ 7270 { 7271 "JMP_JLE_K: if (2 <= 3) return 1", 7272 .u.insns_int = { 7273 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7274 BPF_LD_IMM64(R1, 2), 7275 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 7276 BPF_EXIT_INSN(), 7277 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7278 BPF_EXIT_INSN(), 7279 }, 7280 INTERNAL, 7281 { }, 7282 { { 0, 1 } }, 7283 }, 7284 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */ 7285 { 7286 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)", 7287 .u.insns_int = { 7288 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 7289 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 7290 BPF_EXIT_INSN(), 7291 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 7292 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */ 7293 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */ 7294 BPF_EXIT_INSN(), 7295 }, 7296 INTERNAL, 7297 { }, 7298 { { 0, 1 } }, 7299 }, 7300 { 7301 "JMP_JGE_K: if (3 >= 3) return 1", 7302 .u.insns_int = { 7303 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7304 BPF_LD_IMM64(R1, 3), 7305 BPF_JMP_IMM(BPF_JGE, R1, 3, 1), 7306 BPF_EXIT_INSN(), 7307 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7308 BPF_EXIT_INSN(), 7309 }, 7310 INTERNAL, 7311 { }, 7312 { { 0, 1 } }, 7313 }, 7314 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */ 7315 { 7316 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)", 7317 .u.insns_int = { 7318 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 7319 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 7320 BPF_EXIT_INSN(), 7321 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 7322 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */ 7323 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */ 7324 BPF_EXIT_INSN(), 7325 }, 7326 INTERNAL, 7327 { }, 7328 { { 0, 1 } }, 7329 }, 7330 { 7331 "JMP_JLE_K: if (3 <= 3) return 1", 7332 .u.insns_int = { 7333 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7334 BPF_LD_IMM64(R1, 3), 7335 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 7336 BPF_EXIT_INSN(), 7337 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7338 BPF_EXIT_INSN(), 7339 }, 7340 INTERNAL, 7341 { }, 7342 { { 0, 1 } }, 7343 }, 7344 /* BPF_JMP | BPF_JNE | BPF_K */ 7345 { 7346 "JMP_JNE_K: if (3 != 2) return 1", 7347 .u.insns_int = { 7348 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7349 BPF_LD_IMM64(R1, 3), 7350 BPF_JMP_IMM(BPF_JNE, R1, 2, 1), 7351 BPF_EXIT_INSN(), 7352 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7353 BPF_EXIT_INSN(), 7354 }, 7355 INTERNAL, 7356 { }, 7357 { { 0, 1 } }, 7358 }, 7359 /* BPF_JMP | BPF_JEQ | BPF_K */ 7360 { 7361 "JMP_JEQ_K: if (3 == 3) return 1", 7362 .u.insns_int = { 7363 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7364 BPF_LD_IMM64(R1, 3), 7365 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1), 7366 BPF_EXIT_INSN(), 7367 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7368 BPF_EXIT_INSN(), 7369 }, 7370 INTERNAL, 7371 { }, 7372 { { 0, 1 } }, 7373 }, 7374 /* BPF_JMP | BPF_JSET | BPF_K */ 7375 { 7376 "JMP_JSET_K: if (0x3 & 0x2) return 1", 7377 .u.insns_int = { 7378 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7379 BPF_LD_IMM64(R1, 3), 7380 BPF_JMP_IMM(BPF_JSET, R1, 2, 1), 7381 BPF_EXIT_INSN(), 7382 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7383 BPF_EXIT_INSN(), 7384 }, 7385 INTERNAL, 7386 { }, 7387 { { 0, 1 } }, 7388 }, 7389 { 7390 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1", 7391 .u.insns_int = { 7392 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7393 BPF_LD_IMM64(R1, 3), 7394 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1), 7395 BPF_EXIT_INSN(), 7396 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7397 BPF_EXIT_INSN(), 7398 }, 7399 INTERNAL, 7400 { }, 7401 { { 0, 1 } }, 7402 }, 7403 /* BPF_JMP | BPF_JSGT | BPF_X */ 7404 { 7405 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1", 7406 .u.insns_int = { 7407 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7408 BPF_LD_IMM64(R1, -1), 7409 BPF_LD_IMM64(R2, -2), 7410 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 7411 BPF_EXIT_INSN(), 7412 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7413 BPF_EXIT_INSN(), 7414 }, 7415 INTERNAL, 7416 { }, 7417 { { 0, 1 } }, 7418 }, 7419 { 7420 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0", 7421 .u.insns_int = { 7422 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7423 BPF_LD_IMM64(R1, -1), 7424 BPF_LD_IMM64(R2, -1), 7425 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 7426 BPF_EXIT_INSN(), 7427 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7428 BPF_EXIT_INSN(), 7429 }, 7430 INTERNAL, 7431 { }, 7432 { { 0, 1 } }, 7433 }, 7434 /* BPF_JMP | BPF_JSLT | BPF_X */ 7435 { 7436 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1", 7437 .u.insns_int = { 7438 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7439 BPF_LD_IMM64(R1, -1), 7440 BPF_LD_IMM64(R2, -2), 7441 BPF_JMP_REG(BPF_JSLT, R2, R1, 1), 7442 BPF_EXIT_INSN(), 7443 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7444 BPF_EXIT_INSN(), 7445 }, 7446 INTERNAL, 7447 { }, 7448 { { 0, 1 } }, 7449 }, 7450 { 7451 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0", 7452 .u.insns_int = { 7453 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7454 BPF_LD_IMM64(R1, -1), 7455 BPF_LD_IMM64(R2, -1), 7456 BPF_JMP_REG(BPF_JSLT, R1, R2, 1), 7457 BPF_EXIT_INSN(), 7458 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7459 BPF_EXIT_INSN(), 7460 }, 7461 INTERNAL, 7462 { }, 7463 { { 0, 1 } }, 7464 }, 7465 /* BPF_JMP | BPF_JSGE | BPF_X */ 7466 { 7467 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1", 7468 .u.insns_int = { 7469 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7470 BPF_LD_IMM64(R1, -1), 7471 BPF_LD_IMM64(R2, -2), 7472 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 7473 BPF_EXIT_INSN(), 7474 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7475 BPF_EXIT_INSN(), 7476 }, 7477 INTERNAL, 7478 { }, 7479 { { 0, 1 } }, 7480 }, 7481 { 7482 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1", 7483 .u.insns_int = { 7484 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7485 BPF_LD_IMM64(R1, -1), 7486 BPF_LD_IMM64(R2, -1), 7487 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 7488 BPF_EXIT_INSN(), 7489 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7490 BPF_EXIT_INSN(), 7491 }, 7492 INTERNAL, 7493 { }, 7494 { { 0, 1 } }, 7495 }, 7496 /* BPF_JMP | BPF_JSLE | BPF_X */ 7497 { 7498 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1", 7499 .u.insns_int = { 7500 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7501 BPF_LD_IMM64(R1, -1), 7502 BPF_LD_IMM64(R2, -2), 7503 BPF_JMP_REG(BPF_JSLE, R2, R1, 1), 7504 BPF_EXIT_INSN(), 7505 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7506 BPF_EXIT_INSN(), 7507 }, 7508 INTERNAL, 7509 { }, 7510 { { 0, 1 } }, 7511 }, 7512 { 7513 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1", 7514 .u.insns_int = { 7515 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7516 BPF_LD_IMM64(R1, -1), 7517 BPF_LD_IMM64(R2, -1), 7518 BPF_JMP_REG(BPF_JSLE, R1, R2, 1), 7519 BPF_EXIT_INSN(), 7520 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7521 BPF_EXIT_INSN(), 7522 }, 7523 INTERNAL, 7524 { }, 7525 { { 0, 1 } }, 7526 }, 7527 /* BPF_JMP | BPF_JGT | BPF_X */ 7528 { 7529 "JMP_JGT_X: if (3 > 2) return 1", 7530 .u.insns_int = { 7531 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7532 BPF_LD_IMM64(R1, 3), 7533 BPF_LD_IMM64(R2, 2), 7534 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 7535 BPF_EXIT_INSN(), 7536 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7537 BPF_EXIT_INSN(), 7538 }, 7539 INTERNAL, 7540 { }, 7541 { { 0, 1 } }, 7542 }, 7543 { 7544 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1", 7545 .u.insns_int = { 7546 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7547 BPF_LD_IMM64(R1, -1), 7548 BPF_LD_IMM64(R2, 1), 7549 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 7550 BPF_EXIT_INSN(), 7551 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7552 BPF_EXIT_INSN(), 7553 }, 7554 INTERNAL, 7555 { }, 7556 { { 0, 1 } }, 7557 }, 7558 /* BPF_JMP | BPF_JLT | BPF_X */ 7559 { 7560 "JMP_JLT_X: if (2 < 3) return 1", 7561 .u.insns_int = { 7562 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7563 BPF_LD_IMM64(R1, 3), 7564 BPF_LD_IMM64(R2, 2), 7565 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 7566 BPF_EXIT_INSN(), 7567 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7568 BPF_EXIT_INSN(), 7569 }, 7570 INTERNAL, 7571 { }, 7572 { { 0, 1 } }, 7573 }, 7574 { 7575 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1", 7576 .u.insns_int = { 7577 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7578 BPF_LD_IMM64(R1, -1), 7579 BPF_LD_IMM64(R2, 1), 7580 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 7581 BPF_EXIT_INSN(), 7582 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7583 BPF_EXIT_INSN(), 7584 }, 7585 INTERNAL, 7586 { }, 7587 { { 0, 1 } }, 7588 }, 7589 /* BPF_JMP | BPF_JGE | BPF_X */ 7590 { 7591 "JMP_JGE_X: if (3 >= 2) return 1", 7592 .u.insns_int = { 7593 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7594 BPF_LD_IMM64(R1, 3), 7595 BPF_LD_IMM64(R2, 2), 7596 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 7597 BPF_EXIT_INSN(), 7598 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7599 BPF_EXIT_INSN(), 7600 }, 7601 INTERNAL, 7602 { }, 7603 { { 0, 1 } }, 7604 }, 7605 { 7606 "JMP_JGE_X: if (3 >= 3) return 1", 7607 .u.insns_int = { 7608 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7609 BPF_LD_IMM64(R1, 3), 7610 BPF_LD_IMM64(R2, 3), 7611 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 7612 BPF_EXIT_INSN(), 7613 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7614 BPF_EXIT_INSN(), 7615 }, 7616 INTERNAL, 7617 { }, 7618 { { 0, 1 } }, 7619 }, 7620 /* BPF_JMP | BPF_JLE | BPF_X */ 7621 { 7622 "JMP_JLE_X: if (2 <= 3) return 1", 7623 .u.insns_int = { 7624 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7625 BPF_LD_IMM64(R1, 3), 7626 BPF_LD_IMM64(R2, 2), 7627 BPF_JMP_REG(BPF_JLE, R2, R1, 1), 7628 BPF_EXIT_INSN(), 7629 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7630 BPF_EXIT_INSN(), 7631 }, 7632 INTERNAL, 7633 { }, 7634 { { 0, 1 } }, 7635 }, 7636 { 7637 "JMP_JLE_X: if (3 <= 3) return 1", 7638 .u.insns_int = { 7639 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7640 BPF_LD_IMM64(R1, 3), 7641 BPF_LD_IMM64(R2, 3), 7642 BPF_JMP_REG(BPF_JLE, R1, R2, 1), 7643 BPF_EXIT_INSN(), 7644 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7645 BPF_EXIT_INSN(), 7646 }, 7647 INTERNAL, 7648 { }, 7649 { { 0, 1 } }, 7650 }, 7651 { 7652 /* Mainly testing JIT + imm64 here. */ 7653 "JMP_JGE_X: ldimm64 test 1", 7654 .u.insns_int = { 7655 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7656 BPF_LD_IMM64(R1, 3), 7657 BPF_LD_IMM64(R2, 2), 7658 BPF_JMP_REG(BPF_JGE, R1, R2, 2), 7659 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7660 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 7661 BPF_EXIT_INSN(), 7662 }, 7663 INTERNAL, 7664 { }, 7665 { { 0, 0xeeeeeeeeU } }, 7666 }, 7667 { 7668 "JMP_JGE_X: ldimm64 test 2", 7669 .u.insns_int = { 7670 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7671 BPF_LD_IMM64(R1, 3), 7672 BPF_LD_IMM64(R2, 2), 7673 BPF_JMP_REG(BPF_JGE, R1, R2, 0), 7674 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7675 BPF_EXIT_INSN(), 7676 }, 7677 INTERNAL, 7678 { }, 7679 { { 0, 0xffffffffU } }, 7680 }, 7681 { 7682 "JMP_JGE_X: ldimm64 test 3", 7683 .u.insns_int = { 7684 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7685 BPF_LD_IMM64(R1, 3), 7686 BPF_LD_IMM64(R2, 2), 7687 BPF_JMP_REG(BPF_JGE, R1, R2, 4), 7688 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7689 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 7690 BPF_EXIT_INSN(), 7691 }, 7692 INTERNAL, 7693 { }, 7694 { { 0, 1 } }, 7695 }, 7696 { 7697 "JMP_JLE_X: ldimm64 test 1", 7698 .u.insns_int = { 7699 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7700 BPF_LD_IMM64(R1, 3), 7701 BPF_LD_IMM64(R2, 2), 7702 BPF_JMP_REG(BPF_JLE, R2, R1, 2), 7703 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7704 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 7705 BPF_EXIT_INSN(), 7706 }, 7707 INTERNAL, 7708 { }, 7709 { { 0, 0xeeeeeeeeU } }, 7710 }, 7711 { 7712 "JMP_JLE_X: ldimm64 test 2", 7713 .u.insns_int = { 7714 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7715 BPF_LD_IMM64(R1, 3), 7716 BPF_LD_IMM64(R2, 2), 7717 BPF_JMP_REG(BPF_JLE, R2, R1, 0), 7718 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7719 BPF_EXIT_INSN(), 7720 }, 7721 INTERNAL, 7722 { }, 7723 { { 0, 0xffffffffU } }, 7724 }, 7725 { 7726 "JMP_JLE_X: ldimm64 test 3", 7727 .u.insns_int = { 7728 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7729 BPF_LD_IMM64(R1, 3), 7730 BPF_LD_IMM64(R2, 2), 7731 BPF_JMP_REG(BPF_JLE, R2, R1, 4), 7732 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 7733 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 7734 BPF_EXIT_INSN(), 7735 }, 7736 INTERNAL, 7737 { }, 7738 { { 0, 1 } }, 7739 }, 7740 /* BPF_JMP | BPF_JNE | BPF_X */ 7741 { 7742 "JMP_JNE_X: if (3 != 2) return 1", 7743 .u.insns_int = { 7744 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7745 BPF_LD_IMM64(R1, 3), 7746 BPF_LD_IMM64(R2, 2), 7747 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 7748 BPF_EXIT_INSN(), 7749 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7750 BPF_EXIT_INSN(), 7751 }, 7752 INTERNAL, 7753 { }, 7754 { { 0, 1 } }, 7755 }, 7756 /* BPF_JMP | BPF_JEQ | BPF_X */ 7757 { 7758 "JMP_JEQ_X: if (3 == 3) return 1", 7759 .u.insns_int = { 7760 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7761 BPF_LD_IMM64(R1, 3), 7762 BPF_LD_IMM64(R2, 3), 7763 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 7764 BPF_EXIT_INSN(), 7765 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7766 BPF_EXIT_INSN(), 7767 }, 7768 INTERNAL, 7769 { }, 7770 { { 0, 1 } }, 7771 }, 7772 /* BPF_JMP | BPF_JSET | BPF_X */ 7773 { 7774 "JMP_JSET_X: if (0x3 & 0x2) return 1", 7775 .u.insns_int = { 7776 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7777 BPF_LD_IMM64(R1, 3), 7778 BPF_LD_IMM64(R2, 2), 7779 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 7780 BPF_EXIT_INSN(), 7781 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7782 BPF_EXIT_INSN(), 7783 }, 7784 INTERNAL, 7785 { }, 7786 { { 0, 1 } }, 7787 }, 7788 { 7789 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1", 7790 .u.insns_int = { 7791 BPF_ALU32_IMM(BPF_MOV, R0, 0), 7792 BPF_LD_IMM64(R1, 3), 7793 BPF_LD_IMM64(R2, 0xffffffff), 7794 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 7795 BPF_EXIT_INSN(), 7796 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7797 BPF_EXIT_INSN(), 7798 }, 7799 INTERNAL, 7800 { }, 7801 { { 0, 1 } }, 7802 }, 7803 { /* Mainly checking JIT here. */ 7804 "BPF_MAXINSNS: Very long conditional jump", 7805 { }, 7806 INTERNAL | FLAG_NO_DATA, 7807 { }, 7808 { { 0, 1 } }, 7809 .fill_helper = bpf_fill_long_jmp, 7810 }, 7811 { 7812 "JMP_JA: Jump, gap, jump, ...", 7813 { }, 7814 CLASSIC | FLAG_NO_DATA, 7815 { }, 7816 { { 0, 0xababcbac } }, 7817 .fill_helper = bpf_fill_ja, 7818 }, 7819 { /* Mainly checking JIT here. */ 7820 "BPF_MAXINSNS: Maximum possible literals", 7821 { }, 7822 CLASSIC | FLAG_NO_DATA, 7823 { }, 7824 { { 0, 0xffffffff } }, 7825 .fill_helper = bpf_fill_maxinsns1, 7826 }, 7827 { /* Mainly checking JIT here. */ 7828 "BPF_MAXINSNS: Single literal", 7829 { }, 7830 CLASSIC | FLAG_NO_DATA, 7831 { }, 7832 { { 0, 0xfefefefe } }, 7833 .fill_helper = bpf_fill_maxinsns2, 7834 }, 7835 { /* Mainly checking JIT here. */ 7836 "BPF_MAXINSNS: Run/add until end", 7837 { }, 7838 CLASSIC | FLAG_NO_DATA, 7839 { }, 7840 { { 0, 0x947bf368 } }, 7841 .fill_helper = bpf_fill_maxinsns3, 7842 }, 7843 { 7844 "BPF_MAXINSNS: Too many instructions", 7845 { }, 7846 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 7847 { }, 7848 { }, 7849 .fill_helper = bpf_fill_maxinsns4, 7850 .expected_errcode = -EINVAL, 7851 }, 7852 { /* Mainly checking JIT here. */ 7853 "BPF_MAXINSNS: Very long jump", 7854 { }, 7855 CLASSIC | FLAG_NO_DATA, 7856 { }, 7857 { { 0, 0xabababab } }, 7858 .fill_helper = bpf_fill_maxinsns5, 7859 }, 7860 { /* Mainly checking JIT here. */ 7861 "BPF_MAXINSNS: Ctx heavy transformations", 7862 { }, 7863 CLASSIC, 7864 { }, 7865 { 7866 { 1, SKB_VLAN_PRESENT }, 7867 { 10, SKB_VLAN_PRESENT } 7868 }, 7869 .fill_helper = bpf_fill_maxinsns6, 7870 }, 7871 { /* Mainly checking JIT here. */ 7872 "BPF_MAXINSNS: Call heavy transformations", 7873 { }, 7874 CLASSIC | FLAG_NO_DATA, 7875 { }, 7876 { { 1, 0 }, { 10, 0 } }, 7877 .fill_helper = bpf_fill_maxinsns7, 7878 }, 7879 { /* Mainly checking JIT here. */ 7880 "BPF_MAXINSNS: Jump heavy test", 7881 { }, 7882 CLASSIC | FLAG_NO_DATA, 7883 { }, 7884 { { 0, 0xffffffff } }, 7885 .fill_helper = bpf_fill_maxinsns8, 7886 }, 7887 { /* Mainly checking JIT here. */ 7888 "BPF_MAXINSNS: Very long jump backwards", 7889 { }, 7890 INTERNAL | FLAG_NO_DATA, 7891 { }, 7892 { { 0, 0xcbababab } }, 7893 .fill_helper = bpf_fill_maxinsns9, 7894 }, 7895 { /* Mainly checking JIT here. */ 7896 "BPF_MAXINSNS: Edge hopping nuthouse", 7897 { }, 7898 INTERNAL | FLAG_NO_DATA, 7899 { }, 7900 { { 0, 0xabababac } }, 7901 .fill_helper = bpf_fill_maxinsns10, 7902 }, 7903 { 7904 "BPF_MAXINSNS: Jump, gap, jump, ...", 7905 { }, 7906 CLASSIC | FLAG_NO_DATA, 7907 { }, 7908 { { 0, 0xababcbac } }, 7909 .fill_helper = bpf_fill_maxinsns11, 7910 }, 7911 { 7912 "BPF_MAXINSNS: jump over MSH", 7913 { }, 7914 CLASSIC | FLAG_EXPECTED_FAIL, 7915 { 0xfa, 0xfb, 0xfc, 0xfd, }, 7916 { { 4, 0xabababab } }, 7917 .fill_helper = bpf_fill_maxinsns12, 7918 .expected_errcode = -EINVAL, 7919 }, 7920 { 7921 "BPF_MAXINSNS: exec all MSH", 7922 { }, 7923 CLASSIC, 7924 { 0xfa, 0xfb, 0xfc, 0xfd, }, 7925 { { 4, 0xababab83 } }, 7926 .fill_helper = bpf_fill_maxinsns13, 7927 }, 7928 { 7929 "BPF_MAXINSNS: ld_abs+get_processor_id", 7930 { }, 7931 CLASSIC, 7932 { }, 7933 { { 1, 0xbee } }, 7934 .fill_helper = bpf_fill_ld_abs_get_processor_id, 7935 }, 7936 /* 7937 * LD_IND / LD_ABS on fragmented SKBs 7938 */ 7939 { 7940 "LD_IND byte frag", 7941 .u.insns = { 7942 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 7943 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0), 7944 BPF_STMT(BPF_RET | BPF_A, 0x0), 7945 }, 7946 CLASSIC | FLAG_SKB_FRAG, 7947 { }, 7948 { {0x40, 0x42} }, 7949 .frag_data = { 7950 0x42, 0x00, 0x00, 0x00, 7951 0x43, 0x44, 0x00, 0x00, 7952 0x21, 0x07, 0x19, 0x83, 7953 }, 7954 }, 7955 { 7956 "LD_IND halfword frag", 7957 .u.insns = { 7958 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 7959 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4), 7960 BPF_STMT(BPF_RET | BPF_A, 0x0), 7961 }, 7962 CLASSIC | FLAG_SKB_FRAG, 7963 { }, 7964 { {0x40, 0x4344} }, 7965 .frag_data = { 7966 0x42, 0x00, 0x00, 0x00, 7967 0x43, 0x44, 0x00, 0x00, 7968 0x21, 0x07, 0x19, 0x83, 7969 }, 7970 }, 7971 { 7972 "LD_IND word frag", 7973 .u.insns = { 7974 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 7975 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8), 7976 BPF_STMT(BPF_RET | BPF_A, 0x0), 7977 }, 7978 CLASSIC | FLAG_SKB_FRAG, 7979 { }, 7980 { {0x40, 0x21071983} }, 7981 .frag_data = { 7982 0x42, 0x00, 0x00, 0x00, 7983 0x43, 0x44, 0x00, 0x00, 7984 0x21, 0x07, 0x19, 0x83, 7985 }, 7986 }, 7987 { 7988 "LD_IND halfword mixed head/frag", 7989 .u.insns = { 7990 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 7991 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 7992 BPF_STMT(BPF_RET | BPF_A, 0x0), 7993 }, 7994 CLASSIC | FLAG_SKB_FRAG, 7995 { [0x3e] = 0x25, [0x3f] = 0x05, }, 7996 { {0x40, 0x0519} }, 7997 .frag_data = { 0x19, 0x82 }, 7998 }, 7999 { 8000 "LD_IND word mixed head/frag", 8001 .u.insns = { 8002 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 8003 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 8004 BPF_STMT(BPF_RET | BPF_A, 0x0), 8005 }, 8006 CLASSIC | FLAG_SKB_FRAG, 8007 { [0x3e] = 0x25, [0x3f] = 0x05, }, 8008 { {0x40, 0x25051982} }, 8009 .frag_data = { 0x19, 0x82 }, 8010 }, 8011 { 8012 "LD_ABS byte frag", 8013 .u.insns = { 8014 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40), 8015 BPF_STMT(BPF_RET | BPF_A, 0x0), 8016 }, 8017 CLASSIC | FLAG_SKB_FRAG, 8018 { }, 8019 { {0x40, 0x42} }, 8020 .frag_data = { 8021 0x42, 0x00, 0x00, 0x00, 8022 0x43, 0x44, 0x00, 0x00, 8023 0x21, 0x07, 0x19, 0x83, 8024 }, 8025 }, 8026 { 8027 "LD_ABS halfword frag", 8028 .u.insns = { 8029 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44), 8030 BPF_STMT(BPF_RET | BPF_A, 0x0), 8031 }, 8032 CLASSIC | FLAG_SKB_FRAG, 8033 { }, 8034 { {0x40, 0x4344} }, 8035 .frag_data = { 8036 0x42, 0x00, 0x00, 0x00, 8037 0x43, 0x44, 0x00, 0x00, 8038 0x21, 0x07, 0x19, 0x83, 8039 }, 8040 }, 8041 { 8042 "LD_ABS word frag", 8043 .u.insns = { 8044 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48), 8045 BPF_STMT(BPF_RET | BPF_A, 0x0), 8046 }, 8047 CLASSIC | FLAG_SKB_FRAG, 8048 { }, 8049 { {0x40, 0x21071983} }, 8050 .frag_data = { 8051 0x42, 0x00, 0x00, 0x00, 8052 0x43, 0x44, 0x00, 0x00, 8053 0x21, 0x07, 0x19, 0x83, 8054 }, 8055 }, 8056 { 8057 "LD_ABS halfword mixed head/frag", 8058 .u.insns = { 8059 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 8060 BPF_STMT(BPF_RET | BPF_A, 0x0), 8061 }, 8062 CLASSIC | FLAG_SKB_FRAG, 8063 { [0x3e] = 0x25, [0x3f] = 0x05, }, 8064 { {0x40, 0x0519} }, 8065 .frag_data = { 0x19, 0x82 }, 8066 }, 8067 { 8068 "LD_ABS word mixed head/frag", 8069 .u.insns = { 8070 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e), 8071 BPF_STMT(BPF_RET | BPF_A, 0x0), 8072 }, 8073 CLASSIC | FLAG_SKB_FRAG, 8074 { [0x3e] = 0x25, [0x3f] = 0x05, }, 8075 { {0x40, 0x25051982} }, 8076 .frag_data = { 0x19, 0x82 }, 8077 }, 8078 /* 8079 * LD_IND / LD_ABS on non fragmented SKBs 8080 */ 8081 { 8082 /* 8083 * this tests that the JIT/interpreter correctly resets X 8084 * before using it in an LD_IND instruction. 8085 */ 8086 "LD_IND byte default X", 8087 .u.insns = { 8088 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 8089 BPF_STMT(BPF_RET | BPF_A, 0x0), 8090 }, 8091 CLASSIC, 8092 { [0x1] = 0x42 }, 8093 { {0x40, 0x42 } }, 8094 }, 8095 { 8096 "LD_IND byte positive offset", 8097 .u.insns = { 8098 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8099 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 8100 BPF_STMT(BPF_RET | BPF_A, 0x0), 8101 }, 8102 CLASSIC, 8103 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8104 { {0x40, 0x82 } }, 8105 }, 8106 { 8107 "LD_IND byte negative offset", 8108 .u.insns = { 8109 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8110 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1), 8111 BPF_STMT(BPF_RET | BPF_A, 0x0), 8112 }, 8113 CLASSIC, 8114 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8115 { {0x40, 0x05 } }, 8116 }, 8117 { 8118 "LD_IND byte positive offset, all ff", 8119 .u.insns = { 8120 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8121 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 8122 BPF_STMT(BPF_RET | BPF_A, 0x0), 8123 }, 8124 CLASSIC, 8125 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8126 { {0x40, 0xff } }, 8127 }, 8128 { 8129 "LD_IND byte positive offset, out of bounds", 8130 .u.insns = { 8131 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8132 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 8133 BPF_STMT(BPF_RET | BPF_A, 0x0), 8134 }, 8135 CLASSIC, 8136 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8137 { {0x3f, 0 }, }, 8138 }, 8139 { 8140 "LD_IND byte negative offset, out of bounds", 8141 .u.insns = { 8142 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8143 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f), 8144 BPF_STMT(BPF_RET | BPF_A, 0x0), 8145 }, 8146 CLASSIC, 8147 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8148 { {0x3f, 0 } }, 8149 }, 8150 { 8151 "LD_IND byte negative offset, multiple calls", 8152 .u.insns = { 8153 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 8154 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1), 8155 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2), 8156 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3), 8157 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4), 8158 BPF_STMT(BPF_RET | BPF_A, 0x0), 8159 }, 8160 CLASSIC, 8161 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8162 { {0x40, 0x82 }, }, 8163 }, 8164 { 8165 "LD_IND halfword positive offset", 8166 .u.insns = { 8167 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8168 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2), 8169 BPF_STMT(BPF_RET | BPF_A, 0x0), 8170 }, 8171 CLASSIC, 8172 { 8173 [0x1c] = 0xaa, [0x1d] = 0x55, 8174 [0x1e] = 0xbb, [0x1f] = 0x66, 8175 [0x20] = 0xcc, [0x21] = 0x77, 8176 [0x22] = 0xdd, [0x23] = 0x88, 8177 }, 8178 { {0x40, 0xdd88 } }, 8179 }, 8180 { 8181 "LD_IND halfword negative offset", 8182 .u.insns = { 8183 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8184 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2), 8185 BPF_STMT(BPF_RET | BPF_A, 0x0), 8186 }, 8187 CLASSIC, 8188 { 8189 [0x1c] = 0xaa, [0x1d] = 0x55, 8190 [0x1e] = 0xbb, [0x1f] = 0x66, 8191 [0x20] = 0xcc, [0x21] = 0x77, 8192 [0x22] = 0xdd, [0x23] = 0x88, 8193 }, 8194 { {0x40, 0xbb66 } }, 8195 }, 8196 { 8197 "LD_IND halfword unaligned", 8198 .u.insns = { 8199 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8200 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 8201 BPF_STMT(BPF_RET | BPF_A, 0x0), 8202 }, 8203 CLASSIC, 8204 { 8205 [0x1c] = 0xaa, [0x1d] = 0x55, 8206 [0x1e] = 0xbb, [0x1f] = 0x66, 8207 [0x20] = 0xcc, [0x21] = 0x77, 8208 [0x22] = 0xdd, [0x23] = 0x88, 8209 }, 8210 { {0x40, 0x66cc } }, 8211 }, 8212 { 8213 "LD_IND halfword positive offset, all ff", 8214 .u.insns = { 8215 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d), 8216 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 8217 BPF_STMT(BPF_RET | BPF_A, 0x0), 8218 }, 8219 CLASSIC, 8220 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8221 { {0x40, 0xffff } }, 8222 }, 8223 { 8224 "LD_IND halfword positive offset, out of bounds", 8225 .u.insns = { 8226 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8227 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 8228 BPF_STMT(BPF_RET | BPF_A, 0x0), 8229 }, 8230 CLASSIC, 8231 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8232 { {0x3f, 0 }, }, 8233 }, 8234 { 8235 "LD_IND halfword negative offset, out of bounds", 8236 .u.insns = { 8237 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8238 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f), 8239 BPF_STMT(BPF_RET | BPF_A, 0x0), 8240 }, 8241 CLASSIC, 8242 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8243 { {0x3f, 0 } }, 8244 }, 8245 { 8246 "LD_IND word positive offset", 8247 .u.insns = { 8248 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8249 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4), 8250 BPF_STMT(BPF_RET | BPF_A, 0x0), 8251 }, 8252 CLASSIC, 8253 { 8254 [0x1c] = 0xaa, [0x1d] = 0x55, 8255 [0x1e] = 0xbb, [0x1f] = 0x66, 8256 [0x20] = 0xcc, [0x21] = 0x77, 8257 [0x22] = 0xdd, [0x23] = 0x88, 8258 [0x24] = 0xee, [0x25] = 0x99, 8259 [0x26] = 0xff, [0x27] = 0xaa, 8260 }, 8261 { {0x40, 0xee99ffaa } }, 8262 }, 8263 { 8264 "LD_IND word negative offset", 8265 .u.insns = { 8266 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8267 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4), 8268 BPF_STMT(BPF_RET | BPF_A, 0x0), 8269 }, 8270 CLASSIC, 8271 { 8272 [0x1c] = 0xaa, [0x1d] = 0x55, 8273 [0x1e] = 0xbb, [0x1f] = 0x66, 8274 [0x20] = 0xcc, [0x21] = 0x77, 8275 [0x22] = 0xdd, [0x23] = 0x88, 8276 [0x24] = 0xee, [0x25] = 0x99, 8277 [0x26] = 0xff, [0x27] = 0xaa, 8278 }, 8279 { {0x40, 0xaa55bb66 } }, 8280 }, 8281 { 8282 "LD_IND word unaligned (addr & 3 == 2)", 8283 .u.insns = { 8284 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8285 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 8286 BPF_STMT(BPF_RET | BPF_A, 0x0), 8287 }, 8288 CLASSIC, 8289 { 8290 [0x1c] = 0xaa, [0x1d] = 0x55, 8291 [0x1e] = 0xbb, [0x1f] = 0x66, 8292 [0x20] = 0xcc, [0x21] = 0x77, 8293 [0x22] = 0xdd, [0x23] = 0x88, 8294 [0x24] = 0xee, [0x25] = 0x99, 8295 [0x26] = 0xff, [0x27] = 0xaa, 8296 }, 8297 { {0x40, 0xbb66cc77 } }, 8298 }, 8299 { 8300 "LD_IND word unaligned (addr & 3 == 1)", 8301 .u.insns = { 8302 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8303 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3), 8304 BPF_STMT(BPF_RET | BPF_A, 0x0), 8305 }, 8306 CLASSIC, 8307 { 8308 [0x1c] = 0xaa, [0x1d] = 0x55, 8309 [0x1e] = 0xbb, [0x1f] = 0x66, 8310 [0x20] = 0xcc, [0x21] = 0x77, 8311 [0x22] = 0xdd, [0x23] = 0x88, 8312 [0x24] = 0xee, [0x25] = 0x99, 8313 [0x26] = 0xff, [0x27] = 0xaa, 8314 }, 8315 { {0x40, 0x55bb66cc } }, 8316 }, 8317 { 8318 "LD_IND word unaligned (addr & 3 == 3)", 8319 .u.insns = { 8320 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 8321 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1), 8322 BPF_STMT(BPF_RET | BPF_A, 0x0), 8323 }, 8324 CLASSIC, 8325 { 8326 [0x1c] = 0xaa, [0x1d] = 0x55, 8327 [0x1e] = 0xbb, [0x1f] = 0x66, 8328 [0x20] = 0xcc, [0x21] = 0x77, 8329 [0x22] = 0xdd, [0x23] = 0x88, 8330 [0x24] = 0xee, [0x25] = 0x99, 8331 [0x26] = 0xff, [0x27] = 0xaa, 8332 }, 8333 { {0x40, 0x66cc77dd } }, 8334 }, 8335 { 8336 "LD_IND word positive offset, all ff", 8337 .u.insns = { 8338 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 8339 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 8340 BPF_STMT(BPF_RET | BPF_A, 0x0), 8341 }, 8342 CLASSIC, 8343 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8344 { {0x40, 0xffffffff } }, 8345 }, 8346 { 8347 "LD_IND word positive offset, out of bounds", 8348 .u.insns = { 8349 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8350 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 8351 BPF_STMT(BPF_RET | BPF_A, 0x0), 8352 }, 8353 CLASSIC, 8354 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8355 { {0x3f, 0 }, }, 8356 }, 8357 { 8358 "LD_IND word negative offset, out of bounds", 8359 .u.insns = { 8360 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 8361 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f), 8362 BPF_STMT(BPF_RET | BPF_A, 0x0), 8363 }, 8364 CLASSIC, 8365 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8366 { {0x3f, 0 } }, 8367 }, 8368 { 8369 "LD_ABS byte", 8370 .u.insns = { 8371 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20), 8372 BPF_STMT(BPF_RET | BPF_A, 0x0), 8373 }, 8374 CLASSIC, 8375 { 8376 [0x1c] = 0xaa, [0x1d] = 0x55, 8377 [0x1e] = 0xbb, [0x1f] = 0x66, 8378 [0x20] = 0xcc, [0x21] = 0x77, 8379 [0x22] = 0xdd, [0x23] = 0x88, 8380 [0x24] = 0xee, [0x25] = 0x99, 8381 [0x26] = 0xff, [0x27] = 0xaa, 8382 }, 8383 { {0x40, 0xcc } }, 8384 }, 8385 { 8386 "LD_ABS byte positive offset, all ff", 8387 .u.insns = { 8388 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 8389 BPF_STMT(BPF_RET | BPF_A, 0x0), 8390 }, 8391 CLASSIC, 8392 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8393 { {0x40, 0xff } }, 8394 }, 8395 { 8396 "LD_ABS byte positive offset, out of bounds", 8397 .u.insns = { 8398 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 8399 BPF_STMT(BPF_RET | BPF_A, 0x0), 8400 }, 8401 CLASSIC, 8402 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8403 { {0x3f, 0 }, }, 8404 }, 8405 { 8406 "LD_ABS byte negative offset, out of bounds load", 8407 .u.insns = { 8408 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1), 8409 BPF_STMT(BPF_RET | BPF_A, 0x0), 8410 }, 8411 CLASSIC | FLAG_EXPECTED_FAIL, 8412 .expected_errcode = -EINVAL, 8413 }, 8414 { 8415 "LD_ABS byte negative offset, in bounds", 8416 .u.insns = { 8417 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 8418 BPF_STMT(BPF_RET | BPF_A, 0x0), 8419 }, 8420 CLASSIC, 8421 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8422 { {0x40, 0x82 }, }, 8423 }, 8424 { 8425 "LD_ABS byte negative offset, out of bounds", 8426 .u.insns = { 8427 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 8428 BPF_STMT(BPF_RET | BPF_A, 0x0), 8429 }, 8430 CLASSIC, 8431 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8432 { {0x3f, 0 }, }, 8433 }, 8434 { 8435 "LD_ABS byte negative offset, multiple calls", 8436 .u.insns = { 8437 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c), 8438 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d), 8439 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e), 8440 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 8441 BPF_STMT(BPF_RET | BPF_A, 0x0), 8442 }, 8443 CLASSIC, 8444 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8445 { {0x40, 0x82 }, }, 8446 }, 8447 { 8448 "LD_ABS halfword", 8449 .u.insns = { 8450 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22), 8451 BPF_STMT(BPF_RET | BPF_A, 0x0), 8452 }, 8453 CLASSIC, 8454 { 8455 [0x1c] = 0xaa, [0x1d] = 0x55, 8456 [0x1e] = 0xbb, [0x1f] = 0x66, 8457 [0x20] = 0xcc, [0x21] = 0x77, 8458 [0x22] = 0xdd, [0x23] = 0x88, 8459 [0x24] = 0xee, [0x25] = 0x99, 8460 [0x26] = 0xff, [0x27] = 0xaa, 8461 }, 8462 { {0x40, 0xdd88 } }, 8463 }, 8464 { 8465 "LD_ABS halfword unaligned", 8466 .u.insns = { 8467 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25), 8468 BPF_STMT(BPF_RET | BPF_A, 0x0), 8469 }, 8470 CLASSIC, 8471 { 8472 [0x1c] = 0xaa, [0x1d] = 0x55, 8473 [0x1e] = 0xbb, [0x1f] = 0x66, 8474 [0x20] = 0xcc, [0x21] = 0x77, 8475 [0x22] = 0xdd, [0x23] = 0x88, 8476 [0x24] = 0xee, [0x25] = 0x99, 8477 [0x26] = 0xff, [0x27] = 0xaa, 8478 }, 8479 { {0x40, 0x99ff } }, 8480 }, 8481 { 8482 "LD_ABS halfword positive offset, all ff", 8483 .u.insns = { 8484 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e), 8485 BPF_STMT(BPF_RET | BPF_A, 0x0), 8486 }, 8487 CLASSIC, 8488 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8489 { {0x40, 0xffff } }, 8490 }, 8491 { 8492 "LD_ABS halfword positive offset, out of bounds", 8493 .u.insns = { 8494 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 8495 BPF_STMT(BPF_RET | BPF_A, 0x0), 8496 }, 8497 CLASSIC, 8498 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8499 { {0x3f, 0 }, }, 8500 }, 8501 { 8502 "LD_ABS halfword negative offset, out of bounds load", 8503 .u.insns = { 8504 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1), 8505 BPF_STMT(BPF_RET | BPF_A, 0x0), 8506 }, 8507 CLASSIC | FLAG_EXPECTED_FAIL, 8508 .expected_errcode = -EINVAL, 8509 }, 8510 { 8511 "LD_ABS halfword negative offset, in bounds", 8512 .u.insns = { 8513 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 8514 BPF_STMT(BPF_RET | BPF_A, 0x0), 8515 }, 8516 CLASSIC, 8517 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8518 { {0x40, 0x1982 }, }, 8519 }, 8520 { 8521 "LD_ABS halfword negative offset, out of bounds", 8522 .u.insns = { 8523 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 8524 BPF_STMT(BPF_RET | BPF_A, 0x0), 8525 }, 8526 CLASSIC, 8527 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8528 { {0x3f, 0 }, }, 8529 }, 8530 { 8531 "LD_ABS word", 8532 .u.insns = { 8533 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c), 8534 BPF_STMT(BPF_RET | BPF_A, 0x0), 8535 }, 8536 CLASSIC, 8537 { 8538 [0x1c] = 0xaa, [0x1d] = 0x55, 8539 [0x1e] = 0xbb, [0x1f] = 0x66, 8540 [0x20] = 0xcc, [0x21] = 0x77, 8541 [0x22] = 0xdd, [0x23] = 0x88, 8542 [0x24] = 0xee, [0x25] = 0x99, 8543 [0x26] = 0xff, [0x27] = 0xaa, 8544 }, 8545 { {0x40, 0xaa55bb66 } }, 8546 }, 8547 { 8548 "LD_ABS word unaligned (addr & 3 == 2)", 8549 .u.insns = { 8550 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22), 8551 BPF_STMT(BPF_RET | BPF_A, 0x0), 8552 }, 8553 CLASSIC, 8554 { 8555 [0x1c] = 0xaa, [0x1d] = 0x55, 8556 [0x1e] = 0xbb, [0x1f] = 0x66, 8557 [0x20] = 0xcc, [0x21] = 0x77, 8558 [0x22] = 0xdd, [0x23] = 0x88, 8559 [0x24] = 0xee, [0x25] = 0x99, 8560 [0x26] = 0xff, [0x27] = 0xaa, 8561 }, 8562 { {0x40, 0xdd88ee99 } }, 8563 }, 8564 { 8565 "LD_ABS word unaligned (addr & 3 == 1)", 8566 .u.insns = { 8567 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21), 8568 BPF_STMT(BPF_RET | BPF_A, 0x0), 8569 }, 8570 CLASSIC, 8571 { 8572 [0x1c] = 0xaa, [0x1d] = 0x55, 8573 [0x1e] = 0xbb, [0x1f] = 0x66, 8574 [0x20] = 0xcc, [0x21] = 0x77, 8575 [0x22] = 0xdd, [0x23] = 0x88, 8576 [0x24] = 0xee, [0x25] = 0x99, 8577 [0x26] = 0xff, [0x27] = 0xaa, 8578 }, 8579 { {0x40, 0x77dd88ee } }, 8580 }, 8581 { 8582 "LD_ABS word unaligned (addr & 3 == 3)", 8583 .u.insns = { 8584 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23), 8585 BPF_STMT(BPF_RET | BPF_A, 0x0), 8586 }, 8587 CLASSIC, 8588 { 8589 [0x1c] = 0xaa, [0x1d] = 0x55, 8590 [0x1e] = 0xbb, [0x1f] = 0x66, 8591 [0x20] = 0xcc, [0x21] = 0x77, 8592 [0x22] = 0xdd, [0x23] = 0x88, 8593 [0x24] = 0xee, [0x25] = 0x99, 8594 [0x26] = 0xff, [0x27] = 0xaa, 8595 }, 8596 { {0x40, 0x88ee99ff } }, 8597 }, 8598 { 8599 "LD_ABS word positive offset, all ff", 8600 .u.insns = { 8601 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c), 8602 BPF_STMT(BPF_RET | BPF_A, 0x0), 8603 }, 8604 CLASSIC, 8605 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 8606 { {0x40, 0xffffffff } }, 8607 }, 8608 { 8609 "LD_ABS word positive offset, out of bounds", 8610 .u.insns = { 8611 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f), 8612 BPF_STMT(BPF_RET | BPF_A, 0x0), 8613 }, 8614 CLASSIC, 8615 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8616 { {0x3f, 0 }, }, 8617 }, 8618 { 8619 "LD_ABS word negative offset, out of bounds load", 8620 .u.insns = { 8621 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1), 8622 BPF_STMT(BPF_RET | BPF_A, 0x0), 8623 }, 8624 CLASSIC | FLAG_EXPECTED_FAIL, 8625 .expected_errcode = -EINVAL, 8626 }, 8627 { 8628 "LD_ABS word negative offset, in bounds", 8629 .u.insns = { 8630 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 8631 BPF_STMT(BPF_RET | BPF_A, 0x0), 8632 }, 8633 CLASSIC, 8634 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8635 { {0x40, 0x25051982 }, }, 8636 }, 8637 { 8638 "LD_ABS word negative offset, out of bounds", 8639 .u.insns = { 8640 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 8641 BPF_STMT(BPF_RET | BPF_A, 0x0), 8642 }, 8643 CLASSIC, 8644 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8645 { {0x3f, 0 }, }, 8646 }, 8647 { 8648 "LDX_MSH standalone, preserved A", 8649 .u.insns = { 8650 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8651 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 8652 BPF_STMT(BPF_RET | BPF_A, 0x0), 8653 }, 8654 CLASSIC, 8655 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8656 { {0x40, 0xffeebbaa }, }, 8657 }, 8658 { 8659 "LDX_MSH standalone, preserved A 2", 8660 .u.insns = { 8661 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63), 8662 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 8663 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d), 8664 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 8665 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f), 8666 BPF_STMT(BPF_RET | BPF_A, 0x0), 8667 }, 8668 CLASSIC, 8669 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8670 { {0x40, 0x175e9d63 }, }, 8671 }, 8672 { 8673 "LDX_MSH standalone, test result 1", 8674 .u.insns = { 8675 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8676 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 8677 BPF_STMT(BPF_MISC | BPF_TXA, 0), 8678 BPF_STMT(BPF_RET | BPF_A, 0x0), 8679 }, 8680 CLASSIC, 8681 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8682 { {0x40, 0x14 }, }, 8683 }, 8684 { 8685 "LDX_MSH standalone, test result 2", 8686 .u.insns = { 8687 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8688 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 8689 BPF_STMT(BPF_MISC | BPF_TXA, 0), 8690 BPF_STMT(BPF_RET | BPF_A, 0x0), 8691 }, 8692 CLASSIC, 8693 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8694 { {0x40, 0x24 }, }, 8695 }, 8696 { 8697 "LDX_MSH standalone, negative offset", 8698 .u.insns = { 8699 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8700 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1), 8701 BPF_STMT(BPF_MISC | BPF_TXA, 0), 8702 BPF_STMT(BPF_RET | BPF_A, 0x0), 8703 }, 8704 CLASSIC, 8705 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8706 { {0x40, 0 }, }, 8707 }, 8708 { 8709 "LDX_MSH standalone, negative offset 2", 8710 .u.insns = { 8711 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8712 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e), 8713 BPF_STMT(BPF_MISC | BPF_TXA, 0), 8714 BPF_STMT(BPF_RET | BPF_A, 0x0), 8715 }, 8716 CLASSIC, 8717 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8718 { {0x40, 0x24 }, }, 8719 }, 8720 { 8721 "LDX_MSH standalone, out of bounds", 8722 .u.insns = { 8723 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 8724 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40), 8725 BPF_STMT(BPF_MISC | BPF_TXA, 0), 8726 BPF_STMT(BPF_RET | BPF_A, 0x0), 8727 }, 8728 CLASSIC, 8729 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 8730 { {0x40, 0 }, }, 8731 }, 8732 /* 8733 * verify that the interpreter or JIT correctly sets A and X 8734 * to 0. 8735 */ 8736 { 8737 "ADD default X", 8738 .u.insns = { 8739 /* 8740 * A = 0x42 8741 * A = A + X 8742 * ret A 8743 */ 8744 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 8745 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 8746 BPF_STMT(BPF_RET | BPF_A, 0x0), 8747 }, 8748 CLASSIC | FLAG_NO_DATA, 8749 {}, 8750 { {0x1, 0x42 } }, 8751 }, 8752 { 8753 "ADD default A", 8754 .u.insns = { 8755 /* 8756 * A = A + 0x42 8757 * ret A 8758 */ 8759 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42), 8760 BPF_STMT(BPF_RET | BPF_A, 0x0), 8761 }, 8762 CLASSIC | FLAG_NO_DATA, 8763 {}, 8764 { {0x1, 0x42 } }, 8765 }, 8766 { 8767 "SUB default X", 8768 .u.insns = { 8769 /* 8770 * A = 0x66 8771 * A = A - X 8772 * ret A 8773 */ 8774 BPF_STMT(BPF_LD | BPF_IMM, 0x66), 8775 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 8776 BPF_STMT(BPF_RET | BPF_A, 0x0), 8777 }, 8778 CLASSIC | FLAG_NO_DATA, 8779 {}, 8780 { {0x1, 0x66 } }, 8781 }, 8782 { 8783 "SUB default A", 8784 .u.insns = { 8785 /* 8786 * A = A - -0x66 8787 * ret A 8788 */ 8789 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66), 8790 BPF_STMT(BPF_RET | BPF_A, 0x0), 8791 }, 8792 CLASSIC | FLAG_NO_DATA, 8793 {}, 8794 { {0x1, 0x66 } }, 8795 }, 8796 { 8797 "MUL default X", 8798 .u.insns = { 8799 /* 8800 * A = 0x42 8801 * A = A * X 8802 * ret A 8803 */ 8804 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 8805 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0), 8806 BPF_STMT(BPF_RET | BPF_A, 0x0), 8807 }, 8808 CLASSIC | FLAG_NO_DATA, 8809 {}, 8810 { {0x1, 0x0 } }, 8811 }, 8812 { 8813 "MUL default A", 8814 .u.insns = { 8815 /* 8816 * A = A * 0x66 8817 * ret A 8818 */ 8819 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66), 8820 BPF_STMT(BPF_RET | BPF_A, 0x0), 8821 }, 8822 CLASSIC | FLAG_NO_DATA, 8823 {}, 8824 { {0x1, 0x0 } }, 8825 }, 8826 { 8827 "DIV default X", 8828 .u.insns = { 8829 /* 8830 * A = 0x42 8831 * A = A / X ; this halt the filter execution if X is 0 8832 * ret 0x42 8833 */ 8834 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 8835 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 8836 BPF_STMT(BPF_RET | BPF_K, 0x42), 8837 }, 8838 CLASSIC | FLAG_NO_DATA, 8839 {}, 8840 { {0x1, 0x0 } }, 8841 }, 8842 { 8843 "DIV default A", 8844 .u.insns = { 8845 /* 8846 * A = A / 1 8847 * ret A 8848 */ 8849 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1), 8850 BPF_STMT(BPF_RET | BPF_A, 0x0), 8851 }, 8852 CLASSIC | FLAG_NO_DATA, 8853 {}, 8854 { {0x1, 0x0 } }, 8855 }, 8856 { 8857 "MOD default X", 8858 .u.insns = { 8859 /* 8860 * A = 0x42 8861 * A = A mod X ; this halt the filter execution if X is 0 8862 * ret 0x42 8863 */ 8864 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 8865 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 8866 BPF_STMT(BPF_RET | BPF_K, 0x42), 8867 }, 8868 CLASSIC | FLAG_NO_DATA, 8869 {}, 8870 { {0x1, 0x0 } }, 8871 }, 8872 { 8873 "MOD default A", 8874 .u.insns = { 8875 /* 8876 * A = A mod 1 8877 * ret A 8878 */ 8879 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1), 8880 BPF_STMT(BPF_RET | BPF_A, 0x0), 8881 }, 8882 CLASSIC | FLAG_NO_DATA, 8883 {}, 8884 { {0x1, 0x0 } }, 8885 }, 8886 { 8887 "JMP EQ default A", 8888 .u.insns = { 8889 /* 8890 * cmp A, 0x0, 0, 1 8891 * ret 0x42 8892 * ret 0x66 8893 */ 8894 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1), 8895 BPF_STMT(BPF_RET | BPF_K, 0x42), 8896 BPF_STMT(BPF_RET | BPF_K, 0x66), 8897 }, 8898 CLASSIC | FLAG_NO_DATA, 8899 {}, 8900 { {0x1, 0x42 } }, 8901 }, 8902 { 8903 "JMP EQ default X", 8904 .u.insns = { 8905 /* 8906 * A = 0x0 8907 * cmp A, X, 0, 1 8908 * ret 0x42 8909 * ret 0x66 8910 */ 8911 BPF_STMT(BPF_LD | BPF_IMM, 0x0), 8912 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1), 8913 BPF_STMT(BPF_RET | BPF_K, 0x42), 8914 BPF_STMT(BPF_RET | BPF_K, 0x66), 8915 }, 8916 CLASSIC | FLAG_NO_DATA, 8917 {}, 8918 { {0x1, 0x42 } }, 8919 }, 8920 /* Checking interpreter vs JIT wrt signed extended imms. */ 8921 { 8922 "JNE signed compare, test 1", 8923 .u.insns_int = { 8924 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 8925 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 8926 BPF_MOV64_REG(R2, R1), 8927 BPF_ALU64_REG(BPF_AND, R2, R3), 8928 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8929 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1), 8930 BPF_ALU32_IMM(BPF_MOV, R0, 2), 8931 BPF_EXIT_INSN(), 8932 }, 8933 INTERNAL, 8934 { }, 8935 { { 0, 1 } }, 8936 }, 8937 { 8938 "JNE signed compare, test 2", 8939 .u.insns_int = { 8940 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 8941 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 8942 BPF_MOV64_REG(R2, R1), 8943 BPF_ALU64_REG(BPF_AND, R2, R3), 8944 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8945 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1), 8946 BPF_ALU32_IMM(BPF_MOV, R0, 2), 8947 BPF_EXIT_INSN(), 8948 }, 8949 INTERNAL, 8950 { }, 8951 { { 0, 1 } }, 8952 }, 8953 { 8954 "JNE signed compare, test 3", 8955 .u.insns_int = { 8956 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 8957 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 8958 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000), 8959 BPF_MOV64_REG(R2, R1), 8960 BPF_ALU64_REG(BPF_AND, R2, R3), 8961 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8962 BPF_JMP_REG(BPF_JNE, R2, R4, 1), 8963 BPF_ALU32_IMM(BPF_MOV, R0, 2), 8964 BPF_EXIT_INSN(), 8965 }, 8966 INTERNAL, 8967 { }, 8968 { { 0, 2 } }, 8969 }, 8970 { 8971 "JNE signed compare, test 4", 8972 .u.insns_int = { 8973 BPF_LD_IMM64(R1, -17104896), 8974 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8975 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1), 8976 BPF_ALU32_IMM(BPF_MOV, R0, 2), 8977 BPF_EXIT_INSN(), 8978 }, 8979 INTERNAL, 8980 { }, 8981 { { 0, 2 } }, 8982 }, 8983 { 8984 "JNE signed compare, test 5", 8985 .u.insns_int = { 8986 BPF_LD_IMM64(R1, 0xfefb0000), 8987 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8988 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1), 8989 BPF_ALU32_IMM(BPF_MOV, R0, 2), 8990 BPF_EXIT_INSN(), 8991 }, 8992 INTERNAL, 8993 { }, 8994 { { 0, 1 } }, 8995 }, 8996 { 8997 "JNE signed compare, test 6", 8998 .u.insns_int = { 8999 BPF_LD_IMM64(R1, 0x7efb0000), 9000 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9001 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1), 9002 BPF_ALU32_IMM(BPF_MOV, R0, 2), 9003 BPF_EXIT_INSN(), 9004 }, 9005 INTERNAL, 9006 { }, 9007 { { 0, 2 } }, 9008 }, 9009 { 9010 "JNE signed compare, test 7", 9011 .u.insns = { 9012 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000), 9013 BPF_STMT(BPF_MISC | BPF_TAX, 0), 9014 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12), 9015 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0), 9016 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0), 9017 BPF_STMT(BPF_RET | BPF_K, 1), 9018 BPF_STMT(BPF_RET | BPF_K, 2), 9019 }, 9020 CLASSIC | FLAG_NO_DATA, 9021 {}, 9022 { { 0, 2 } }, 9023 }, 9024 /* Exhaustive test of ALU64 shift operations */ 9025 { 9026 "ALU64_LSH_K: all shift values", 9027 { }, 9028 INTERNAL | FLAG_NO_DATA, 9029 { }, 9030 { { 0, 1 } }, 9031 .fill_helper = bpf_fill_alu_lsh_imm, 9032 }, 9033 { 9034 "ALU64_RSH_K: all shift values", 9035 { }, 9036 INTERNAL | FLAG_NO_DATA, 9037 { }, 9038 { { 0, 1 } }, 9039 .fill_helper = bpf_fill_alu_rsh_imm, 9040 }, 9041 { 9042 "ALU64_ARSH_K: all shift values", 9043 { }, 9044 INTERNAL | FLAG_NO_DATA, 9045 { }, 9046 { { 0, 1 } }, 9047 .fill_helper = bpf_fill_alu_arsh_imm, 9048 }, 9049 { 9050 "ALU64_LSH_X: all shift values", 9051 { }, 9052 INTERNAL | FLAG_NO_DATA, 9053 { }, 9054 { { 0, 1 } }, 9055 .fill_helper = bpf_fill_alu_lsh_reg, 9056 }, 9057 { 9058 "ALU64_RSH_X: all shift values", 9059 { }, 9060 INTERNAL | FLAG_NO_DATA, 9061 { }, 9062 { { 0, 1 } }, 9063 .fill_helper = bpf_fill_alu_rsh_reg, 9064 }, 9065 { 9066 "ALU64_ARSH_X: all shift values", 9067 { }, 9068 INTERNAL | FLAG_NO_DATA, 9069 { }, 9070 { { 0, 1 } }, 9071 .fill_helper = bpf_fill_alu_arsh_reg, 9072 }, 9073 /* Exhaustive test of ALU32 shift operations */ 9074 { 9075 "ALU32_LSH_K: all shift values", 9076 { }, 9077 INTERNAL | FLAG_NO_DATA, 9078 { }, 9079 { { 0, 1 } }, 9080 .fill_helper = bpf_fill_alu32_lsh_imm, 9081 }, 9082 { 9083 "ALU32_RSH_K: all shift values", 9084 { }, 9085 INTERNAL | FLAG_NO_DATA, 9086 { }, 9087 { { 0, 1 } }, 9088 .fill_helper = bpf_fill_alu32_rsh_imm, 9089 }, 9090 { 9091 "ALU32_ARSH_K: all shift values", 9092 { }, 9093 INTERNAL | FLAG_NO_DATA, 9094 { }, 9095 { { 0, 1 } }, 9096 .fill_helper = bpf_fill_alu32_arsh_imm, 9097 }, 9098 { 9099 "ALU32_LSH_X: all shift values", 9100 { }, 9101 INTERNAL | FLAG_NO_DATA, 9102 { }, 9103 { { 0, 1 } }, 9104 .fill_helper = bpf_fill_alu32_lsh_reg, 9105 }, 9106 { 9107 "ALU32_RSH_X: all shift values", 9108 { }, 9109 INTERNAL | FLAG_NO_DATA, 9110 { }, 9111 { { 0, 1 } }, 9112 .fill_helper = bpf_fill_alu32_rsh_reg, 9113 }, 9114 { 9115 "ALU32_ARSH_X: all shift values", 9116 { }, 9117 INTERNAL | FLAG_NO_DATA, 9118 { }, 9119 { { 0, 1 } }, 9120 .fill_helper = bpf_fill_alu32_arsh_reg, 9121 }, 9122 /* ALU64 immediate magnitudes */ 9123 { 9124 "ALU64_MOV_K: all immediate value magnitudes", 9125 { }, 9126 INTERNAL | FLAG_NO_DATA, 9127 { }, 9128 { { 0, 1 } }, 9129 .fill_helper = bpf_fill_alu64_mov_imm, 9130 .nr_testruns = NR_PATTERN_RUNS, 9131 }, 9132 { 9133 "ALU64_AND_K: all immediate value magnitudes", 9134 { }, 9135 INTERNAL | FLAG_NO_DATA, 9136 { }, 9137 { { 0, 1 } }, 9138 .fill_helper = bpf_fill_alu64_and_imm, 9139 .nr_testruns = NR_PATTERN_RUNS, 9140 }, 9141 { 9142 "ALU64_OR_K: all immediate value magnitudes", 9143 { }, 9144 INTERNAL | FLAG_NO_DATA, 9145 { }, 9146 { { 0, 1 } }, 9147 .fill_helper = bpf_fill_alu64_or_imm, 9148 .nr_testruns = NR_PATTERN_RUNS, 9149 }, 9150 { 9151 "ALU64_XOR_K: all immediate value magnitudes", 9152 { }, 9153 INTERNAL | FLAG_NO_DATA, 9154 { }, 9155 { { 0, 1 } }, 9156 .fill_helper = bpf_fill_alu64_xor_imm, 9157 .nr_testruns = NR_PATTERN_RUNS, 9158 }, 9159 { 9160 "ALU64_ADD_K: all immediate value magnitudes", 9161 { }, 9162 INTERNAL | FLAG_NO_DATA, 9163 { }, 9164 { { 0, 1 } }, 9165 .fill_helper = bpf_fill_alu64_add_imm, 9166 .nr_testruns = NR_PATTERN_RUNS, 9167 }, 9168 { 9169 "ALU64_SUB_K: all immediate value magnitudes", 9170 { }, 9171 INTERNAL | FLAG_NO_DATA, 9172 { }, 9173 { { 0, 1 } }, 9174 .fill_helper = bpf_fill_alu64_sub_imm, 9175 .nr_testruns = NR_PATTERN_RUNS, 9176 }, 9177 { 9178 "ALU64_MUL_K: all immediate value magnitudes", 9179 { }, 9180 INTERNAL | FLAG_NO_DATA, 9181 { }, 9182 { { 0, 1 } }, 9183 .fill_helper = bpf_fill_alu64_mul_imm, 9184 .nr_testruns = NR_PATTERN_RUNS, 9185 }, 9186 { 9187 "ALU64_DIV_K: all immediate value magnitudes", 9188 { }, 9189 INTERNAL | FLAG_NO_DATA, 9190 { }, 9191 { { 0, 1 } }, 9192 .fill_helper = bpf_fill_alu64_div_imm, 9193 .nr_testruns = NR_PATTERN_RUNS, 9194 }, 9195 { 9196 "ALU64_MOD_K: all immediate value magnitudes", 9197 { }, 9198 INTERNAL | FLAG_NO_DATA, 9199 { }, 9200 { { 0, 1 } }, 9201 .fill_helper = bpf_fill_alu64_mod_imm, 9202 .nr_testruns = NR_PATTERN_RUNS, 9203 }, 9204 /* ALU32 immediate magnitudes */ 9205 { 9206 "ALU32_MOV_K: all immediate value magnitudes", 9207 { }, 9208 INTERNAL | FLAG_NO_DATA, 9209 { }, 9210 { { 0, 1 } }, 9211 .fill_helper = bpf_fill_alu32_mov_imm, 9212 .nr_testruns = NR_PATTERN_RUNS, 9213 }, 9214 { 9215 "ALU32_AND_K: all immediate value magnitudes", 9216 { }, 9217 INTERNAL | FLAG_NO_DATA, 9218 { }, 9219 { { 0, 1 } }, 9220 .fill_helper = bpf_fill_alu32_and_imm, 9221 .nr_testruns = NR_PATTERN_RUNS, 9222 }, 9223 { 9224 "ALU32_OR_K: all immediate value magnitudes", 9225 { }, 9226 INTERNAL | FLAG_NO_DATA, 9227 { }, 9228 { { 0, 1 } }, 9229 .fill_helper = bpf_fill_alu32_or_imm, 9230 .nr_testruns = NR_PATTERN_RUNS, 9231 }, 9232 { 9233 "ALU32_XOR_K: all immediate value magnitudes", 9234 { }, 9235 INTERNAL | FLAG_NO_DATA, 9236 { }, 9237 { { 0, 1 } }, 9238 .fill_helper = bpf_fill_alu32_xor_imm, 9239 .nr_testruns = NR_PATTERN_RUNS, 9240 }, 9241 { 9242 "ALU32_ADD_K: all immediate value magnitudes", 9243 { }, 9244 INTERNAL | FLAG_NO_DATA, 9245 { }, 9246 { { 0, 1 } }, 9247 .fill_helper = bpf_fill_alu32_add_imm, 9248 .nr_testruns = NR_PATTERN_RUNS, 9249 }, 9250 { 9251 "ALU32_SUB_K: all immediate value magnitudes", 9252 { }, 9253 INTERNAL | FLAG_NO_DATA, 9254 { }, 9255 { { 0, 1 } }, 9256 .fill_helper = bpf_fill_alu32_sub_imm, 9257 .nr_testruns = NR_PATTERN_RUNS, 9258 }, 9259 { 9260 "ALU32_MUL_K: all immediate value magnitudes", 9261 { }, 9262 INTERNAL | FLAG_NO_DATA, 9263 { }, 9264 { { 0, 1 } }, 9265 .fill_helper = bpf_fill_alu32_mul_imm, 9266 .nr_testruns = NR_PATTERN_RUNS, 9267 }, 9268 { 9269 "ALU32_DIV_K: all immediate value magnitudes", 9270 { }, 9271 INTERNAL | FLAG_NO_DATA, 9272 { }, 9273 { { 0, 1 } }, 9274 .fill_helper = bpf_fill_alu32_div_imm, 9275 .nr_testruns = NR_PATTERN_RUNS, 9276 }, 9277 { 9278 "ALU32_MOD_K: all immediate value magnitudes", 9279 { }, 9280 INTERNAL | FLAG_NO_DATA, 9281 { }, 9282 { { 0, 1 } }, 9283 .fill_helper = bpf_fill_alu32_mod_imm, 9284 }, 9285 /* ALU64 register magnitudes */ 9286 { 9287 "ALU64_MOV_X: all register value magnitudes", 9288 { }, 9289 INTERNAL | FLAG_NO_DATA, 9290 { }, 9291 { { 0, 1 } }, 9292 .fill_helper = bpf_fill_alu64_mov_reg, 9293 .nr_testruns = NR_PATTERN_RUNS, 9294 }, 9295 { 9296 "ALU64_AND_X: all register value magnitudes", 9297 { }, 9298 INTERNAL | FLAG_NO_DATA, 9299 { }, 9300 { { 0, 1 } }, 9301 .fill_helper = bpf_fill_alu64_and_reg, 9302 .nr_testruns = NR_PATTERN_RUNS, 9303 }, 9304 { 9305 "ALU64_OR_X: all register value magnitudes", 9306 { }, 9307 INTERNAL | FLAG_NO_DATA, 9308 { }, 9309 { { 0, 1 } }, 9310 .fill_helper = bpf_fill_alu64_or_reg, 9311 .nr_testruns = NR_PATTERN_RUNS, 9312 }, 9313 { 9314 "ALU64_XOR_X: all register value magnitudes", 9315 { }, 9316 INTERNAL | FLAG_NO_DATA, 9317 { }, 9318 { { 0, 1 } }, 9319 .fill_helper = bpf_fill_alu64_xor_reg, 9320 .nr_testruns = NR_PATTERN_RUNS, 9321 }, 9322 { 9323 "ALU64_ADD_X: all register value magnitudes", 9324 { }, 9325 INTERNAL | FLAG_NO_DATA, 9326 { }, 9327 { { 0, 1 } }, 9328 .fill_helper = bpf_fill_alu64_add_reg, 9329 .nr_testruns = NR_PATTERN_RUNS, 9330 }, 9331 { 9332 "ALU64_SUB_X: all register value magnitudes", 9333 { }, 9334 INTERNAL | FLAG_NO_DATA, 9335 { }, 9336 { { 0, 1 } }, 9337 .fill_helper = bpf_fill_alu64_sub_reg, 9338 .nr_testruns = NR_PATTERN_RUNS, 9339 }, 9340 { 9341 "ALU64_MUL_X: all register value magnitudes", 9342 { }, 9343 INTERNAL | FLAG_NO_DATA, 9344 { }, 9345 { { 0, 1 } }, 9346 .fill_helper = bpf_fill_alu64_mul_reg, 9347 .nr_testruns = NR_PATTERN_RUNS, 9348 }, 9349 { 9350 "ALU64_DIV_X: all register value magnitudes", 9351 { }, 9352 INTERNAL | FLAG_NO_DATA, 9353 { }, 9354 { { 0, 1 } }, 9355 .fill_helper = bpf_fill_alu64_div_reg, 9356 .nr_testruns = NR_PATTERN_RUNS, 9357 }, 9358 { 9359 "ALU64_MOD_X: all register value magnitudes", 9360 { }, 9361 INTERNAL | FLAG_NO_DATA, 9362 { }, 9363 { { 0, 1 } }, 9364 .fill_helper = bpf_fill_alu64_mod_reg, 9365 .nr_testruns = NR_PATTERN_RUNS, 9366 }, 9367 /* ALU32 register magnitudes */ 9368 { 9369 "ALU32_MOV_X: all register value magnitudes", 9370 { }, 9371 INTERNAL | FLAG_NO_DATA, 9372 { }, 9373 { { 0, 1 } }, 9374 .fill_helper = bpf_fill_alu32_mov_reg, 9375 .nr_testruns = NR_PATTERN_RUNS, 9376 }, 9377 { 9378 "ALU32_AND_X: all register value magnitudes", 9379 { }, 9380 INTERNAL | FLAG_NO_DATA, 9381 { }, 9382 { { 0, 1 } }, 9383 .fill_helper = bpf_fill_alu32_and_reg, 9384 .nr_testruns = NR_PATTERN_RUNS, 9385 }, 9386 { 9387 "ALU32_OR_X: all register value magnitudes", 9388 { }, 9389 INTERNAL | FLAG_NO_DATA, 9390 { }, 9391 { { 0, 1 } }, 9392 .fill_helper = bpf_fill_alu32_or_reg, 9393 .nr_testruns = NR_PATTERN_RUNS, 9394 }, 9395 { 9396 "ALU32_XOR_X: all register value magnitudes", 9397 { }, 9398 INTERNAL | FLAG_NO_DATA, 9399 { }, 9400 { { 0, 1 } }, 9401 .fill_helper = bpf_fill_alu32_xor_reg, 9402 .nr_testruns = NR_PATTERN_RUNS, 9403 }, 9404 { 9405 "ALU32_ADD_X: all register value magnitudes", 9406 { }, 9407 INTERNAL | FLAG_NO_DATA, 9408 { }, 9409 { { 0, 1 } }, 9410 .fill_helper = bpf_fill_alu32_add_reg, 9411 .nr_testruns = NR_PATTERN_RUNS, 9412 }, 9413 { 9414 "ALU32_SUB_X: all register value magnitudes", 9415 { }, 9416 INTERNAL | FLAG_NO_DATA, 9417 { }, 9418 { { 0, 1 } }, 9419 .fill_helper = bpf_fill_alu32_sub_reg, 9420 .nr_testruns = NR_PATTERN_RUNS, 9421 }, 9422 { 9423 "ALU32_MUL_X: all register value magnitudes", 9424 { }, 9425 INTERNAL | FLAG_NO_DATA, 9426 { }, 9427 { { 0, 1 } }, 9428 .fill_helper = bpf_fill_alu32_mul_reg, 9429 .nr_testruns = NR_PATTERN_RUNS, 9430 }, 9431 { 9432 "ALU32_DIV_X: all register value magnitudes", 9433 { }, 9434 INTERNAL | FLAG_NO_DATA, 9435 { }, 9436 { { 0, 1 } }, 9437 .fill_helper = bpf_fill_alu32_div_reg, 9438 .nr_testruns = NR_PATTERN_RUNS, 9439 }, 9440 { 9441 "ALU32_MOD_X: all register value magnitudes", 9442 { }, 9443 INTERNAL | FLAG_NO_DATA, 9444 { }, 9445 { { 0, 1 } }, 9446 .fill_helper = bpf_fill_alu32_mod_reg, 9447 .nr_testruns = NR_PATTERN_RUNS, 9448 }, 9449 }; 9450 9451 static struct net_device dev; 9452 9453 static struct sk_buff *populate_skb(char *buf, int size) 9454 { 9455 struct sk_buff *skb; 9456 9457 if (size >= MAX_DATA) 9458 return NULL; 9459 9460 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 9461 if (!skb) 9462 return NULL; 9463 9464 __skb_put_data(skb, buf, size); 9465 9466 /* Initialize a fake skb with test pattern. */ 9467 skb_reset_mac_header(skb); 9468 skb->protocol = htons(ETH_P_IP); 9469 skb->pkt_type = SKB_TYPE; 9470 skb->mark = SKB_MARK; 9471 skb->hash = SKB_HASH; 9472 skb->queue_mapping = SKB_QUEUE_MAP; 9473 skb->vlan_tci = SKB_VLAN_TCI; 9474 skb->vlan_present = SKB_VLAN_PRESENT; 9475 skb->vlan_proto = htons(ETH_P_IP); 9476 dev_net_set(&dev, &init_net); 9477 skb->dev = &dev; 9478 skb->dev->ifindex = SKB_DEV_IFINDEX; 9479 skb->dev->type = SKB_DEV_TYPE; 9480 skb_set_network_header(skb, min(size, ETH_HLEN)); 9481 9482 return skb; 9483 } 9484 9485 static void *generate_test_data(struct bpf_test *test, int sub) 9486 { 9487 struct sk_buff *skb; 9488 struct page *page; 9489 9490 if (test->aux & FLAG_NO_DATA) 9491 return NULL; 9492 9493 /* Test case expects an skb, so populate one. Various 9494 * subtests generate skbs of different sizes based on 9495 * the same data. 9496 */ 9497 skb = populate_skb(test->data, test->test[sub].data_size); 9498 if (!skb) 9499 return NULL; 9500 9501 if (test->aux & FLAG_SKB_FRAG) { 9502 /* 9503 * when the test requires a fragmented skb, add a 9504 * single fragment to the skb, filled with 9505 * test->frag_data. 9506 */ 9507 void *ptr; 9508 9509 page = alloc_page(GFP_KERNEL); 9510 9511 if (!page) 9512 goto err_kfree_skb; 9513 9514 ptr = kmap(page); 9515 if (!ptr) 9516 goto err_free_page; 9517 memcpy(ptr, test->frag_data, MAX_DATA); 9518 kunmap(page); 9519 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA); 9520 } 9521 9522 return skb; 9523 9524 err_free_page: 9525 __free_page(page); 9526 err_kfree_skb: 9527 kfree_skb(skb); 9528 return NULL; 9529 } 9530 9531 static void release_test_data(const struct bpf_test *test, void *data) 9532 { 9533 if (test->aux & FLAG_NO_DATA) 9534 return; 9535 9536 kfree_skb(data); 9537 } 9538 9539 static int filter_length(int which) 9540 { 9541 struct sock_filter *fp; 9542 int len; 9543 9544 if (tests[which].fill_helper) 9545 return tests[which].u.ptr.len; 9546 9547 fp = tests[which].u.insns; 9548 for (len = MAX_INSNS - 1; len > 0; --len) 9549 if (fp[len].code != 0 || fp[len].k != 0) 9550 break; 9551 9552 return len + 1; 9553 } 9554 9555 static void *filter_pointer(int which) 9556 { 9557 if (tests[which].fill_helper) 9558 return tests[which].u.ptr.insns; 9559 else 9560 return tests[which].u.insns; 9561 } 9562 9563 static struct bpf_prog *generate_filter(int which, int *err) 9564 { 9565 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 9566 unsigned int flen = filter_length(which); 9567 void *fptr = filter_pointer(which); 9568 struct sock_fprog_kern fprog; 9569 struct bpf_prog *fp; 9570 9571 switch (test_type) { 9572 case CLASSIC: 9573 fprog.filter = fptr; 9574 fprog.len = flen; 9575 9576 *err = bpf_prog_create(&fp, &fprog); 9577 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 9578 if (*err == tests[which].expected_errcode) { 9579 pr_cont("PASS\n"); 9580 /* Verifier rejected filter as expected. */ 9581 *err = 0; 9582 return NULL; 9583 } else { 9584 pr_cont("UNEXPECTED_PASS\n"); 9585 /* Verifier didn't reject the test that's 9586 * bad enough, just return! 9587 */ 9588 *err = -EINVAL; 9589 return NULL; 9590 } 9591 } 9592 if (*err) { 9593 pr_cont("FAIL to prog_create err=%d len=%d\n", 9594 *err, fprog.len); 9595 return NULL; 9596 } 9597 break; 9598 9599 case INTERNAL: 9600 fp = bpf_prog_alloc(bpf_prog_size(flen), 0); 9601 if (fp == NULL) { 9602 pr_cont("UNEXPECTED_FAIL no memory left\n"); 9603 *err = -ENOMEM; 9604 return NULL; 9605 } 9606 9607 fp->len = flen; 9608 /* Type doesn't really matter here as long as it's not unspec. */ 9609 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 9610 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn)); 9611 fp->aux->stack_depth = tests[which].stack_depth; 9612 9613 /* We cannot error here as we don't need type compatibility 9614 * checks. 9615 */ 9616 fp = bpf_prog_select_runtime(fp, err); 9617 if (*err) { 9618 pr_cont("FAIL to select_runtime err=%d\n", *err); 9619 return NULL; 9620 } 9621 break; 9622 } 9623 9624 *err = 0; 9625 return fp; 9626 } 9627 9628 static void release_filter(struct bpf_prog *fp, int which) 9629 { 9630 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 9631 9632 switch (test_type) { 9633 case CLASSIC: 9634 bpf_prog_destroy(fp); 9635 break; 9636 case INTERNAL: 9637 bpf_prog_free(fp); 9638 break; 9639 } 9640 } 9641 9642 static int __run_one(const struct bpf_prog *fp, const void *data, 9643 int runs, u64 *duration) 9644 { 9645 u64 start, finish; 9646 int ret = 0, i; 9647 9648 migrate_disable(); 9649 start = ktime_get_ns(); 9650 9651 for (i = 0; i < runs; i++) 9652 ret = bpf_prog_run(fp, data); 9653 9654 finish = ktime_get_ns(); 9655 migrate_enable(); 9656 9657 *duration = finish - start; 9658 do_div(*duration, runs); 9659 9660 return ret; 9661 } 9662 9663 static int run_one(const struct bpf_prog *fp, struct bpf_test *test) 9664 { 9665 int err_cnt = 0, i, runs = MAX_TESTRUNS; 9666 9667 if (test->nr_testruns) 9668 runs = min(test->nr_testruns, MAX_TESTRUNS); 9669 9670 for (i = 0; i < MAX_SUBTESTS; i++) { 9671 void *data; 9672 u64 duration; 9673 u32 ret; 9674 9675 /* 9676 * NOTE: Several sub-tests may be present, in which case 9677 * a zero {data_size, result} tuple indicates the end of 9678 * the sub-test array. The first test is always run, 9679 * even if both data_size and result happen to be zero. 9680 */ 9681 if (i > 0 && 9682 test->test[i].data_size == 0 && 9683 test->test[i].result == 0) 9684 break; 9685 9686 data = generate_test_data(test, i); 9687 if (!data && !(test->aux & FLAG_NO_DATA)) { 9688 pr_cont("data generation failed "); 9689 err_cnt++; 9690 break; 9691 } 9692 ret = __run_one(fp, data, runs, &duration); 9693 release_test_data(test, data); 9694 9695 if (ret == test->test[i].result) { 9696 pr_cont("%lld ", duration); 9697 } else { 9698 pr_cont("ret %d != %d ", ret, 9699 test->test[i].result); 9700 err_cnt++; 9701 } 9702 } 9703 9704 return err_cnt; 9705 } 9706 9707 static char test_name[64]; 9708 module_param_string(test_name, test_name, sizeof(test_name), 0); 9709 9710 static int test_id = -1; 9711 module_param(test_id, int, 0); 9712 9713 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 }; 9714 module_param_array(test_range, int, NULL, 0); 9715 9716 static __init int find_test_index(const char *test_name) 9717 { 9718 int i; 9719 9720 for (i = 0; i < ARRAY_SIZE(tests); i++) { 9721 if (!strcmp(tests[i].descr, test_name)) 9722 return i; 9723 } 9724 return -1; 9725 } 9726 9727 static __init int prepare_bpf_tests(void) 9728 { 9729 if (test_id >= 0) { 9730 /* 9731 * if a test_id was specified, use test_range to 9732 * cover only that test. 9733 */ 9734 if (test_id >= ARRAY_SIZE(tests)) { 9735 pr_err("test_bpf: invalid test_id specified.\n"); 9736 return -EINVAL; 9737 } 9738 9739 test_range[0] = test_id; 9740 test_range[1] = test_id; 9741 } else if (*test_name) { 9742 /* 9743 * if a test_name was specified, find it and setup 9744 * test_range to cover only that test. 9745 */ 9746 int idx = find_test_index(test_name); 9747 9748 if (idx < 0) { 9749 pr_err("test_bpf: no test named '%s' found.\n", 9750 test_name); 9751 return -EINVAL; 9752 } 9753 test_range[0] = idx; 9754 test_range[1] = idx; 9755 } else { 9756 /* 9757 * check that the supplied test_range is valid. 9758 */ 9759 if (test_range[0] >= ARRAY_SIZE(tests) || 9760 test_range[1] >= ARRAY_SIZE(tests) || 9761 test_range[0] < 0 || test_range[1] < 0) { 9762 pr_err("test_bpf: test_range is out of bound.\n"); 9763 return -EINVAL; 9764 } 9765 9766 if (test_range[1] < test_range[0]) { 9767 pr_err("test_bpf: test_range is ending before it starts.\n"); 9768 return -EINVAL; 9769 } 9770 } 9771 9772 return 0; 9773 } 9774 9775 static __init void destroy_bpf_tests(void) 9776 { 9777 } 9778 9779 static bool exclude_test(int test_id) 9780 { 9781 return test_id < test_range[0] || test_id > test_range[1]; 9782 } 9783 9784 static __init struct sk_buff *build_test_skb(void) 9785 { 9786 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN; 9787 struct sk_buff *skb[2]; 9788 struct page *page[2]; 9789 int i, data_size = 8; 9790 9791 for (i = 0; i < 2; i++) { 9792 page[i] = alloc_page(GFP_KERNEL); 9793 if (!page[i]) { 9794 if (i == 0) 9795 goto err_page0; 9796 else 9797 goto err_page1; 9798 } 9799 9800 /* this will set skb[i]->head_frag */ 9801 skb[i] = dev_alloc_skb(headroom + data_size); 9802 if (!skb[i]) { 9803 if (i == 0) 9804 goto err_skb0; 9805 else 9806 goto err_skb1; 9807 } 9808 9809 skb_reserve(skb[i], headroom); 9810 skb_put(skb[i], data_size); 9811 skb[i]->protocol = htons(ETH_P_IP); 9812 skb_reset_network_header(skb[i]); 9813 skb_set_mac_header(skb[i], -ETH_HLEN); 9814 9815 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64); 9816 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1 9817 } 9818 9819 /* setup shinfo */ 9820 skb_shinfo(skb[0])->gso_size = 1448; 9821 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4; 9822 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY; 9823 skb_shinfo(skb[0])->gso_segs = 0; 9824 skb_shinfo(skb[0])->frag_list = skb[1]; 9825 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000; 9826 9827 /* adjust skb[0]'s len */ 9828 skb[0]->len += skb[1]->len; 9829 skb[0]->data_len += skb[1]->data_len; 9830 skb[0]->truesize += skb[1]->truesize; 9831 9832 return skb[0]; 9833 9834 err_skb1: 9835 __free_page(page[1]); 9836 err_page1: 9837 kfree_skb(skb[0]); 9838 err_skb0: 9839 __free_page(page[0]); 9840 err_page0: 9841 return NULL; 9842 } 9843 9844 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void) 9845 { 9846 unsigned int alloc_size = 2000; 9847 unsigned int headroom = 102, doffset = 72, data_size = 1308; 9848 struct sk_buff *skb[2]; 9849 int i; 9850 9851 /* skbs linked in a frag_list, both with linear data, with head_frag=0 9852 * (data allocated by kmalloc), both have tcp data of 1308 bytes 9853 * (total payload is 2616 bytes). 9854 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom. 9855 */ 9856 for (i = 0; i < 2; i++) { 9857 skb[i] = alloc_skb(alloc_size, GFP_KERNEL); 9858 if (!skb[i]) { 9859 if (i == 0) 9860 goto err_skb0; 9861 else 9862 goto err_skb1; 9863 } 9864 9865 skb[i]->protocol = htons(ETH_P_IPV6); 9866 skb_reserve(skb[i], headroom); 9867 skb_put(skb[i], doffset + data_size); 9868 skb_reset_network_header(skb[i]); 9869 if (i == 0) 9870 skb_reset_mac_header(skb[i]); 9871 else 9872 skb_set_mac_header(skb[i], -ETH_HLEN); 9873 __skb_pull(skb[i], doffset); 9874 } 9875 9876 /* setup shinfo. 9877 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a 9878 * reduced gso_size. 9879 */ 9880 skb_shinfo(skb[0])->gso_size = 1288; 9881 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY; 9882 skb_shinfo(skb[0])->gso_segs = 0; 9883 skb_shinfo(skb[0])->frag_list = skb[1]; 9884 9885 /* adjust skb[0]'s len */ 9886 skb[0]->len += skb[1]->len; 9887 skb[0]->data_len += skb[1]->len; 9888 skb[0]->truesize += skb[1]->truesize; 9889 9890 return skb[0]; 9891 9892 err_skb1: 9893 kfree_skb(skb[0]); 9894 err_skb0: 9895 return NULL; 9896 } 9897 9898 struct skb_segment_test { 9899 const char *descr; 9900 struct sk_buff *(*build_skb)(void); 9901 netdev_features_t features; 9902 }; 9903 9904 static struct skb_segment_test skb_segment_tests[] __initconst = { 9905 { 9906 .descr = "gso_with_rx_frags", 9907 .build_skb = build_test_skb, 9908 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM | 9909 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM 9910 }, 9911 { 9912 .descr = "gso_linear_no_head_frag", 9913 .build_skb = build_test_skb_linear_no_head_frag, 9914 .features = NETIF_F_SG | NETIF_F_FRAGLIST | 9915 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO | 9916 NETIF_F_LLTX_BIT | NETIF_F_GRO | 9917 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM | 9918 NETIF_F_HW_VLAN_STAG_TX_BIT 9919 } 9920 }; 9921 9922 static __init int test_skb_segment_single(const struct skb_segment_test *test) 9923 { 9924 struct sk_buff *skb, *segs; 9925 int ret = -1; 9926 9927 skb = test->build_skb(); 9928 if (!skb) { 9929 pr_info("%s: failed to build_test_skb", __func__); 9930 goto done; 9931 } 9932 9933 segs = skb_segment(skb, test->features); 9934 if (!IS_ERR(segs)) { 9935 kfree_skb_list(segs); 9936 ret = 0; 9937 } 9938 kfree_skb(skb); 9939 done: 9940 return ret; 9941 } 9942 9943 static __init int test_skb_segment(void) 9944 { 9945 int i, err_cnt = 0, pass_cnt = 0; 9946 9947 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) { 9948 const struct skb_segment_test *test = &skb_segment_tests[i]; 9949 9950 pr_info("#%d %s ", i, test->descr); 9951 9952 if (test_skb_segment_single(test)) { 9953 pr_cont("FAIL\n"); 9954 err_cnt++; 9955 } else { 9956 pr_cont("PASS\n"); 9957 pass_cnt++; 9958 } 9959 } 9960 9961 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__, 9962 pass_cnt, err_cnt); 9963 return err_cnt ? -EINVAL : 0; 9964 } 9965 9966 static __init int test_bpf(void) 9967 { 9968 int i, err_cnt = 0, pass_cnt = 0; 9969 int jit_cnt = 0, run_cnt = 0; 9970 9971 for (i = 0; i < ARRAY_SIZE(tests); i++) { 9972 struct bpf_prog *fp; 9973 int err; 9974 9975 cond_resched(); 9976 if (exclude_test(i)) 9977 continue; 9978 9979 pr_info("#%d %s ", i, tests[i].descr); 9980 9981 if (tests[i].fill_helper && 9982 tests[i].fill_helper(&tests[i]) < 0) { 9983 pr_cont("FAIL to prog_fill\n"); 9984 continue; 9985 } 9986 9987 fp = generate_filter(i, &err); 9988 9989 if (tests[i].fill_helper) { 9990 kfree(tests[i].u.ptr.insns); 9991 tests[i].u.ptr.insns = NULL; 9992 } 9993 9994 if (fp == NULL) { 9995 if (err == 0) { 9996 pass_cnt++; 9997 continue; 9998 } 9999 err_cnt++; 10000 continue; 10001 } 10002 10003 pr_cont("jited:%u ", fp->jited); 10004 10005 run_cnt++; 10006 if (fp->jited) 10007 jit_cnt++; 10008 10009 err = run_one(fp, &tests[i]); 10010 release_filter(fp, i); 10011 10012 if (err) { 10013 pr_cont("FAIL (%d times)\n", err); 10014 err_cnt++; 10015 } else { 10016 pr_cont("PASS\n"); 10017 pass_cnt++; 10018 } 10019 } 10020 10021 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 10022 pass_cnt, err_cnt, jit_cnt, run_cnt); 10023 10024 return err_cnt ? -EINVAL : 0; 10025 } 10026 10027 struct tail_call_test { 10028 const char *descr; 10029 struct bpf_insn insns[MAX_INSNS]; 10030 int result; 10031 int stack_depth; 10032 }; 10033 10034 /* 10035 * Magic marker used in test snippets for tail calls below. 10036 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced 10037 * with the proper values by the test runner. 10038 */ 10039 #define TAIL_CALL_MARKER 0x7a11ca11 10040 10041 /* Special offset to indicate a NULL call target */ 10042 #define TAIL_CALL_NULL 0x7fff 10043 10044 /* Special offset to indicate an out-of-range index */ 10045 #define TAIL_CALL_INVALID 0x7ffe 10046 10047 #define TAIL_CALL(offset) \ 10048 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \ 10049 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \ 10050 offset, TAIL_CALL_MARKER), \ 10051 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0) 10052 10053 /* 10054 * Tail call tests. Each test case may call any other test in the table, 10055 * including itself, specified as a relative index offset from the calling 10056 * test. The index TAIL_CALL_NULL can be used to specify a NULL target 10057 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID 10058 * results in a target index that is out of range. 10059 */ 10060 static struct tail_call_test tail_call_tests[] = { 10061 { 10062 "Tail call leaf", 10063 .insns = { 10064 BPF_ALU64_REG(BPF_MOV, R0, R1), 10065 BPF_ALU64_IMM(BPF_ADD, R0, 1), 10066 BPF_EXIT_INSN(), 10067 }, 10068 .result = 1, 10069 }, 10070 { 10071 "Tail call 2", 10072 .insns = { 10073 BPF_ALU64_IMM(BPF_ADD, R1, 2), 10074 TAIL_CALL(-1), 10075 BPF_ALU64_IMM(BPF_MOV, R0, -1), 10076 BPF_EXIT_INSN(), 10077 }, 10078 .result = 3, 10079 }, 10080 { 10081 "Tail call 3", 10082 .insns = { 10083 BPF_ALU64_IMM(BPF_ADD, R1, 3), 10084 TAIL_CALL(-1), 10085 BPF_ALU64_IMM(BPF_MOV, R0, -1), 10086 BPF_EXIT_INSN(), 10087 }, 10088 .result = 6, 10089 }, 10090 { 10091 "Tail call 4", 10092 .insns = { 10093 BPF_ALU64_IMM(BPF_ADD, R1, 4), 10094 TAIL_CALL(-1), 10095 BPF_ALU64_IMM(BPF_MOV, R0, -1), 10096 BPF_EXIT_INSN(), 10097 }, 10098 .result = 10, 10099 }, 10100 { 10101 "Tail call error path, max count reached", 10102 .insns = { 10103 BPF_ALU64_IMM(BPF_ADD, R1, 1), 10104 BPF_ALU64_REG(BPF_MOV, R0, R1), 10105 TAIL_CALL(0), 10106 BPF_EXIT_INSN(), 10107 }, 10108 .result = MAX_TAIL_CALL_CNT + 1, 10109 }, 10110 { 10111 "Tail call error path, NULL target", 10112 .insns = { 10113 BPF_ALU64_IMM(BPF_MOV, R0, -1), 10114 TAIL_CALL(TAIL_CALL_NULL), 10115 BPF_ALU64_IMM(BPF_MOV, R0, 1), 10116 BPF_EXIT_INSN(), 10117 }, 10118 .result = 1, 10119 }, 10120 { 10121 "Tail call error path, index out of range", 10122 .insns = { 10123 BPF_ALU64_IMM(BPF_MOV, R0, -1), 10124 TAIL_CALL(TAIL_CALL_INVALID), 10125 BPF_ALU64_IMM(BPF_MOV, R0, 1), 10126 BPF_EXIT_INSN(), 10127 }, 10128 .result = 1, 10129 }, 10130 }; 10131 10132 static void __init destroy_tail_call_tests(struct bpf_array *progs) 10133 { 10134 int i; 10135 10136 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) 10137 if (progs->ptrs[i]) 10138 bpf_prog_free(progs->ptrs[i]); 10139 kfree(progs); 10140 } 10141 10142 static __init int prepare_tail_call_tests(struct bpf_array **pprogs) 10143 { 10144 int ntests = ARRAY_SIZE(tail_call_tests); 10145 struct bpf_array *progs; 10146 int which, err; 10147 10148 /* Allocate the table of programs to be used for tall calls */ 10149 progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]), 10150 GFP_KERNEL); 10151 if (!progs) 10152 goto out_nomem; 10153 10154 /* Create all eBPF programs and populate the table */ 10155 for (which = 0; which < ntests; which++) { 10156 struct tail_call_test *test = &tail_call_tests[which]; 10157 struct bpf_prog *fp; 10158 int len, i; 10159 10160 /* Compute the number of program instructions */ 10161 for (len = 0; len < MAX_INSNS; len++) { 10162 struct bpf_insn *insn = &test->insns[len]; 10163 10164 if (len < MAX_INSNS - 1 && 10165 insn->code == (BPF_LD | BPF_DW | BPF_IMM)) 10166 len++; 10167 if (insn->code == 0) 10168 break; 10169 } 10170 10171 /* Allocate and initialize the program */ 10172 fp = bpf_prog_alloc(bpf_prog_size(len), 0); 10173 if (!fp) 10174 goto out_nomem; 10175 10176 fp->len = len; 10177 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 10178 fp->aux->stack_depth = test->stack_depth; 10179 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn)); 10180 10181 /* Relocate runtime tail call offsets and addresses */ 10182 for (i = 0; i < len; i++) { 10183 struct bpf_insn *insn = &fp->insnsi[i]; 10184 10185 if (insn->imm != TAIL_CALL_MARKER) 10186 continue; 10187 10188 switch (insn->code) { 10189 case BPF_LD | BPF_DW | BPF_IMM: 10190 insn[0].imm = (u32)(long)progs; 10191 insn[1].imm = ((u64)(long)progs) >> 32; 10192 break; 10193 10194 case BPF_ALU | BPF_MOV | BPF_K: 10195 if (insn->off == TAIL_CALL_NULL) 10196 insn->imm = ntests; 10197 else if (insn->off == TAIL_CALL_INVALID) 10198 insn->imm = ntests + 1; 10199 else 10200 insn->imm = which + insn->off; 10201 insn->off = 0; 10202 } 10203 } 10204 10205 fp = bpf_prog_select_runtime(fp, &err); 10206 if (err) 10207 goto out_err; 10208 10209 progs->ptrs[which] = fp; 10210 } 10211 10212 /* The last entry contains a NULL program pointer */ 10213 progs->map.max_entries = ntests + 1; 10214 *pprogs = progs; 10215 return 0; 10216 10217 out_nomem: 10218 err = -ENOMEM; 10219 10220 out_err: 10221 if (progs) 10222 destroy_tail_call_tests(progs); 10223 return err; 10224 } 10225 10226 static __init int test_tail_calls(struct bpf_array *progs) 10227 { 10228 int i, err_cnt = 0, pass_cnt = 0; 10229 int jit_cnt = 0, run_cnt = 0; 10230 10231 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) { 10232 struct tail_call_test *test = &tail_call_tests[i]; 10233 struct bpf_prog *fp = progs->ptrs[i]; 10234 u64 duration; 10235 int ret; 10236 10237 cond_resched(); 10238 10239 pr_info("#%d %s ", i, test->descr); 10240 if (!fp) { 10241 err_cnt++; 10242 continue; 10243 } 10244 pr_cont("jited:%u ", fp->jited); 10245 10246 run_cnt++; 10247 if (fp->jited) 10248 jit_cnt++; 10249 10250 ret = __run_one(fp, NULL, MAX_TESTRUNS, &duration); 10251 if (ret == test->result) { 10252 pr_cont("%lld PASS", duration); 10253 pass_cnt++; 10254 } else { 10255 pr_cont("ret %d != %d FAIL", ret, test->result); 10256 err_cnt++; 10257 } 10258 } 10259 10260 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 10261 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt); 10262 10263 return err_cnt ? -EINVAL : 0; 10264 } 10265 10266 static int __init test_bpf_init(void) 10267 { 10268 struct bpf_array *progs = NULL; 10269 int ret; 10270 10271 ret = prepare_bpf_tests(); 10272 if (ret < 0) 10273 return ret; 10274 10275 ret = test_bpf(); 10276 destroy_bpf_tests(); 10277 if (ret) 10278 return ret; 10279 10280 ret = prepare_tail_call_tests(&progs); 10281 if (ret) 10282 return ret; 10283 ret = test_tail_calls(progs); 10284 destroy_tail_call_tests(progs); 10285 if (ret) 10286 return ret; 10287 10288 return test_skb_segment(); 10289 } 10290 10291 static void __exit test_bpf_exit(void) 10292 { 10293 } 10294 10295 module_init(test_bpf_init); 10296 module_exit(test_bpf_exit); 10297 10298 MODULE_LICENSE("GPL"); 10299