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 #define FLAG_VERIFIER_ZEXT BIT(3) 56 57 enum { 58 CLASSIC = BIT(6), /* Old BPF instructions only. */ 59 INTERNAL = BIT(7), /* Extended instruction set. */ 60 }; 61 62 #define TEST_TYPE_MASK (CLASSIC | INTERNAL) 63 64 struct bpf_test { 65 const char *descr; 66 union { 67 struct sock_filter insns[MAX_INSNS]; 68 struct bpf_insn insns_int[MAX_INSNS]; 69 struct { 70 void *insns; 71 unsigned int len; 72 } ptr; 73 } u; 74 __u8 aux; 75 __u8 data[MAX_DATA]; 76 struct { 77 int data_size; 78 __u32 result; 79 } test[MAX_SUBTESTS]; 80 int (*fill_helper)(struct bpf_test *self); 81 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */ 82 __u8 frag_data[MAX_DATA]; 83 int stack_depth; /* for eBPF only, since tests don't call verifier */ 84 int nr_testruns; /* Custom run count, defaults to MAX_TESTRUNS if 0 */ 85 }; 86 87 /* Large test cases need separate allocation and fill handler. */ 88 89 static int bpf_fill_maxinsns1(struct bpf_test *self) 90 { 91 unsigned int len = BPF_MAXINSNS; 92 struct sock_filter *insn; 93 __u32 k = ~0; 94 int i; 95 96 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 97 if (!insn) 98 return -ENOMEM; 99 100 for (i = 0; i < len; i++, k--) 101 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k); 102 103 self->u.ptr.insns = insn; 104 self->u.ptr.len = len; 105 106 return 0; 107 } 108 109 static int bpf_fill_maxinsns2(struct bpf_test *self) 110 { 111 unsigned int len = BPF_MAXINSNS; 112 struct sock_filter *insn; 113 int i; 114 115 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 116 if (!insn) 117 return -ENOMEM; 118 119 for (i = 0; i < len; i++) 120 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 121 122 self->u.ptr.insns = insn; 123 self->u.ptr.len = len; 124 125 return 0; 126 } 127 128 static int bpf_fill_maxinsns3(struct bpf_test *self) 129 { 130 unsigned int len = BPF_MAXINSNS; 131 struct sock_filter *insn; 132 struct rnd_state rnd; 133 int i; 134 135 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 136 if (!insn) 137 return -ENOMEM; 138 139 prandom_seed_state(&rnd, 3141592653589793238ULL); 140 141 for (i = 0; i < len - 1; i++) { 142 __u32 k = prandom_u32_state(&rnd); 143 144 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k); 145 } 146 147 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 148 149 self->u.ptr.insns = insn; 150 self->u.ptr.len = len; 151 152 return 0; 153 } 154 155 static int bpf_fill_maxinsns4(struct bpf_test *self) 156 { 157 unsigned int len = BPF_MAXINSNS + 1; 158 struct sock_filter *insn; 159 int i; 160 161 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 162 if (!insn) 163 return -ENOMEM; 164 165 for (i = 0; i < len; i++) 166 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 167 168 self->u.ptr.insns = insn; 169 self->u.ptr.len = len; 170 171 return 0; 172 } 173 174 static int bpf_fill_maxinsns5(struct bpf_test *self) 175 { 176 unsigned int len = BPF_MAXINSNS; 177 struct sock_filter *insn; 178 int i; 179 180 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 181 if (!insn) 182 return -ENOMEM; 183 184 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 185 186 for (i = 1; i < len - 1; i++) 187 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 188 189 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 190 191 self->u.ptr.insns = insn; 192 self->u.ptr.len = len; 193 194 return 0; 195 } 196 197 static int bpf_fill_maxinsns6(struct bpf_test *self) 198 { 199 unsigned int len = BPF_MAXINSNS; 200 struct sock_filter *insn; 201 int i; 202 203 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 204 if (!insn) 205 return -ENOMEM; 206 207 for (i = 0; i < len - 1; i++) 208 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 209 SKF_AD_VLAN_TAG_PRESENT); 210 211 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 212 213 self->u.ptr.insns = insn; 214 self->u.ptr.len = len; 215 216 return 0; 217 } 218 219 static int bpf_fill_maxinsns7(struct bpf_test *self) 220 { 221 unsigned int len = BPF_MAXINSNS; 222 struct sock_filter *insn; 223 int i; 224 225 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 226 if (!insn) 227 return -ENOMEM; 228 229 for (i = 0; i < len - 4; i++) 230 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 231 SKF_AD_CPU); 232 233 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0); 234 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 235 SKF_AD_CPU); 236 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0); 237 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 238 239 self->u.ptr.insns = insn; 240 self->u.ptr.len = len; 241 242 return 0; 243 } 244 245 static int bpf_fill_maxinsns8(struct bpf_test *self) 246 { 247 unsigned int len = BPF_MAXINSNS; 248 struct sock_filter *insn; 249 int i, jmp_off = len - 3; 250 251 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 252 if (!insn) 253 return -ENOMEM; 254 255 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff); 256 257 for (i = 1; i < len - 1; i++) 258 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0); 259 260 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 261 262 self->u.ptr.insns = insn; 263 self->u.ptr.len = len; 264 265 return 0; 266 } 267 268 static int bpf_fill_maxinsns9(struct bpf_test *self) 269 { 270 unsigned int len = BPF_MAXINSNS; 271 struct bpf_insn *insn; 272 int i; 273 274 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 275 if (!insn) 276 return -ENOMEM; 277 278 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2); 279 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab); 280 insn[2] = BPF_EXIT_INSN(); 281 282 for (i = 3; i < len - 2; i++) 283 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe); 284 285 insn[len - 2] = BPF_EXIT_INSN(); 286 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1)); 287 288 self->u.ptr.insns = insn; 289 self->u.ptr.len = len; 290 291 return 0; 292 } 293 294 static int bpf_fill_maxinsns10(struct bpf_test *self) 295 { 296 unsigned int len = BPF_MAXINSNS, hlen = len - 2; 297 struct bpf_insn *insn; 298 int i; 299 300 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 301 if (!insn) 302 return -ENOMEM; 303 304 for (i = 0; i < hlen / 2; i++) 305 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i); 306 for (i = hlen - 1; i > hlen / 2; i--) 307 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i); 308 309 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1); 310 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac); 311 insn[hlen + 1] = BPF_EXIT_INSN(); 312 313 self->u.ptr.insns = insn; 314 self->u.ptr.len = len; 315 316 return 0; 317 } 318 319 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len, 320 unsigned int plen) 321 { 322 struct sock_filter *insn; 323 unsigned int rlen; 324 int i, j; 325 326 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 327 if (!insn) 328 return -ENOMEM; 329 330 rlen = (len % plen) - 1; 331 332 for (i = 0; i + plen < len; i += plen) 333 for (j = 0; j < plen; j++) 334 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, 335 plen - 1 - j, 0, 0); 336 for (j = 0; j < rlen; j++) 337 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j, 338 0, 0); 339 340 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac); 341 342 self->u.ptr.insns = insn; 343 self->u.ptr.len = len; 344 345 return 0; 346 } 347 348 static int bpf_fill_maxinsns11(struct bpf_test *self) 349 { 350 /* Hits 70 passes on x86_64 and triggers NOPs padding. */ 351 return __bpf_fill_ja(self, BPF_MAXINSNS, 68); 352 } 353 354 static int bpf_fill_maxinsns12(struct bpf_test *self) 355 { 356 unsigned int len = BPF_MAXINSNS; 357 struct sock_filter *insn; 358 int i = 0; 359 360 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 361 if (!insn) 362 return -ENOMEM; 363 364 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 365 366 for (i = 1; i < len - 1; i++) 367 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 368 369 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 370 371 self->u.ptr.insns = insn; 372 self->u.ptr.len = len; 373 374 return 0; 375 } 376 377 static int bpf_fill_maxinsns13(struct bpf_test *self) 378 { 379 unsigned int len = BPF_MAXINSNS; 380 struct sock_filter *insn; 381 int i = 0; 382 383 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 384 if (!insn) 385 return -ENOMEM; 386 387 for (i = 0; i < len - 3; i++) 388 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0); 389 390 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab); 391 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0); 392 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 393 394 self->u.ptr.insns = insn; 395 self->u.ptr.len = len; 396 397 return 0; 398 } 399 400 static int bpf_fill_ja(struct bpf_test *self) 401 { 402 /* Hits exactly 11 passes on x86_64 JIT. */ 403 return __bpf_fill_ja(self, 12, 9); 404 } 405 406 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self) 407 { 408 unsigned int len = BPF_MAXINSNS; 409 struct sock_filter *insn; 410 int i; 411 412 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 413 if (!insn) 414 return -ENOMEM; 415 416 for (i = 0; i < len - 1; i += 2) { 417 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0); 418 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 419 SKF_AD_OFF + SKF_AD_CPU); 420 } 421 422 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee); 423 424 self->u.ptr.insns = insn; 425 self->u.ptr.len = len; 426 427 return 0; 428 } 429 430 static int __bpf_fill_stxdw(struct bpf_test *self, int size) 431 { 432 unsigned int len = BPF_MAXINSNS; 433 struct bpf_insn *insn; 434 int i; 435 436 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 437 if (!insn) 438 return -ENOMEM; 439 440 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1); 441 insn[1] = BPF_ST_MEM(size, R10, -40, 42); 442 443 for (i = 2; i < len - 2; i++) 444 insn[i] = BPF_STX_XADD(size, R10, R0, -40); 445 446 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40); 447 insn[len - 1] = BPF_EXIT_INSN(); 448 449 self->u.ptr.insns = insn; 450 self->u.ptr.len = len; 451 self->stack_depth = 40; 452 453 return 0; 454 } 455 456 static int bpf_fill_stxw(struct bpf_test *self) 457 { 458 return __bpf_fill_stxdw(self, BPF_W); 459 } 460 461 static int bpf_fill_stxdw(struct bpf_test *self) 462 { 463 return __bpf_fill_stxdw(self, BPF_DW); 464 } 465 466 static int __bpf_ld_imm64(struct bpf_insn insns[2], u8 reg, s64 imm64) 467 { 468 struct bpf_insn tmp[] = {BPF_LD_IMM64(reg, imm64)}; 469 470 memcpy(insns, tmp, sizeof(tmp)); 471 return 2; 472 } 473 474 /* 475 * Branch conversion tests. Complex operations can expand to a lot 476 * of instructions when JITed. This in turn may cause jump offsets 477 * to overflow the field size of the native instruction, triggering 478 * a branch conversion mechanism in some JITs. 479 */ 480 static int __bpf_fill_max_jmp(struct bpf_test *self, int jmp, int imm) 481 { 482 struct bpf_insn *insns; 483 int len = S16_MAX + 5; 484 int i; 485 486 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 487 if (!insns) 488 return -ENOMEM; 489 490 i = __bpf_ld_imm64(insns, R1, 0x0123456789abcdefULL); 491 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 492 insns[i++] = BPF_JMP_IMM(jmp, R0, imm, S16_MAX); 493 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 2); 494 insns[i++] = BPF_EXIT_INSN(); 495 496 while (i < len - 1) { 497 static const int ops[] = { 498 BPF_LSH, BPF_RSH, BPF_ARSH, BPF_ADD, 499 BPF_SUB, BPF_MUL, BPF_DIV, BPF_MOD, 500 }; 501 int op = ops[(i >> 1) % ARRAY_SIZE(ops)]; 502 503 if (i & 1) 504 insns[i++] = BPF_ALU32_REG(op, R0, R1); 505 else 506 insns[i++] = BPF_ALU64_REG(op, R0, R1); 507 } 508 509 insns[i++] = BPF_EXIT_INSN(); 510 self->u.ptr.insns = insns; 511 self->u.ptr.len = len; 512 BUG_ON(i != len); 513 514 return 0; 515 } 516 517 /* Branch taken by runtime decision */ 518 static int bpf_fill_max_jmp_taken(struct bpf_test *self) 519 { 520 return __bpf_fill_max_jmp(self, BPF_JEQ, 1); 521 } 522 523 /* Branch not taken by runtime decision */ 524 static int bpf_fill_max_jmp_not_taken(struct bpf_test *self) 525 { 526 return __bpf_fill_max_jmp(self, BPF_JEQ, 0); 527 } 528 529 /* Branch always taken, known at JIT time */ 530 static int bpf_fill_max_jmp_always_taken(struct bpf_test *self) 531 { 532 return __bpf_fill_max_jmp(self, BPF_JGE, 0); 533 } 534 535 /* Branch never taken, known at JIT time */ 536 static int bpf_fill_max_jmp_never_taken(struct bpf_test *self) 537 { 538 return __bpf_fill_max_jmp(self, BPF_JLT, 0); 539 } 540 541 /* Test an ALU shift operation for all valid shift values */ 542 static int __bpf_fill_alu_shift(struct bpf_test *self, u8 op, 543 u8 mode, bool alu32) 544 { 545 static const s64 regs[] = { 546 0x0123456789abcdefLL, /* dword > 0, word < 0 */ 547 0xfedcba9876543210LL, /* dowrd < 0, word > 0 */ 548 0xfedcba0198765432LL, /* dowrd < 0, word < 0 */ 549 0x0123458967abcdefLL, /* dword > 0, word > 0 */ 550 }; 551 int bits = alu32 ? 32 : 64; 552 int len = (2 + 7 * bits) * ARRAY_SIZE(regs) + 3; 553 struct bpf_insn *insn; 554 int imm, k; 555 int i = 0; 556 557 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 558 if (!insn) 559 return -ENOMEM; 560 561 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 562 563 for (k = 0; k < ARRAY_SIZE(regs); k++) { 564 s64 reg = regs[k]; 565 566 i += __bpf_ld_imm64(&insn[i], R3, reg); 567 568 for (imm = 0; imm < bits; imm++) { 569 u64 val; 570 571 /* Perform operation */ 572 insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3); 573 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R2, imm); 574 if (alu32) { 575 if (mode == BPF_K) 576 insn[i++] = BPF_ALU32_IMM(op, R1, imm); 577 else 578 insn[i++] = BPF_ALU32_REG(op, R1, R2); 579 switch (op) { 580 case BPF_LSH: 581 val = (u32)reg << imm; 582 break; 583 case BPF_RSH: 584 val = (u32)reg >> imm; 585 break; 586 case BPF_ARSH: 587 val = (u32)reg >> imm; 588 if (imm > 0 && (reg & 0x80000000)) 589 val |= ~(u32)0 << (32 - imm); 590 break; 591 } 592 } else { 593 if (mode == BPF_K) 594 insn[i++] = BPF_ALU64_IMM(op, R1, imm); 595 else 596 insn[i++] = BPF_ALU64_REG(op, R1, R2); 597 switch (op) { 598 case BPF_LSH: 599 val = (u64)reg << imm; 600 break; 601 case BPF_RSH: 602 val = (u64)reg >> imm; 603 break; 604 case BPF_ARSH: 605 val = (u64)reg >> imm; 606 if (imm > 0 && reg < 0) 607 val |= ~(u64)0 << (64 - imm); 608 break; 609 } 610 } 611 612 /* 613 * When debugging a JIT that fails this test, one 614 * can write the immediate value to R0 here to find 615 * out which operand values that fail. 616 */ 617 618 /* Load reference and check the result */ 619 i += __bpf_ld_imm64(&insn[i], R4, val); 620 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R4, 1); 621 insn[i++] = BPF_EXIT_INSN(); 622 } 623 } 624 625 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 626 insn[i++] = BPF_EXIT_INSN(); 627 628 self->u.ptr.insns = insn; 629 self->u.ptr.len = len; 630 BUG_ON(i > len); 631 632 return 0; 633 } 634 635 static int bpf_fill_alu_lsh_imm(struct bpf_test *self) 636 { 637 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, false); 638 } 639 640 static int bpf_fill_alu_rsh_imm(struct bpf_test *self) 641 { 642 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, false); 643 } 644 645 static int bpf_fill_alu_arsh_imm(struct bpf_test *self) 646 { 647 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, false); 648 } 649 650 static int bpf_fill_alu_lsh_reg(struct bpf_test *self) 651 { 652 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, false); 653 } 654 655 static int bpf_fill_alu_rsh_reg(struct bpf_test *self) 656 { 657 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, false); 658 } 659 660 static int bpf_fill_alu_arsh_reg(struct bpf_test *self) 661 { 662 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, false); 663 } 664 665 static int bpf_fill_alu32_lsh_imm(struct bpf_test *self) 666 { 667 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_K, true); 668 } 669 670 static int bpf_fill_alu32_rsh_imm(struct bpf_test *self) 671 { 672 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_K, true); 673 } 674 675 static int bpf_fill_alu32_arsh_imm(struct bpf_test *self) 676 { 677 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_K, true); 678 } 679 680 static int bpf_fill_alu32_lsh_reg(struct bpf_test *self) 681 { 682 return __bpf_fill_alu_shift(self, BPF_LSH, BPF_X, true); 683 } 684 685 static int bpf_fill_alu32_rsh_reg(struct bpf_test *self) 686 { 687 return __bpf_fill_alu_shift(self, BPF_RSH, BPF_X, true); 688 } 689 690 static int bpf_fill_alu32_arsh_reg(struct bpf_test *self) 691 { 692 return __bpf_fill_alu_shift(self, BPF_ARSH, BPF_X, true); 693 } 694 695 /* 696 * Common operand pattern generator for exhaustive power-of-two magnitudes 697 * tests. The block size parameters can be adjusted to increase/reduce the 698 * number of combinatons tested and thereby execution speed and memory 699 * footprint. 700 */ 701 702 static inline s64 value(int msb, int delta, int sign) 703 { 704 return sign * (1LL << msb) + delta; 705 } 706 707 static int __bpf_fill_pattern(struct bpf_test *self, void *arg, 708 int dbits, int sbits, int block1, int block2, 709 int (*emit)(struct bpf_test*, void*, 710 struct bpf_insn*, s64, s64)) 711 { 712 static const int sgn[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}}; 713 struct bpf_insn *insns; 714 int di, si, bt, db, sb; 715 int count, len, k; 716 int extra = 1 + 2; 717 int i = 0; 718 719 /* Total number of iterations for the two pattern */ 720 count = (dbits - 1) * (sbits - 1) * block1 * block1 * ARRAY_SIZE(sgn); 721 count += (max(dbits, sbits) - 1) * block2 * block2 * ARRAY_SIZE(sgn); 722 723 /* Compute the maximum number of insns and allocate the buffer */ 724 len = extra + count * (*emit)(self, arg, NULL, 0, 0); 725 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 726 if (!insns) 727 return -ENOMEM; 728 729 /* Add head instruction(s) */ 730 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 731 732 /* 733 * Pattern 1: all combinations of power-of-two magnitudes and sign, 734 * and with a block of contiguous values around each magnitude. 735 */ 736 for (di = 0; di < dbits - 1; di++) /* Dst magnitudes */ 737 for (si = 0; si < sbits - 1; si++) /* Src magnitudes */ 738 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 739 for (db = -(block1 / 2); 740 db < (block1 + 1) / 2; db++) 741 for (sb = -(block1 / 2); 742 sb < (block1 + 1) / 2; sb++) { 743 s64 dst, src; 744 745 dst = value(di, db, sgn[k][0]); 746 src = value(si, sb, sgn[k][1]); 747 i += (*emit)(self, arg, 748 &insns[i], 749 dst, src); 750 } 751 /* 752 * Pattern 2: all combinations for a larger block of values 753 * for each power-of-two magnitude and sign, where the magnitude is 754 * the same for both operands. 755 */ 756 for (bt = 0; bt < max(dbits, sbits) - 1; bt++) /* Magnitude */ 757 for (k = 0; k < ARRAY_SIZE(sgn); k++) /* Sign combos */ 758 for (db = -(block2 / 2); db < (block2 + 1) / 2; db++) 759 for (sb = -(block2 / 2); 760 sb < (block2 + 1) / 2; sb++) { 761 s64 dst, src; 762 763 dst = value(bt % dbits, db, sgn[k][0]); 764 src = value(bt % sbits, sb, sgn[k][1]); 765 i += (*emit)(self, arg, &insns[i], 766 dst, src); 767 } 768 769 /* Append tail instructions */ 770 insns[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 771 insns[i++] = BPF_EXIT_INSN(); 772 BUG_ON(i > len); 773 774 self->u.ptr.insns = insns; 775 self->u.ptr.len = i; 776 777 return 0; 778 } 779 780 /* 781 * Block size parameters used in pattern tests below. une as needed to 782 * increase/reduce the number combinations tested, see following examples. 783 * block values per operand MSB 784 * ---------------------------------------- 785 * 0 none 786 * 1 (1 << MSB) 787 * 2 (1 << MSB) + [-1, 0] 788 * 3 (1 << MSB) + [-1, 0, 1] 789 */ 790 #define PATTERN_BLOCK1 1 791 #define PATTERN_BLOCK2 5 792 793 /* Number of test runs for a pattern test */ 794 #define NR_PATTERN_RUNS 1 795 796 /* 797 * Exhaustive tests of ALU operations for all combinations of power-of-two 798 * magnitudes of the operands, both for positive and negative values. The 799 * test is designed to verify e.g. the ALU and ALU64 operations for JITs that 800 * emit different code depending on the magnitude of the immediate value. 801 */ 802 803 static bool __bpf_alu_result(u64 *res, u64 v1, u64 v2, u8 op) 804 { 805 *res = 0; 806 switch (op) { 807 case BPF_MOV: 808 *res = v2; 809 break; 810 case BPF_AND: 811 *res = v1 & v2; 812 break; 813 case BPF_OR: 814 *res = v1 | v2; 815 break; 816 case BPF_XOR: 817 *res = v1 ^ v2; 818 break; 819 case BPF_ADD: 820 *res = v1 + v2; 821 break; 822 case BPF_SUB: 823 *res = v1 - v2; 824 break; 825 case BPF_MUL: 826 *res = v1 * v2; 827 break; 828 case BPF_DIV: 829 if (v2 == 0) 830 return false; 831 *res = div64_u64(v1, v2); 832 break; 833 case BPF_MOD: 834 if (v2 == 0) 835 return false; 836 div64_u64_rem(v1, v2, res); 837 break; 838 } 839 return true; 840 } 841 842 static int __bpf_emit_alu64_imm(struct bpf_test *self, void *arg, 843 struct bpf_insn *insns, s64 dst, s64 imm) 844 { 845 int op = *(int *)arg; 846 int i = 0; 847 u64 res; 848 849 if (!insns) 850 return 7; 851 852 if (__bpf_alu_result(&res, dst, (s32)imm, op)) { 853 i += __bpf_ld_imm64(&insns[i], R1, dst); 854 i += __bpf_ld_imm64(&insns[i], R3, res); 855 insns[i++] = BPF_ALU64_IMM(op, R1, imm); 856 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 857 insns[i++] = BPF_EXIT_INSN(); 858 } 859 860 return i; 861 } 862 863 static int __bpf_emit_alu32_imm(struct bpf_test *self, void *arg, 864 struct bpf_insn *insns, s64 dst, s64 imm) 865 { 866 int op = *(int *)arg; 867 int i = 0; 868 u64 res; 869 870 if (!insns) 871 return 7; 872 873 if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) { 874 i += __bpf_ld_imm64(&insns[i], R1, dst); 875 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 876 insns[i++] = BPF_ALU32_IMM(op, R1, imm); 877 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 878 insns[i++] = BPF_EXIT_INSN(); 879 } 880 881 return i; 882 } 883 884 static int __bpf_emit_alu64_reg(struct bpf_test *self, void *arg, 885 struct bpf_insn *insns, s64 dst, s64 src) 886 { 887 int op = *(int *)arg; 888 int i = 0; 889 u64 res; 890 891 if (!insns) 892 return 9; 893 894 if (__bpf_alu_result(&res, dst, src, op)) { 895 i += __bpf_ld_imm64(&insns[i], R1, dst); 896 i += __bpf_ld_imm64(&insns[i], R2, src); 897 i += __bpf_ld_imm64(&insns[i], R3, res); 898 insns[i++] = BPF_ALU64_REG(op, R1, R2); 899 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 900 insns[i++] = BPF_EXIT_INSN(); 901 } 902 903 return i; 904 } 905 906 static int __bpf_emit_alu32_reg(struct bpf_test *self, void *arg, 907 struct bpf_insn *insns, s64 dst, s64 src) 908 { 909 int op = *(int *)arg; 910 int i = 0; 911 u64 res; 912 913 if (!insns) 914 return 9; 915 916 if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) { 917 i += __bpf_ld_imm64(&insns[i], R1, dst); 918 i += __bpf_ld_imm64(&insns[i], R2, src); 919 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 920 insns[i++] = BPF_ALU32_REG(op, R1, R2); 921 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 922 insns[i++] = BPF_EXIT_INSN(); 923 } 924 925 return i; 926 } 927 928 static int __bpf_fill_alu64_imm(struct bpf_test *self, int op) 929 { 930 return __bpf_fill_pattern(self, &op, 64, 32, 931 PATTERN_BLOCK1, PATTERN_BLOCK2, 932 &__bpf_emit_alu64_imm); 933 } 934 935 static int __bpf_fill_alu32_imm(struct bpf_test *self, int op) 936 { 937 return __bpf_fill_pattern(self, &op, 64, 32, 938 PATTERN_BLOCK1, PATTERN_BLOCK2, 939 &__bpf_emit_alu32_imm); 940 } 941 942 static int __bpf_fill_alu64_reg(struct bpf_test *self, int op) 943 { 944 return __bpf_fill_pattern(self, &op, 64, 64, 945 PATTERN_BLOCK1, PATTERN_BLOCK2, 946 &__bpf_emit_alu64_reg); 947 } 948 949 static int __bpf_fill_alu32_reg(struct bpf_test *self, int op) 950 { 951 return __bpf_fill_pattern(self, &op, 64, 64, 952 PATTERN_BLOCK1, PATTERN_BLOCK2, 953 &__bpf_emit_alu32_reg); 954 } 955 956 /* ALU64 immediate operations */ 957 static int bpf_fill_alu64_mov_imm(struct bpf_test *self) 958 { 959 return __bpf_fill_alu64_imm(self, BPF_MOV); 960 } 961 962 static int bpf_fill_alu64_and_imm(struct bpf_test *self) 963 { 964 return __bpf_fill_alu64_imm(self, BPF_AND); 965 } 966 967 static int bpf_fill_alu64_or_imm(struct bpf_test *self) 968 { 969 return __bpf_fill_alu64_imm(self, BPF_OR); 970 } 971 972 static int bpf_fill_alu64_xor_imm(struct bpf_test *self) 973 { 974 return __bpf_fill_alu64_imm(self, BPF_XOR); 975 } 976 977 static int bpf_fill_alu64_add_imm(struct bpf_test *self) 978 { 979 return __bpf_fill_alu64_imm(self, BPF_ADD); 980 } 981 982 static int bpf_fill_alu64_sub_imm(struct bpf_test *self) 983 { 984 return __bpf_fill_alu64_imm(self, BPF_SUB); 985 } 986 987 static int bpf_fill_alu64_mul_imm(struct bpf_test *self) 988 { 989 return __bpf_fill_alu64_imm(self, BPF_MUL); 990 } 991 992 static int bpf_fill_alu64_div_imm(struct bpf_test *self) 993 { 994 return __bpf_fill_alu64_imm(self, BPF_DIV); 995 } 996 997 static int bpf_fill_alu64_mod_imm(struct bpf_test *self) 998 { 999 return __bpf_fill_alu64_imm(self, BPF_MOD); 1000 } 1001 1002 /* ALU32 immediate operations */ 1003 static int bpf_fill_alu32_mov_imm(struct bpf_test *self) 1004 { 1005 return __bpf_fill_alu32_imm(self, BPF_MOV); 1006 } 1007 1008 static int bpf_fill_alu32_and_imm(struct bpf_test *self) 1009 { 1010 return __bpf_fill_alu32_imm(self, BPF_AND); 1011 } 1012 1013 static int bpf_fill_alu32_or_imm(struct bpf_test *self) 1014 { 1015 return __bpf_fill_alu32_imm(self, BPF_OR); 1016 } 1017 1018 static int bpf_fill_alu32_xor_imm(struct bpf_test *self) 1019 { 1020 return __bpf_fill_alu32_imm(self, BPF_XOR); 1021 } 1022 1023 static int bpf_fill_alu32_add_imm(struct bpf_test *self) 1024 { 1025 return __bpf_fill_alu32_imm(self, BPF_ADD); 1026 } 1027 1028 static int bpf_fill_alu32_sub_imm(struct bpf_test *self) 1029 { 1030 return __bpf_fill_alu32_imm(self, BPF_SUB); 1031 } 1032 1033 static int bpf_fill_alu32_mul_imm(struct bpf_test *self) 1034 { 1035 return __bpf_fill_alu32_imm(self, BPF_MUL); 1036 } 1037 1038 static int bpf_fill_alu32_div_imm(struct bpf_test *self) 1039 { 1040 return __bpf_fill_alu32_imm(self, BPF_DIV); 1041 } 1042 1043 static int bpf_fill_alu32_mod_imm(struct bpf_test *self) 1044 { 1045 return __bpf_fill_alu32_imm(self, BPF_MOD); 1046 } 1047 1048 /* ALU64 register operations */ 1049 static int bpf_fill_alu64_mov_reg(struct bpf_test *self) 1050 { 1051 return __bpf_fill_alu64_reg(self, BPF_MOV); 1052 } 1053 1054 static int bpf_fill_alu64_and_reg(struct bpf_test *self) 1055 { 1056 return __bpf_fill_alu64_reg(self, BPF_AND); 1057 } 1058 1059 static int bpf_fill_alu64_or_reg(struct bpf_test *self) 1060 { 1061 return __bpf_fill_alu64_reg(self, BPF_OR); 1062 } 1063 1064 static int bpf_fill_alu64_xor_reg(struct bpf_test *self) 1065 { 1066 return __bpf_fill_alu64_reg(self, BPF_XOR); 1067 } 1068 1069 static int bpf_fill_alu64_add_reg(struct bpf_test *self) 1070 { 1071 return __bpf_fill_alu64_reg(self, BPF_ADD); 1072 } 1073 1074 static int bpf_fill_alu64_sub_reg(struct bpf_test *self) 1075 { 1076 return __bpf_fill_alu64_reg(self, BPF_SUB); 1077 } 1078 1079 static int bpf_fill_alu64_mul_reg(struct bpf_test *self) 1080 { 1081 return __bpf_fill_alu64_reg(self, BPF_MUL); 1082 } 1083 1084 static int bpf_fill_alu64_div_reg(struct bpf_test *self) 1085 { 1086 return __bpf_fill_alu64_reg(self, BPF_DIV); 1087 } 1088 1089 static int bpf_fill_alu64_mod_reg(struct bpf_test *self) 1090 { 1091 return __bpf_fill_alu64_reg(self, BPF_MOD); 1092 } 1093 1094 /* ALU32 register operations */ 1095 static int bpf_fill_alu32_mov_reg(struct bpf_test *self) 1096 { 1097 return __bpf_fill_alu32_reg(self, BPF_MOV); 1098 } 1099 1100 static int bpf_fill_alu32_and_reg(struct bpf_test *self) 1101 { 1102 return __bpf_fill_alu32_reg(self, BPF_AND); 1103 } 1104 1105 static int bpf_fill_alu32_or_reg(struct bpf_test *self) 1106 { 1107 return __bpf_fill_alu32_reg(self, BPF_OR); 1108 } 1109 1110 static int bpf_fill_alu32_xor_reg(struct bpf_test *self) 1111 { 1112 return __bpf_fill_alu32_reg(self, BPF_XOR); 1113 } 1114 1115 static int bpf_fill_alu32_add_reg(struct bpf_test *self) 1116 { 1117 return __bpf_fill_alu32_reg(self, BPF_ADD); 1118 } 1119 1120 static int bpf_fill_alu32_sub_reg(struct bpf_test *self) 1121 { 1122 return __bpf_fill_alu32_reg(self, BPF_SUB); 1123 } 1124 1125 static int bpf_fill_alu32_mul_reg(struct bpf_test *self) 1126 { 1127 return __bpf_fill_alu32_reg(self, BPF_MUL); 1128 } 1129 1130 static int bpf_fill_alu32_div_reg(struct bpf_test *self) 1131 { 1132 return __bpf_fill_alu32_reg(self, BPF_DIV); 1133 } 1134 1135 static int bpf_fill_alu32_mod_reg(struct bpf_test *self) 1136 { 1137 return __bpf_fill_alu32_reg(self, BPF_MOD); 1138 } 1139 1140 /* 1141 * Exhaustive tests of atomic operations for all power-of-two operand 1142 * magnitudes, both for positive and negative values. 1143 */ 1144 1145 static int __bpf_emit_atomic64(struct bpf_test *self, void *arg, 1146 struct bpf_insn *insns, s64 dst, s64 src) 1147 { 1148 int op = *(int *)arg; 1149 u64 keep, fetch, res; 1150 int i = 0; 1151 1152 if (!insns) 1153 return 21; 1154 1155 switch (op) { 1156 case BPF_XCHG: 1157 res = src; 1158 break; 1159 default: 1160 __bpf_alu_result(&res, dst, src, BPF_OP(op)); 1161 } 1162 1163 keep = 0x0123456789abcdefULL; 1164 if (op & BPF_FETCH) 1165 fetch = dst; 1166 else 1167 fetch = src; 1168 1169 i += __bpf_ld_imm64(&insns[i], R0, keep); 1170 i += __bpf_ld_imm64(&insns[i], R1, dst); 1171 i += __bpf_ld_imm64(&insns[i], R2, src); 1172 i += __bpf_ld_imm64(&insns[i], R3, res); 1173 i += __bpf_ld_imm64(&insns[i], R4, fetch); 1174 i += __bpf_ld_imm64(&insns[i], R5, keep); 1175 1176 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8); 1177 insns[i++] = BPF_ATOMIC_OP(BPF_DW, op, R10, R2, -8); 1178 insns[i++] = BPF_LDX_MEM(BPF_DW, R1, R10, -8); 1179 1180 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 1181 insns[i++] = BPF_EXIT_INSN(); 1182 1183 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1); 1184 insns[i++] = BPF_EXIT_INSN(); 1185 1186 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1); 1187 insns[i++] = BPF_EXIT_INSN(); 1188 1189 return i; 1190 } 1191 1192 static int __bpf_emit_atomic32(struct bpf_test *self, void *arg, 1193 struct bpf_insn *insns, s64 dst, s64 src) 1194 { 1195 int op = *(int *)arg; 1196 u64 keep, fetch, res; 1197 int i = 0; 1198 1199 if (!insns) 1200 return 21; 1201 1202 switch (op) { 1203 case BPF_XCHG: 1204 res = src; 1205 break; 1206 default: 1207 __bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op)); 1208 } 1209 1210 keep = 0x0123456789abcdefULL; 1211 if (op & BPF_FETCH) 1212 fetch = (u32)dst; 1213 else 1214 fetch = src; 1215 1216 i += __bpf_ld_imm64(&insns[i], R0, keep); 1217 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst); 1218 i += __bpf_ld_imm64(&insns[i], R2, src); 1219 i += __bpf_ld_imm64(&insns[i], R3, (u32)res); 1220 i += __bpf_ld_imm64(&insns[i], R4, fetch); 1221 i += __bpf_ld_imm64(&insns[i], R5, keep); 1222 1223 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4); 1224 insns[i++] = BPF_ATOMIC_OP(BPF_W, op, R10, R2, -4); 1225 insns[i++] = BPF_LDX_MEM(BPF_W, R1, R10, -4); 1226 1227 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1); 1228 insns[i++] = BPF_EXIT_INSN(); 1229 1230 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R4, 1); 1231 insns[i++] = BPF_EXIT_INSN(); 1232 1233 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R5, 1); 1234 insns[i++] = BPF_EXIT_INSN(); 1235 1236 return i; 1237 } 1238 1239 static int __bpf_emit_cmpxchg64(struct bpf_test *self, void *arg, 1240 struct bpf_insn *insns, s64 dst, s64 src) 1241 { 1242 int i = 0; 1243 1244 if (!insns) 1245 return 23; 1246 1247 i += __bpf_ld_imm64(&insns[i], R0, ~dst); 1248 i += __bpf_ld_imm64(&insns[i], R1, dst); 1249 i += __bpf_ld_imm64(&insns[i], R2, src); 1250 1251 /* Result unsuccessful */ 1252 insns[i++] = BPF_STX_MEM(BPF_DW, R10, R1, -8); 1253 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8); 1254 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8); 1255 1256 insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2); 1257 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1258 insns[i++] = BPF_EXIT_INSN(); 1259 1260 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2); 1261 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1262 insns[i++] = BPF_EXIT_INSN(); 1263 1264 /* Result successful */ 1265 insns[i++] = BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -8); 1266 insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8); 1267 1268 insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2); 1269 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1270 insns[i++] = BPF_EXIT_INSN(); 1271 1272 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2); 1273 insns[i++] = BPF_MOV64_IMM(R0, __LINE__); 1274 insns[i++] = BPF_EXIT_INSN(); 1275 1276 return i; 1277 } 1278 1279 static int __bpf_emit_cmpxchg32(struct bpf_test *self, void *arg, 1280 struct bpf_insn *insns, s64 dst, s64 src) 1281 { 1282 int i = 0; 1283 1284 if (!insns) 1285 return 27; 1286 1287 i += __bpf_ld_imm64(&insns[i], R0, ~dst); 1288 i += __bpf_ld_imm64(&insns[i], R1, (u32)dst); 1289 i += __bpf_ld_imm64(&insns[i], R2, src); 1290 1291 /* Result unsuccessful */ 1292 insns[i++] = BPF_STX_MEM(BPF_W, R10, R1, -4); 1293 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4); 1294 insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */ 1295 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4); 1296 1297 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2); 1298 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1299 insns[i++] = BPF_EXIT_INSN(); 1300 1301 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2); 1302 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1303 insns[i++] = BPF_EXIT_INSN(); 1304 1305 /* Result successful */ 1306 i += __bpf_ld_imm64(&insns[i], R0, dst); 1307 insns[i++] = BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R2, -4); 1308 insns[i++] = BPF_ZEXT_REG(R0), /* Zext always inserted by verifier */ 1309 insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4); 1310 1311 insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2); 1312 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1313 insns[i++] = BPF_EXIT_INSN(); 1314 1315 insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R1, 2); 1316 insns[i++] = BPF_MOV32_IMM(R0, __LINE__); 1317 insns[i++] = BPF_EXIT_INSN(); 1318 1319 return i; 1320 } 1321 1322 static int __bpf_fill_atomic64(struct bpf_test *self, int op) 1323 { 1324 return __bpf_fill_pattern(self, &op, 64, 64, 1325 0, PATTERN_BLOCK2, 1326 &__bpf_emit_atomic64); 1327 } 1328 1329 static int __bpf_fill_atomic32(struct bpf_test *self, int op) 1330 { 1331 return __bpf_fill_pattern(self, &op, 64, 64, 1332 0, PATTERN_BLOCK2, 1333 &__bpf_emit_atomic32); 1334 } 1335 1336 /* 64-bit atomic operations */ 1337 static int bpf_fill_atomic64_add(struct bpf_test *self) 1338 { 1339 return __bpf_fill_atomic64(self, BPF_ADD); 1340 } 1341 1342 static int bpf_fill_atomic64_and(struct bpf_test *self) 1343 { 1344 return __bpf_fill_atomic64(self, BPF_AND); 1345 } 1346 1347 static int bpf_fill_atomic64_or(struct bpf_test *self) 1348 { 1349 return __bpf_fill_atomic64(self, BPF_OR); 1350 } 1351 1352 static int bpf_fill_atomic64_xor(struct bpf_test *self) 1353 { 1354 return __bpf_fill_atomic64(self, BPF_XOR); 1355 } 1356 1357 static int bpf_fill_atomic64_add_fetch(struct bpf_test *self) 1358 { 1359 return __bpf_fill_atomic64(self, BPF_ADD | BPF_FETCH); 1360 } 1361 1362 static int bpf_fill_atomic64_and_fetch(struct bpf_test *self) 1363 { 1364 return __bpf_fill_atomic64(self, BPF_AND | BPF_FETCH); 1365 } 1366 1367 static int bpf_fill_atomic64_or_fetch(struct bpf_test *self) 1368 { 1369 return __bpf_fill_atomic64(self, BPF_OR | BPF_FETCH); 1370 } 1371 1372 static int bpf_fill_atomic64_xor_fetch(struct bpf_test *self) 1373 { 1374 return __bpf_fill_atomic64(self, BPF_XOR | BPF_FETCH); 1375 } 1376 1377 static int bpf_fill_atomic64_xchg(struct bpf_test *self) 1378 { 1379 return __bpf_fill_atomic64(self, BPF_XCHG); 1380 } 1381 1382 static int bpf_fill_cmpxchg64(struct bpf_test *self) 1383 { 1384 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2, 1385 &__bpf_emit_cmpxchg64); 1386 } 1387 1388 /* 32-bit atomic operations */ 1389 static int bpf_fill_atomic32_add(struct bpf_test *self) 1390 { 1391 return __bpf_fill_atomic32(self, BPF_ADD); 1392 } 1393 1394 static int bpf_fill_atomic32_and(struct bpf_test *self) 1395 { 1396 return __bpf_fill_atomic32(self, BPF_AND); 1397 } 1398 1399 static int bpf_fill_atomic32_or(struct bpf_test *self) 1400 { 1401 return __bpf_fill_atomic32(self, BPF_OR); 1402 } 1403 1404 static int bpf_fill_atomic32_xor(struct bpf_test *self) 1405 { 1406 return __bpf_fill_atomic32(self, BPF_XOR); 1407 } 1408 1409 static int bpf_fill_atomic32_add_fetch(struct bpf_test *self) 1410 { 1411 return __bpf_fill_atomic32(self, BPF_ADD | BPF_FETCH); 1412 } 1413 1414 static int bpf_fill_atomic32_and_fetch(struct bpf_test *self) 1415 { 1416 return __bpf_fill_atomic32(self, BPF_AND | BPF_FETCH); 1417 } 1418 1419 static int bpf_fill_atomic32_or_fetch(struct bpf_test *self) 1420 { 1421 return __bpf_fill_atomic32(self, BPF_OR | BPF_FETCH); 1422 } 1423 1424 static int bpf_fill_atomic32_xor_fetch(struct bpf_test *self) 1425 { 1426 return __bpf_fill_atomic32(self, BPF_XOR | BPF_FETCH); 1427 } 1428 1429 static int bpf_fill_atomic32_xchg(struct bpf_test *self) 1430 { 1431 return __bpf_fill_atomic32(self, BPF_XCHG); 1432 } 1433 1434 static int bpf_fill_cmpxchg32(struct bpf_test *self) 1435 { 1436 return __bpf_fill_pattern(self, NULL, 64, 64, 0, PATTERN_BLOCK2, 1437 &__bpf_emit_cmpxchg32); 1438 } 1439 1440 /* 1441 * Test the two-instruction 64-bit immediate load operation for all 1442 * power-of-two magnitudes of the immediate operand. For each MSB, a block 1443 * of immediate values centered around the power-of-two MSB are tested, 1444 * both for positive and negative values. The test is designed to verify 1445 * the operation for JITs that emit different code depending on the magnitude 1446 * of the immediate value. This is often the case if the native instruction 1447 * immediate field width is narrower than 32 bits. 1448 */ 1449 static int bpf_fill_ld_imm64(struct bpf_test *self) 1450 { 1451 int block = 64; /* Increase for more tests per MSB position */ 1452 int len = 3 + 8 * 63 * block * 2; 1453 struct bpf_insn *insn; 1454 int bit, adj, sign; 1455 int i = 0; 1456 1457 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 1458 if (!insn) 1459 return -ENOMEM; 1460 1461 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 1462 1463 for (bit = 0; bit <= 62; bit++) { 1464 for (adj = -block / 2; adj < block / 2; adj++) { 1465 for (sign = -1; sign <= 1; sign += 2) { 1466 s64 imm = sign * ((1LL << bit) + adj); 1467 1468 /* Perform operation */ 1469 i += __bpf_ld_imm64(&insn[i], R1, imm); 1470 1471 /* Load reference */ 1472 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R2, imm); 1473 insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, 1474 (u32)(imm >> 32)); 1475 insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32); 1476 insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3); 1477 1478 /* Check result */ 1479 insn[i++] = BPF_JMP_REG(BPF_JEQ, R1, R2, 1); 1480 insn[i++] = BPF_EXIT_INSN(); 1481 } 1482 } 1483 } 1484 1485 insn[i++] = BPF_ALU64_IMM(BPF_MOV, R0, 1); 1486 insn[i++] = BPF_EXIT_INSN(); 1487 1488 self->u.ptr.insns = insn; 1489 self->u.ptr.len = len; 1490 BUG_ON(i != len); 1491 1492 return 0; 1493 } 1494 1495 /* 1496 * Exhaustive tests of JMP operations for all combinations of power-of-two 1497 * magnitudes of the operands, both for positive and negative values. The 1498 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that 1499 * emit different code depending on the magnitude of the immediate value. 1500 */ 1501 1502 static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op) 1503 { 1504 switch (op) { 1505 case BPF_JSET: 1506 return !!(v1 & v2); 1507 case BPF_JEQ: 1508 return v1 == v2; 1509 case BPF_JNE: 1510 return v1 != v2; 1511 case BPF_JGT: 1512 return (u64)v1 > (u64)v2; 1513 case BPF_JGE: 1514 return (u64)v1 >= (u64)v2; 1515 case BPF_JLT: 1516 return (u64)v1 < (u64)v2; 1517 case BPF_JLE: 1518 return (u64)v1 <= (u64)v2; 1519 case BPF_JSGT: 1520 return v1 > v2; 1521 case BPF_JSGE: 1522 return v1 >= v2; 1523 case BPF_JSLT: 1524 return v1 < v2; 1525 case BPF_JSLE: 1526 return v1 <= v2; 1527 } 1528 return false; 1529 } 1530 1531 static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg, 1532 struct bpf_insn *insns, s64 dst, s64 imm) 1533 { 1534 int op = *(int *)arg; 1535 1536 if (insns) { 1537 bool match = __bpf_match_jmp_cond(dst, (s32)imm, op); 1538 int i = 0; 1539 1540 insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match); 1541 1542 i += __bpf_ld_imm64(&insns[i], R1, dst); 1543 insns[i++] = BPF_JMP_IMM(op, R1, imm, 1); 1544 if (!match) 1545 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 1546 insns[i++] = BPF_EXIT_INSN(); 1547 1548 return i; 1549 } 1550 1551 return 5 + 1; 1552 } 1553 1554 static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg, 1555 struct bpf_insn *insns, s64 dst, s64 imm) 1556 { 1557 int op = *(int *)arg; 1558 1559 if (insns) { 1560 bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op); 1561 int i = 0; 1562 1563 i += __bpf_ld_imm64(&insns[i], R1, dst); 1564 insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1); 1565 if (!match) 1566 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 1567 insns[i++] = BPF_EXIT_INSN(); 1568 1569 return i; 1570 } 1571 1572 return 5; 1573 } 1574 1575 static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg, 1576 struct bpf_insn *insns, s64 dst, s64 src) 1577 { 1578 int op = *(int *)arg; 1579 1580 if (insns) { 1581 bool match = __bpf_match_jmp_cond(dst, src, op); 1582 int i = 0; 1583 1584 i += __bpf_ld_imm64(&insns[i], R1, dst); 1585 i += __bpf_ld_imm64(&insns[i], R2, src); 1586 insns[i++] = BPF_JMP_REG(op, R1, R2, 1); 1587 if (!match) 1588 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 1589 insns[i++] = BPF_EXIT_INSN(); 1590 1591 return i; 1592 } 1593 1594 return 7; 1595 } 1596 1597 static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg, 1598 struct bpf_insn *insns, s64 dst, s64 src) 1599 { 1600 int op = *(int *)arg; 1601 1602 if (insns) { 1603 bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op); 1604 int i = 0; 1605 1606 i += __bpf_ld_imm64(&insns[i], R1, dst); 1607 i += __bpf_ld_imm64(&insns[i], R2, src); 1608 insns[i++] = BPF_JMP32_REG(op, R1, R2, 1); 1609 if (!match) 1610 insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1); 1611 insns[i++] = BPF_EXIT_INSN(); 1612 1613 return i; 1614 } 1615 1616 return 7; 1617 } 1618 1619 static int __bpf_fill_jmp_imm(struct bpf_test *self, int op) 1620 { 1621 return __bpf_fill_pattern(self, &op, 64, 32, 1622 PATTERN_BLOCK1, PATTERN_BLOCK2, 1623 &__bpf_emit_jmp_imm); 1624 } 1625 1626 static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op) 1627 { 1628 return __bpf_fill_pattern(self, &op, 64, 32, 1629 PATTERN_BLOCK1, PATTERN_BLOCK2, 1630 &__bpf_emit_jmp32_imm); 1631 } 1632 1633 static int __bpf_fill_jmp_reg(struct bpf_test *self, int op) 1634 { 1635 return __bpf_fill_pattern(self, &op, 64, 64, 1636 PATTERN_BLOCK1, PATTERN_BLOCK2, 1637 &__bpf_emit_jmp_reg); 1638 } 1639 1640 static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op) 1641 { 1642 return __bpf_fill_pattern(self, &op, 64, 64, 1643 PATTERN_BLOCK1, PATTERN_BLOCK2, 1644 &__bpf_emit_jmp32_reg); 1645 } 1646 1647 /* JMP immediate tests */ 1648 static int bpf_fill_jmp_jset_imm(struct bpf_test *self) 1649 { 1650 return __bpf_fill_jmp_imm(self, BPF_JSET); 1651 } 1652 1653 static int bpf_fill_jmp_jeq_imm(struct bpf_test *self) 1654 { 1655 return __bpf_fill_jmp_imm(self, BPF_JEQ); 1656 } 1657 1658 static int bpf_fill_jmp_jne_imm(struct bpf_test *self) 1659 { 1660 return __bpf_fill_jmp_imm(self, BPF_JNE); 1661 } 1662 1663 static int bpf_fill_jmp_jgt_imm(struct bpf_test *self) 1664 { 1665 return __bpf_fill_jmp_imm(self, BPF_JGT); 1666 } 1667 1668 static int bpf_fill_jmp_jge_imm(struct bpf_test *self) 1669 { 1670 return __bpf_fill_jmp_imm(self, BPF_JGE); 1671 } 1672 1673 static int bpf_fill_jmp_jlt_imm(struct bpf_test *self) 1674 { 1675 return __bpf_fill_jmp_imm(self, BPF_JLT); 1676 } 1677 1678 static int bpf_fill_jmp_jle_imm(struct bpf_test *self) 1679 { 1680 return __bpf_fill_jmp_imm(self, BPF_JLE); 1681 } 1682 1683 static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self) 1684 { 1685 return __bpf_fill_jmp_imm(self, BPF_JSGT); 1686 } 1687 1688 static int bpf_fill_jmp_jsge_imm(struct bpf_test *self) 1689 { 1690 return __bpf_fill_jmp_imm(self, BPF_JSGE); 1691 } 1692 1693 static int bpf_fill_jmp_jslt_imm(struct bpf_test *self) 1694 { 1695 return __bpf_fill_jmp_imm(self, BPF_JSLT); 1696 } 1697 1698 static int bpf_fill_jmp_jsle_imm(struct bpf_test *self) 1699 { 1700 return __bpf_fill_jmp_imm(self, BPF_JSLE); 1701 } 1702 1703 /* JMP32 immediate tests */ 1704 static int bpf_fill_jmp32_jset_imm(struct bpf_test *self) 1705 { 1706 return __bpf_fill_jmp32_imm(self, BPF_JSET); 1707 } 1708 1709 static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self) 1710 { 1711 return __bpf_fill_jmp32_imm(self, BPF_JEQ); 1712 } 1713 1714 static int bpf_fill_jmp32_jne_imm(struct bpf_test *self) 1715 { 1716 return __bpf_fill_jmp32_imm(self, BPF_JNE); 1717 } 1718 1719 static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self) 1720 { 1721 return __bpf_fill_jmp32_imm(self, BPF_JGT); 1722 } 1723 1724 static int bpf_fill_jmp32_jge_imm(struct bpf_test *self) 1725 { 1726 return __bpf_fill_jmp32_imm(self, BPF_JGE); 1727 } 1728 1729 static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self) 1730 { 1731 return __bpf_fill_jmp32_imm(self, BPF_JLT); 1732 } 1733 1734 static int bpf_fill_jmp32_jle_imm(struct bpf_test *self) 1735 { 1736 return __bpf_fill_jmp32_imm(self, BPF_JLE); 1737 } 1738 1739 static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self) 1740 { 1741 return __bpf_fill_jmp32_imm(self, BPF_JSGT); 1742 } 1743 1744 static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self) 1745 { 1746 return __bpf_fill_jmp32_imm(self, BPF_JSGE); 1747 } 1748 1749 static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self) 1750 { 1751 return __bpf_fill_jmp32_imm(self, BPF_JSLT); 1752 } 1753 1754 static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self) 1755 { 1756 return __bpf_fill_jmp32_imm(self, BPF_JSLE); 1757 } 1758 1759 /* JMP register tests */ 1760 static int bpf_fill_jmp_jset_reg(struct bpf_test *self) 1761 { 1762 return __bpf_fill_jmp_reg(self, BPF_JSET); 1763 } 1764 1765 static int bpf_fill_jmp_jeq_reg(struct bpf_test *self) 1766 { 1767 return __bpf_fill_jmp_reg(self, BPF_JEQ); 1768 } 1769 1770 static int bpf_fill_jmp_jne_reg(struct bpf_test *self) 1771 { 1772 return __bpf_fill_jmp_reg(self, BPF_JNE); 1773 } 1774 1775 static int bpf_fill_jmp_jgt_reg(struct bpf_test *self) 1776 { 1777 return __bpf_fill_jmp_reg(self, BPF_JGT); 1778 } 1779 1780 static int bpf_fill_jmp_jge_reg(struct bpf_test *self) 1781 { 1782 return __bpf_fill_jmp_reg(self, BPF_JGE); 1783 } 1784 1785 static int bpf_fill_jmp_jlt_reg(struct bpf_test *self) 1786 { 1787 return __bpf_fill_jmp_reg(self, BPF_JLT); 1788 } 1789 1790 static int bpf_fill_jmp_jle_reg(struct bpf_test *self) 1791 { 1792 return __bpf_fill_jmp_reg(self, BPF_JLE); 1793 } 1794 1795 static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self) 1796 { 1797 return __bpf_fill_jmp_reg(self, BPF_JSGT); 1798 } 1799 1800 static int bpf_fill_jmp_jsge_reg(struct bpf_test *self) 1801 { 1802 return __bpf_fill_jmp_reg(self, BPF_JSGE); 1803 } 1804 1805 static int bpf_fill_jmp_jslt_reg(struct bpf_test *self) 1806 { 1807 return __bpf_fill_jmp_reg(self, BPF_JSLT); 1808 } 1809 1810 static int bpf_fill_jmp_jsle_reg(struct bpf_test *self) 1811 { 1812 return __bpf_fill_jmp_reg(self, BPF_JSLE); 1813 } 1814 1815 /* JMP32 register tests */ 1816 static int bpf_fill_jmp32_jset_reg(struct bpf_test *self) 1817 { 1818 return __bpf_fill_jmp32_reg(self, BPF_JSET); 1819 } 1820 1821 static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self) 1822 { 1823 return __bpf_fill_jmp32_reg(self, BPF_JEQ); 1824 } 1825 1826 static int bpf_fill_jmp32_jne_reg(struct bpf_test *self) 1827 { 1828 return __bpf_fill_jmp32_reg(self, BPF_JNE); 1829 } 1830 1831 static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self) 1832 { 1833 return __bpf_fill_jmp32_reg(self, BPF_JGT); 1834 } 1835 1836 static int bpf_fill_jmp32_jge_reg(struct bpf_test *self) 1837 { 1838 return __bpf_fill_jmp32_reg(self, BPF_JGE); 1839 } 1840 1841 static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self) 1842 { 1843 return __bpf_fill_jmp32_reg(self, BPF_JLT); 1844 } 1845 1846 static int bpf_fill_jmp32_jle_reg(struct bpf_test *self) 1847 { 1848 return __bpf_fill_jmp32_reg(self, BPF_JLE); 1849 } 1850 1851 static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self) 1852 { 1853 return __bpf_fill_jmp32_reg(self, BPF_JSGT); 1854 } 1855 1856 static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self) 1857 { 1858 return __bpf_fill_jmp32_reg(self, BPF_JSGE); 1859 } 1860 1861 static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self) 1862 { 1863 return __bpf_fill_jmp32_reg(self, BPF_JSLT); 1864 } 1865 1866 static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self) 1867 { 1868 return __bpf_fill_jmp32_reg(self, BPF_JSLE); 1869 } 1870 1871 /* 1872 * Set up a sequence of staggered jumps, forwards and backwards with 1873 * increasing offset. This tests the conversion of relative jumps to 1874 * JITed native jumps. On some architectures, for example MIPS, a large 1875 * PC-relative jump offset may overflow the immediate field of the native 1876 * conditional branch instruction, triggering a conversion to use an 1877 * absolute jump instead. Since this changes the jump offsets, another 1878 * offset computation pass is necessary, and that may in turn trigger 1879 * another branch conversion. This jump sequence is particularly nasty 1880 * in that regard. 1881 * 1882 * The sequence generation is parameterized by size and jump type. 1883 * The size must be even, and the expected result is always size + 1. 1884 * Below is an example with size=8 and result=9. 1885 * 1886 * ________________________Start 1887 * R0 = 0 1888 * R1 = r1 1889 * R2 = r2 1890 * ,------- JMP +4 * 3______________Preamble: 4 insns 1891 * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------. 1892 * | | R0 = 8 | 1893 * | | JMP +7 * 3 ------------------------. 1894 * | ,--------|-----1- if R0 != 5 JMP 7 * 3 + 1 <--------------. | | 1895 * | | | R0 = 6 | | | 1896 * | | | JMP +5 * 3 ------------------. | | 1897 * | | ,------|-----2- if R0 != 3 JMP 6 * 3 + 1 <--------. | | | | 1898 * | | | | R0 = 4 | | | | | 1899 * | | | | JMP +3 * 3 ------------. | | | | 1900 * | | | ,----|-----3- if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | | 1901 * | | | | | R0 = 2 | | | | | | | 1902 * | | | | | JMP +1 * 3 ------. | | | | | | 1903 * | | | | ,--t=====4> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc 1904 * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off 1905 * | | | | | JMP -2 * 3 ---' | | | | | | | 1906 * | | | | | ,------5- if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | | 1907 * | | | | | | R0 = 3 | | | | | | 1908 * | | | | | | JMP -4 * 3 ---------' | | | | | 1909 * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | | 1910 * | | | | | | | R0 = 5 | | | | 1911 * | | | | | | | JMP -6 * 3 ---------------' | | | 1912 * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | | 1913 * | | | | | | | | R0 = 7 | | 1914 * | | Error | | | JMP -8 * 3 ---------------------' | 1915 * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------' 1916 * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns 1917 * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn 1918 * 1919 */ 1920 1921 /* The maximum size parameter */ 1922 #define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1) 1923 1924 /* We use a reduced number of iterations to get a reasonable execution time */ 1925 #define NR_STAGGERED_JMP_RUNS 10 1926 1927 static int __bpf_fill_staggered_jumps(struct bpf_test *self, 1928 const struct bpf_insn *jmp, 1929 u64 r1, u64 r2) 1930 { 1931 int size = self->test[0].result - 1; 1932 int len = 4 + 3 * (size + 1); 1933 struct bpf_insn *insns; 1934 int off, ind; 1935 1936 insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL); 1937 if (!insns) 1938 return -ENOMEM; 1939 1940 /* Preamble */ 1941 insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0); 1942 insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1); 1943 insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2); 1944 insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2); 1945 1946 /* Sequence */ 1947 for (ind = 0, off = size; ind <= size; ind++, off -= 2) { 1948 struct bpf_insn *ins = &insns[4 + 3 * ind]; 1949 int loc; 1950 1951 if (off == 0) 1952 off--; 1953 1954 loc = abs(off); 1955 ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1, 1956 3 * (size - ind) + 1); 1957 ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc); 1958 ins[2] = *jmp; 1959 ins[2].off = 3 * (off - 1); 1960 } 1961 1962 /* Return */ 1963 insns[len - 1] = BPF_EXIT_INSN(); 1964 1965 self->u.ptr.insns = insns; 1966 self->u.ptr.len = len; 1967 1968 return 0; 1969 } 1970 1971 /* 64-bit unconditional jump */ 1972 static int bpf_fill_staggered_ja(struct bpf_test *self) 1973 { 1974 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0); 1975 1976 return __bpf_fill_staggered_jumps(self, &jmp, 0, 0); 1977 } 1978 1979 /* 64-bit immediate jumps */ 1980 static int bpf_fill_staggered_jeq_imm(struct bpf_test *self) 1981 { 1982 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0); 1983 1984 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 1985 } 1986 1987 static int bpf_fill_staggered_jne_imm(struct bpf_test *self) 1988 { 1989 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0); 1990 1991 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0); 1992 } 1993 1994 static int bpf_fill_staggered_jset_imm(struct bpf_test *self) 1995 { 1996 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0); 1997 1998 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0); 1999 } 2000 2001 static int bpf_fill_staggered_jgt_imm(struct bpf_test *self) 2002 { 2003 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0); 2004 2005 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0); 2006 } 2007 2008 static int bpf_fill_staggered_jge_imm(struct bpf_test *self) 2009 { 2010 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0); 2011 2012 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2013 } 2014 2015 static int bpf_fill_staggered_jlt_imm(struct bpf_test *self) 2016 { 2017 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0); 2018 2019 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2020 } 2021 2022 static int bpf_fill_staggered_jle_imm(struct bpf_test *self) 2023 { 2024 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0); 2025 2026 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2027 } 2028 2029 static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self) 2030 { 2031 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0); 2032 2033 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2034 } 2035 2036 static int bpf_fill_staggered_jsge_imm(struct bpf_test *self) 2037 { 2038 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0); 2039 2040 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2041 } 2042 2043 static int bpf_fill_staggered_jslt_imm(struct bpf_test *self) 2044 { 2045 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0); 2046 2047 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2048 } 2049 2050 static int bpf_fill_staggered_jsle_imm(struct bpf_test *self) 2051 { 2052 struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0); 2053 2054 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2055 } 2056 2057 /* 64-bit register jumps */ 2058 static int bpf_fill_staggered_jeq_reg(struct bpf_test *self) 2059 { 2060 struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0); 2061 2062 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2063 } 2064 2065 static int bpf_fill_staggered_jne_reg(struct bpf_test *self) 2066 { 2067 struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0); 2068 2069 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234); 2070 } 2071 2072 static int bpf_fill_staggered_jset_reg(struct bpf_test *self) 2073 { 2074 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0); 2075 2076 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82); 2077 } 2078 2079 static int bpf_fill_staggered_jgt_reg(struct bpf_test *self) 2080 { 2081 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0); 2082 2083 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234); 2084 } 2085 2086 static int bpf_fill_staggered_jge_reg(struct bpf_test *self) 2087 { 2088 struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0); 2089 2090 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2091 } 2092 2093 static int bpf_fill_staggered_jlt_reg(struct bpf_test *self) 2094 { 2095 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0); 2096 2097 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000); 2098 } 2099 2100 static int bpf_fill_staggered_jle_reg(struct bpf_test *self) 2101 { 2102 struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0); 2103 2104 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2105 } 2106 2107 static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self) 2108 { 2109 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0); 2110 2111 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2); 2112 } 2113 2114 static int bpf_fill_staggered_jsge_reg(struct bpf_test *self) 2115 { 2116 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0); 2117 2118 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2); 2119 } 2120 2121 static int bpf_fill_staggered_jslt_reg(struct bpf_test *self) 2122 { 2123 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0); 2124 2125 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1); 2126 } 2127 2128 static int bpf_fill_staggered_jsle_reg(struct bpf_test *self) 2129 { 2130 struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0); 2131 2132 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1); 2133 } 2134 2135 /* 32-bit immediate jumps */ 2136 static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self) 2137 { 2138 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0); 2139 2140 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2141 } 2142 2143 static int bpf_fill_staggered_jne32_imm(struct bpf_test *self) 2144 { 2145 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0); 2146 2147 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0); 2148 } 2149 2150 static int bpf_fill_staggered_jset32_imm(struct bpf_test *self) 2151 { 2152 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0); 2153 2154 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0); 2155 } 2156 2157 static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self) 2158 { 2159 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0); 2160 2161 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0); 2162 } 2163 2164 static int bpf_fill_staggered_jge32_imm(struct bpf_test *self) 2165 { 2166 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0); 2167 2168 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2169 } 2170 2171 static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self) 2172 { 2173 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0); 2174 2175 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2176 } 2177 2178 static int bpf_fill_staggered_jle32_imm(struct bpf_test *self) 2179 { 2180 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0); 2181 2182 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0); 2183 } 2184 2185 static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self) 2186 { 2187 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0); 2188 2189 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2190 } 2191 2192 static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self) 2193 { 2194 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0); 2195 2196 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2197 } 2198 2199 static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self) 2200 { 2201 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0); 2202 2203 return __bpf_fill_staggered_jumps(self, &jmp, -2, 0); 2204 } 2205 2206 static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self) 2207 { 2208 struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0); 2209 2210 return __bpf_fill_staggered_jumps(self, &jmp, -1, 0); 2211 } 2212 2213 /* 32-bit register jumps */ 2214 static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self) 2215 { 2216 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0); 2217 2218 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2219 } 2220 2221 static int bpf_fill_staggered_jne32_reg(struct bpf_test *self) 2222 { 2223 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0); 2224 2225 return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234); 2226 } 2227 2228 static int bpf_fill_staggered_jset32_reg(struct bpf_test *self) 2229 { 2230 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0); 2231 2232 return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82); 2233 } 2234 2235 static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self) 2236 { 2237 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0); 2238 2239 return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234); 2240 } 2241 2242 static int bpf_fill_staggered_jge32_reg(struct bpf_test *self) 2243 { 2244 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0); 2245 2246 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2247 } 2248 2249 static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self) 2250 { 2251 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0); 2252 2253 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000); 2254 } 2255 2256 static int bpf_fill_staggered_jle32_reg(struct bpf_test *self) 2257 { 2258 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0); 2259 2260 return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234); 2261 } 2262 2263 static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self) 2264 { 2265 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0); 2266 2267 return __bpf_fill_staggered_jumps(self, &jmp, -1, -2); 2268 } 2269 2270 static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self) 2271 { 2272 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0); 2273 2274 return __bpf_fill_staggered_jumps(self, &jmp, -2, -2); 2275 } 2276 2277 static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self) 2278 { 2279 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0); 2280 2281 return __bpf_fill_staggered_jumps(self, &jmp, -2, -1); 2282 } 2283 2284 static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self) 2285 { 2286 struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0); 2287 2288 return __bpf_fill_staggered_jumps(self, &jmp, -1, -1); 2289 } 2290 2291 2292 static struct bpf_test tests[] = { 2293 { 2294 "TAX", 2295 .u.insns = { 2296 BPF_STMT(BPF_LD | BPF_IMM, 1), 2297 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2298 BPF_STMT(BPF_LD | BPF_IMM, 2), 2299 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2300 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 2301 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2302 BPF_STMT(BPF_LD | BPF_LEN, 0), 2303 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2304 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 2305 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 2306 BPF_STMT(BPF_RET | BPF_A, 0) 2307 }, 2308 CLASSIC, 2309 { 10, 20, 30, 40, 50 }, 2310 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 2311 }, 2312 { 2313 "TXA", 2314 .u.insns = { 2315 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2316 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2317 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2318 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 2319 }, 2320 CLASSIC, 2321 { 10, 20, 30, 40, 50 }, 2322 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 2323 }, 2324 { 2325 "ADD_SUB_MUL_K", 2326 .u.insns = { 2327 BPF_STMT(BPF_LD | BPF_IMM, 1), 2328 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 2329 BPF_STMT(BPF_LDX | BPF_IMM, 3), 2330 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 2331 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 2332 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 2333 BPF_STMT(BPF_RET | BPF_A, 0) 2334 }, 2335 CLASSIC | FLAG_NO_DATA, 2336 { }, 2337 { { 0, 0xfffffffd } } 2338 }, 2339 { 2340 "DIV_MOD_KX", 2341 .u.insns = { 2342 BPF_STMT(BPF_LD | BPF_IMM, 8), 2343 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 2344 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2345 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 2346 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 2347 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2348 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 2349 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 2350 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2351 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 2352 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 2353 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2354 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 2355 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000), 2356 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2357 BPF_STMT(BPF_RET | BPF_A, 0) 2358 }, 2359 CLASSIC | FLAG_NO_DATA, 2360 { }, 2361 { { 0, 0x20000000 } } 2362 }, 2363 { 2364 "AND_OR_LSH_K", 2365 .u.insns = { 2366 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 2367 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 2368 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 2369 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2370 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 2371 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 2372 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2373 BPF_STMT(BPF_RET | BPF_A, 0) 2374 }, 2375 CLASSIC | FLAG_NO_DATA, 2376 { }, 2377 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 2378 }, 2379 { 2380 "LD_IMM_0", 2381 .u.insns = { 2382 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */ 2383 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), 2384 BPF_STMT(BPF_RET | BPF_K, 0), 2385 BPF_STMT(BPF_RET | BPF_K, 1), 2386 }, 2387 CLASSIC, 2388 { }, 2389 { { 1, 1 } }, 2390 }, 2391 { 2392 "LD_IND", 2393 .u.insns = { 2394 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2395 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 2396 BPF_STMT(BPF_RET | BPF_K, 1) 2397 }, 2398 CLASSIC, 2399 { }, 2400 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 2401 }, 2402 { 2403 "LD_ABS", 2404 .u.insns = { 2405 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 2406 BPF_STMT(BPF_RET | BPF_K, 1) 2407 }, 2408 CLASSIC, 2409 { }, 2410 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 2411 }, 2412 { 2413 "LD_ABS_LL", 2414 .u.insns = { 2415 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 2416 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2417 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 2418 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2419 BPF_STMT(BPF_RET | BPF_A, 0) 2420 }, 2421 CLASSIC, 2422 { 1, 2, 3 }, 2423 { { 1, 0 }, { 2, 3 } }, 2424 }, 2425 { 2426 "LD_IND_LL", 2427 .u.insns = { 2428 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 2429 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2430 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2431 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2432 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 2433 BPF_STMT(BPF_RET | BPF_A, 0) 2434 }, 2435 CLASSIC, 2436 { 1, 2, 3, 0xff }, 2437 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 2438 }, 2439 { 2440 "LD_ABS_NET", 2441 .u.insns = { 2442 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 2443 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2444 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 2445 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2446 BPF_STMT(BPF_RET | BPF_A, 0) 2447 }, 2448 CLASSIC, 2449 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 2450 { { 15, 0 }, { 16, 3 } }, 2451 }, 2452 { 2453 "LD_IND_NET", 2454 .u.insns = { 2455 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 2456 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2457 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 2458 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2459 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 2460 BPF_STMT(BPF_RET | BPF_A, 0) 2461 }, 2462 CLASSIC, 2463 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 2464 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 2465 }, 2466 { 2467 "LD_PKTTYPE", 2468 .u.insns = { 2469 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2470 SKF_AD_OFF + SKF_AD_PKTTYPE), 2471 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 2472 BPF_STMT(BPF_RET | BPF_K, 1), 2473 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2474 SKF_AD_OFF + SKF_AD_PKTTYPE), 2475 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 2476 BPF_STMT(BPF_RET | BPF_K, 1), 2477 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2478 SKF_AD_OFF + SKF_AD_PKTTYPE), 2479 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 2480 BPF_STMT(BPF_RET | BPF_K, 1), 2481 BPF_STMT(BPF_RET | BPF_A, 0) 2482 }, 2483 CLASSIC, 2484 { }, 2485 { { 1, 3 }, { 10, 3 } }, 2486 }, 2487 { 2488 "LD_MARK", 2489 .u.insns = { 2490 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2491 SKF_AD_OFF + SKF_AD_MARK), 2492 BPF_STMT(BPF_RET | BPF_A, 0) 2493 }, 2494 CLASSIC, 2495 { }, 2496 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 2497 }, 2498 { 2499 "LD_RXHASH", 2500 .u.insns = { 2501 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2502 SKF_AD_OFF + SKF_AD_RXHASH), 2503 BPF_STMT(BPF_RET | BPF_A, 0) 2504 }, 2505 CLASSIC, 2506 { }, 2507 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 2508 }, 2509 { 2510 "LD_QUEUE", 2511 .u.insns = { 2512 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2513 SKF_AD_OFF + SKF_AD_QUEUE), 2514 BPF_STMT(BPF_RET | BPF_A, 0) 2515 }, 2516 CLASSIC, 2517 { }, 2518 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 2519 }, 2520 { 2521 "LD_PROTOCOL", 2522 .u.insns = { 2523 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 2524 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 2525 BPF_STMT(BPF_RET | BPF_K, 0), 2526 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2527 SKF_AD_OFF + SKF_AD_PROTOCOL), 2528 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2529 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 2530 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 2531 BPF_STMT(BPF_RET | BPF_K, 0), 2532 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2533 BPF_STMT(BPF_RET | BPF_A, 0) 2534 }, 2535 CLASSIC, 2536 { 10, 20, 30 }, 2537 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 2538 }, 2539 { 2540 "LD_VLAN_TAG", 2541 .u.insns = { 2542 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2543 SKF_AD_OFF + SKF_AD_VLAN_TAG), 2544 BPF_STMT(BPF_RET | BPF_A, 0) 2545 }, 2546 CLASSIC, 2547 { }, 2548 { 2549 { 1, SKB_VLAN_TCI }, 2550 { 10, SKB_VLAN_TCI } 2551 }, 2552 }, 2553 { 2554 "LD_VLAN_TAG_PRESENT", 2555 .u.insns = { 2556 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2557 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 2558 BPF_STMT(BPF_RET | BPF_A, 0) 2559 }, 2560 CLASSIC, 2561 { }, 2562 { 2563 { 1, SKB_VLAN_PRESENT }, 2564 { 10, SKB_VLAN_PRESENT } 2565 }, 2566 }, 2567 { 2568 "LD_IFINDEX", 2569 .u.insns = { 2570 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2571 SKF_AD_OFF + SKF_AD_IFINDEX), 2572 BPF_STMT(BPF_RET | BPF_A, 0) 2573 }, 2574 CLASSIC, 2575 { }, 2576 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 2577 }, 2578 { 2579 "LD_HATYPE", 2580 .u.insns = { 2581 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2582 SKF_AD_OFF + SKF_AD_HATYPE), 2583 BPF_STMT(BPF_RET | BPF_A, 0) 2584 }, 2585 CLASSIC, 2586 { }, 2587 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 2588 }, 2589 { 2590 "LD_CPU", 2591 .u.insns = { 2592 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2593 SKF_AD_OFF + SKF_AD_CPU), 2594 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2595 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2596 SKF_AD_OFF + SKF_AD_CPU), 2597 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 2598 BPF_STMT(BPF_RET | BPF_A, 0) 2599 }, 2600 CLASSIC, 2601 { }, 2602 { { 1, 0 }, { 10, 0 } }, 2603 }, 2604 { 2605 "LD_NLATTR", 2606 .u.insns = { 2607 BPF_STMT(BPF_LDX | BPF_IMM, 2), 2608 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2609 BPF_STMT(BPF_LDX | BPF_IMM, 3), 2610 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2611 SKF_AD_OFF + SKF_AD_NLATTR), 2612 BPF_STMT(BPF_RET | BPF_A, 0) 2613 }, 2614 CLASSIC, 2615 #ifdef __BIG_ENDIAN 2616 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 }, 2617 #else 2618 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 2619 #endif 2620 { { 4, 0 }, { 20, 6 } }, 2621 }, 2622 { 2623 "LD_NLATTR_NEST", 2624 .u.insns = { 2625 BPF_STMT(BPF_LD | BPF_IMM, 2), 2626 BPF_STMT(BPF_LDX | BPF_IMM, 3), 2627 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2628 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2629 BPF_STMT(BPF_LD | BPF_IMM, 2), 2630 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2631 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2632 BPF_STMT(BPF_LD | BPF_IMM, 2), 2633 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2634 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2635 BPF_STMT(BPF_LD | BPF_IMM, 2), 2636 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2637 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2638 BPF_STMT(BPF_LD | BPF_IMM, 2), 2639 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2640 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2641 BPF_STMT(BPF_LD | BPF_IMM, 2), 2642 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2643 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2644 BPF_STMT(BPF_LD | BPF_IMM, 2), 2645 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2646 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2647 BPF_STMT(BPF_LD | BPF_IMM, 2), 2648 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2649 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 2650 BPF_STMT(BPF_RET | BPF_A, 0) 2651 }, 2652 CLASSIC, 2653 #ifdef __BIG_ENDIAN 2654 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 }, 2655 #else 2656 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 2657 #endif 2658 { { 4, 0 }, { 20, 10 } }, 2659 }, 2660 { 2661 "LD_PAYLOAD_OFF", 2662 .u.insns = { 2663 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2664 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 2665 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2666 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 2667 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2668 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 2669 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2670 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 2671 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2672 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 2673 BPF_STMT(BPF_RET | BPF_A, 0) 2674 }, 2675 CLASSIC, 2676 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 2677 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 2678 * id 9737, seq 1, length 64 2679 */ 2680 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 2681 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 2682 0x08, 0x00, 2683 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 2684 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 2685 { { 30, 0 }, { 100, 42 } }, 2686 }, 2687 { 2688 "LD_ANC_XOR", 2689 .u.insns = { 2690 BPF_STMT(BPF_LD | BPF_IMM, 10), 2691 BPF_STMT(BPF_LDX | BPF_IMM, 300), 2692 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 2693 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 2694 BPF_STMT(BPF_RET | BPF_A, 0) 2695 }, 2696 CLASSIC, 2697 { }, 2698 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } }, 2699 }, 2700 { 2701 "SPILL_FILL", 2702 .u.insns = { 2703 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2704 BPF_STMT(BPF_LD | BPF_IMM, 2), 2705 BPF_STMT(BPF_ALU | BPF_RSH, 1), 2706 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 2707 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 2708 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 2709 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 2710 BPF_STMT(BPF_STX, 15), /* M3 = len */ 2711 BPF_STMT(BPF_LDX | BPF_MEM, 1), 2712 BPF_STMT(BPF_LD | BPF_MEM, 2), 2713 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 2714 BPF_STMT(BPF_LDX | BPF_MEM, 15), 2715 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 2716 BPF_STMT(BPF_RET | BPF_A, 0) 2717 }, 2718 CLASSIC, 2719 { }, 2720 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 2721 }, 2722 { 2723 "JEQ", 2724 .u.insns = { 2725 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2726 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 2727 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 2728 BPF_STMT(BPF_RET | BPF_K, 1), 2729 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2730 }, 2731 CLASSIC, 2732 { 3, 3, 3, 3, 3 }, 2733 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 2734 }, 2735 { 2736 "JGT", 2737 .u.insns = { 2738 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2739 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 2740 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 2741 BPF_STMT(BPF_RET | BPF_K, 1), 2742 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2743 }, 2744 CLASSIC, 2745 { 4, 4, 4, 3, 3 }, 2746 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 2747 }, 2748 { 2749 "JGE (jt 0), test 1", 2750 .u.insns = { 2751 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2752 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 2753 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 2754 BPF_STMT(BPF_RET | BPF_K, 1), 2755 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2756 }, 2757 CLASSIC, 2758 { 4, 4, 4, 3, 3 }, 2759 { { 2, 0 }, { 3, 1 }, { 4, 1 } }, 2760 }, 2761 { 2762 "JGE (jt 0), test 2", 2763 .u.insns = { 2764 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2765 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 2766 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1), 2767 BPF_STMT(BPF_RET | BPF_K, 1), 2768 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2769 }, 2770 CLASSIC, 2771 { 4, 4, 5, 3, 3 }, 2772 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } }, 2773 }, 2774 { 2775 "JGE", 2776 .u.insns = { 2777 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2778 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 2779 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 2780 BPF_STMT(BPF_RET | BPF_K, 10), 2781 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 2782 BPF_STMT(BPF_RET | BPF_K, 20), 2783 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 2784 BPF_STMT(BPF_RET | BPF_K, 30), 2785 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 2786 BPF_STMT(BPF_RET | BPF_K, 40), 2787 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2788 }, 2789 CLASSIC, 2790 { 1, 2, 3, 4, 5 }, 2791 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 2792 }, 2793 { 2794 "JSET", 2795 .u.insns = { 2796 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 2797 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 2798 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 2799 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 2800 BPF_STMT(BPF_LDX | BPF_LEN, 0), 2801 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2802 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 2803 BPF_STMT(BPF_MISC | BPF_TAX, 0), 2804 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 2805 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 2806 BPF_STMT(BPF_RET | BPF_K, 10), 2807 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 2808 BPF_STMT(BPF_RET | BPF_K, 20), 2809 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 2810 BPF_STMT(BPF_RET | BPF_K, 30), 2811 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 2812 BPF_STMT(BPF_RET | BPF_K, 30), 2813 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 2814 BPF_STMT(BPF_RET | BPF_K, 30), 2815 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 2816 BPF_STMT(BPF_RET | BPF_K, 30), 2817 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 2818 BPF_STMT(BPF_RET | BPF_K, 30), 2819 BPF_STMT(BPF_RET | BPF_K, MAX_K) 2820 }, 2821 CLASSIC, 2822 { 0, 0xAA, 0x55, 1 }, 2823 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 2824 }, 2825 { 2826 "tcpdump port 22", 2827 .u.insns = { 2828 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 2829 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */ 2830 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20), 2831 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 2832 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 2833 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17), 2834 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54), 2835 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0), 2836 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56), 2837 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13), 2838 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */ 2839 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 2840 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 2841 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 2842 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8), 2843 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 2844 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0), 2845 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 2846 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 2847 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 2848 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 2849 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1), 2850 BPF_STMT(BPF_RET | BPF_K, 0xffff), 2851 BPF_STMT(BPF_RET | BPF_K, 0), 2852 }, 2853 CLASSIC, 2854 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 2855 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 2856 * seq 1305692979:1305693027, ack 3650467037, win 65535, 2857 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 2858 */ 2859 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 2860 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 2861 0x08, 0x00, 2862 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 2863 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 2864 0x0a, 0x01, 0x01, 0x95, /* ip src */ 2865 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 2866 0xc2, 0x24, 2867 0x00, 0x16 /* dst port */ }, 2868 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 2869 }, 2870 { 2871 "tcpdump complex", 2872 .u.insns = { 2873 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 2874 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 2875 * (len > 115 or len < 30000000000)' -d 2876 */ 2877 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 2878 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0), 2879 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29), 2880 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 2881 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27), 2882 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 2883 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0), 2884 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 2885 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 2886 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 2887 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 2888 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20), 2889 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16), 2890 BPF_STMT(BPF_ST, 1), 2891 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14), 2892 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf), 2893 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2), 2894 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */ 2895 BPF_STMT(BPF_LD | BPF_MEM, 1), 2896 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 2897 BPF_STMT(BPF_ST, 5), 2898 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 2899 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26), 2900 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 2901 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2), 2902 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */ 2903 BPF_STMT(BPF_LD | BPF_MEM, 5), 2904 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0), 2905 BPF_STMT(BPF_LD | BPF_LEN, 0), 2906 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0), 2907 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0), 2908 BPF_STMT(BPF_RET | BPF_K, 0xffff), 2909 BPF_STMT(BPF_RET | BPF_K, 0), 2910 }, 2911 CLASSIC, 2912 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 2913 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 2914 0x08, 0x00, 2915 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 2916 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 2917 0x0a, 0x01, 0x01, 0x95, /* ip src */ 2918 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 2919 0xc2, 0x24, 2920 0x00, 0x16 /* dst port */ }, 2921 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 2922 }, 2923 { 2924 "RET_A", 2925 .u.insns = { 2926 /* check that uninitialized X and A contain zeros */ 2927 BPF_STMT(BPF_MISC | BPF_TXA, 0), 2928 BPF_STMT(BPF_RET | BPF_A, 0) 2929 }, 2930 CLASSIC, 2931 { }, 2932 { {1, 0}, {2, 0} }, 2933 }, 2934 { 2935 "INT: ADD trivial", 2936 .u.insns_int = { 2937 BPF_ALU64_IMM(BPF_MOV, R1, 1), 2938 BPF_ALU64_IMM(BPF_ADD, R1, 2), 2939 BPF_ALU64_IMM(BPF_MOV, R2, 3), 2940 BPF_ALU64_REG(BPF_SUB, R1, R2), 2941 BPF_ALU64_IMM(BPF_ADD, R1, -1), 2942 BPF_ALU64_IMM(BPF_MUL, R1, 3), 2943 BPF_ALU64_REG(BPF_MOV, R0, R1), 2944 BPF_EXIT_INSN(), 2945 }, 2946 INTERNAL, 2947 { }, 2948 { { 0, 0xfffffffd } } 2949 }, 2950 { 2951 "INT: MUL_X", 2952 .u.insns_int = { 2953 BPF_ALU64_IMM(BPF_MOV, R0, -1), 2954 BPF_ALU64_IMM(BPF_MOV, R1, -1), 2955 BPF_ALU64_IMM(BPF_MOV, R2, 3), 2956 BPF_ALU64_REG(BPF_MUL, R1, R2), 2957 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 2958 BPF_EXIT_INSN(), 2959 BPF_ALU64_IMM(BPF_MOV, R0, 1), 2960 BPF_EXIT_INSN(), 2961 }, 2962 INTERNAL, 2963 { }, 2964 { { 0, 1 } } 2965 }, 2966 { 2967 "INT: MUL_X2", 2968 .u.insns_int = { 2969 BPF_ALU32_IMM(BPF_MOV, R0, -1), 2970 BPF_ALU32_IMM(BPF_MOV, R1, -1), 2971 BPF_ALU32_IMM(BPF_MOV, R2, 3), 2972 BPF_ALU64_REG(BPF_MUL, R1, R2), 2973 BPF_ALU64_IMM(BPF_RSH, R1, 8), 2974 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 2975 BPF_EXIT_INSN(), 2976 BPF_ALU32_IMM(BPF_MOV, R0, 1), 2977 BPF_EXIT_INSN(), 2978 }, 2979 INTERNAL, 2980 { }, 2981 { { 0, 1 } } 2982 }, 2983 { 2984 "INT: MUL32_X", 2985 .u.insns_int = { 2986 BPF_ALU32_IMM(BPF_MOV, R0, -1), 2987 BPF_ALU64_IMM(BPF_MOV, R1, -1), 2988 BPF_ALU32_IMM(BPF_MOV, R2, 3), 2989 BPF_ALU32_REG(BPF_MUL, R1, R2), 2990 BPF_ALU64_IMM(BPF_RSH, R1, 8), 2991 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 2992 BPF_EXIT_INSN(), 2993 BPF_ALU32_IMM(BPF_MOV, R0, 1), 2994 BPF_EXIT_INSN(), 2995 }, 2996 INTERNAL, 2997 { }, 2998 { { 0, 1 } } 2999 }, 3000 { 3001 /* Have to test all register combinations, since 3002 * JITing of different registers will produce 3003 * different asm code. 3004 */ 3005 "INT: ADD 64-bit", 3006 .u.insns_int = { 3007 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3008 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3009 BPF_ALU64_IMM(BPF_MOV, R2, 2), 3010 BPF_ALU64_IMM(BPF_MOV, R3, 3), 3011 BPF_ALU64_IMM(BPF_MOV, R4, 4), 3012 BPF_ALU64_IMM(BPF_MOV, R5, 5), 3013 BPF_ALU64_IMM(BPF_MOV, R6, 6), 3014 BPF_ALU64_IMM(BPF_MOV, R7, 7), 3015 BPF_ALU64_IMM(BPF_MOV, R8, 8), 3016 BPF_ALU64_IMM(BPF_MOV, R9, 9), 3017 BPF_ALU64_IMM(BPF_ADD, R0, 20), 3018 BPF_ALU64_IMM(BPF_ADD, R1, 20), 3019 BPF_ALU64_IMM(BPF_ADD, R2, 20), 3020 BPF_ALU64_IMM(BPF_ADD, R3, 20), 3021 BPF_ALU64_IMM(BPF_ADD, R4, 20), 3022 BPF_ALU64_IMM(BPF_ADD, R5, 20), 3023 BPF_ALU64_IMM(BPF_ADD, R6, 20), 3024 BPF_ALU64_IMM(BPF_ADD, R7, 20), 3025 BPF_ALU64_IMM(BPF_ADD, R8, 20), 3026 BPF_ALU64_IMM(BPF_ADD, R9, 20), 3027 BPF_ALU64_IMM(BPF_SUB, R0, 10), 3028 BPF_ALU64_IMM(BPF_SUB, R1, 10), 3029 BPF_ALU64_IMM(BPF_SUB, R2, 10), 3030 BPF_ALU64_IMM(BPF_SUB, R3, 10), 3031 BPF_ALU64_IMM(BPF_SUB, R4, 10), 3032 BPF_ALU64_IMM(BPF_SUB, R5, 10), 3033 BPF_ALU64_IMM(BPF_SUB, R6, 10), 3034 BPF_ALU64_IMM(BPF_SUB, R7, 10), 3035 BPF_ALU64_IMM(BPF_SUB, R8, 10), 3036 BPF_ALU64_IMM(BPF_SUB, R9, 10), 3037 BPF_ALU64_REG(BPF_ADD, R0, R0), 3038 BPF_ALU64_REG(BPF_ADD, R0, R1), 3039 BPF_ALU64_REG(BPF_ADD, R0, R2), 3040 BPF_ALU64_REG(BPF_ADD, R0, R3), 3041 BPF_ALU64_REG(BPF_ADD, R0, R4), 3042 BPF_ALU64_REG(BPF_ADD, R0, R5), 3043 BPF_ALU64_REG(BPF_ADD, R0, R6), 3044 BPF_ALU64_REG(BPF_ADD, R0, R7), 3045 BPF_ALU64_REG(BPF_ADD, R0, R8), 3046 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 3047 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 3048 BPF_EXIT_INSN(), 3049 BPF_ALU64_REG(BPF_ADD, R1, R0), 3050 BPF_ALU64_REG(BPF_ADD, R1, R1), 3051 BPF_ALU64_REG(BPF_ADD, R1, R2), 3052 BPF_ALU64_REG(BPF_ADD, R1, R3), 3053 BPF_ALU64_REG(BPF_ADD, R1, R4), 3054 BPF_ALU64_REG(BPF_ADD, R1, R5), 3055 BPF_ALU64_REG(BPF_ADD, R1, R6), 3056 BPF_ALU64_REG(BPF_ADD, R1, R7), 3057 BPF_ALU64_REG(BPF_ADD, R1, R8), 3058 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 3059 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 3060 BPF_EXIT_INSN(), 3061 BPF_ALU64_REG(BPF_ADD, R2, R0), 3062 BPF_ALU64_REG(BPF_ADD, R2, R1), 3063 BPF_ALU64_REG(BPF_ADD, R2, R2), 3064 BPF_ALU64_REG(BPF_ADD, R2, R3), 3065 BPF_ALU64_REG(BPF_ADD, R2, R4), 3066 BPF_ALU64_REG(BPF_ADD, R2, R5), 3067 BPF_ALU64_REG(BPF_ADD, R2, R6), 3068 BPF_ALU64_REG(BPF_ADD, R2, R7), 3069 BPF_ALU64_REG(BPF_ADD, R2, R8), 3070 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 3071 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 3072 BPF_EXIT_INSN(), 3073 BPF_ALU64_REG(BPF_ADD, R3, R0), 3074 BPF_ALU64_REG(BPF_ADD, R3, R1), 3075 BPF_ALU64_REG(BPF_ADD, R3, R2), 3076 BPF_ALU64_REG(BPF_ADD, R3, R3), 3077 BPF_ALU64_REG(BPF_ADD, R3, R4), 3078 BPF_ALU64_REG(BPF_ADD, R3, R5), 3079 BPF_ALU64_REG(BPF_ADD, R3, R6), 3080 BPF_ALU64_REG(BPF_ADD, R3, R7), 3081 BPF_ALU64_REG(BPF_ADD, R3, R8), 3082 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 3083 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 3084 BPF_EXIT_INSN(), 3085 BPF_ALU64_REG(BPF_ADD, R4, R0), 3086 BPF_ALU64_REG(BPF_ADD, R4, R1), 3087 BPF_ALU64_REG(BPF_ADD, R4, R2), 3088 BPF_ALU64_REG(BPF_ADD, R4, R3), 3089 BPF_ALU64_REG(BPF_ADD, R4, R4), 3090 BPF_ALU64_REG(BPF_ADD, R4, R5), 3091 BPF_ALU64_REG(BPF_ADD, R4, R6), 3092 BPF_ALU64_REG(BPF_ADD, R4, R7), 3093 BPF_ALU64_REG(BPF_ADD, R4, R8), 3094 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 3095 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 3096 BPF_EXIT_INSN(), 3097 BPF_ALU64_REG(BPF_ADD, R5, R0), 3098 BPF_ALU64_REG(BPF_ADD, R5, R1), 3099 BPF_ALU64_REG(BPF_ADD, R5, R2), 3100 BPF_ALU64_REG(BPF_ADD, R5, R3), 3101 BPF_ALU64_REG(BPF_ADD, R5, R4), 3102 BPF_ALU64_REG(BPF_ADD, R5, R5), 3103 BPF_ALU64_REG(BPF_ADD, R5, R6), 3104 BPF_ALU64_REG(BPF_ADD, R5, R7), 3105 BPF_ALU64_REG(BPF_ADD, R5, R8), 3106 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 3107 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 3108 BPF_EXIT_INSN(), 3109 BPF_ALU64_REG(BPF_ADD, R6, R0), 3110 BPF_ALU64_REG(BPF_ADD, R6, R1), 3111 BPF_ALU64_REG(BPF_ADD, R6, R2), 3112 BPF_ALU64_REG(BPF_ADD, R6, R3), 3113 BPF_ALU64_REG(BPF_ADD, R6, R4), 3114 BPF_ALU64_REG(BPF_ADD, R6, R5), 3115 BPF_ALU64_REG(BPF_ADD, R6, R6), 3116 BPF_ALU64_REG(BPF_ADD, R6, R7), 3117 BPF_ALU64_REG(BPF_ADD, R6, R8), 3118 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 3119 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 3120 BPF_EXIT_INSN(), 3121 BPF_ALU64_REG(BPF_ADD, R7, R0), 3122 BPF_ALU64_REG(BPF_ADD, R7, R1), 3123 BPF_ALU64_REG(BPF_ADD, R7, R2), 3124 BPF_ALU64_REG(BPF_ADD, R7, R3), 3125 BPF_ALU64_REG(BPF_ADD, R7, R4), 3126 BPF_ALU64_REG(BPF_ADD, R7, R5), 3127 BPF_ALU64_REG(BPF_ADD, R7, R6), 3128 BPF_ALU64_REG(BPF_ADD, R7, R7), 3129 BPF_ALU64_REG(BPF_ADD, R7, R8), 3130 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 3131 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 3132 BPF_EXIT_INSN(), 3133 BPF_ALU64_REG(BPF_ADD, R8, R0), 3134 BPF_ALU64_REG(BPF_ADD, R8, R1), 3135 BPF_ALU64_REG(BPF_ADD, R8, R2), 3136 BPF_ALU64_REG(BPF_ADD, R8, R3), 3137 BPF_ALU64_REG(BPF_ADD, R8, R4), 3138 BPF_ALU64_REG(BPF_ADD, R8, R5), 3139 BPF_ALU64_REG(BPF_ADD, R8, R6), 3140 BPF_ALU64_REG(BPF_ADD, R8, R7), 3141 BPF_ALU64_REG(BPF_ADD, R8, R8), 3142 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 3143 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 3144 BPF_EXIT_INSN(), 3145 BPF_ALU64_REG(BPF_ADD, R9, R0), 3146 BPF_ALU64_REG(BPF_ADD, R9, R1), 3147 BPF_ALU64_REG(BPF_ADD, R9, R2), 3148 BPF_ALU64_REG(BPF_ADD, R9, R3), 3149 BPF_ALU64_REG(BPF_ADD, R9, R4), 3150 BPF_ALU64_REG(BPF_ADD, R9, R5), 3151 BPF_ALU64_REG(BPF_ADD, R9, R6), 3152 BPF_ALU64_REG(BPF_ADD, R9, R7), 3153 BPF_ALU64_REG(BPF_ADD, R9, R8), 3154 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 3155 BPF_ALU64_REG(BPF_MOV, R0, R9), 3156 BPF_EXIT_INSN(), 3157 }, 3158 INTERNAL, 3159 { }, 3160 { { 0, 2957380 } } 3161 }, 3162 { 3163 "INT: ADD 32-bit", 3164 .u.insns_int = { 3165 BPF_ALU32_IMM(BPF_MOV, R0, 20), 3166 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3167 BPF_ALU32_IMM(BPF_MOV, R2, 2), 3168 BPF_ALU32_IMM(BPF_MOV, R3, 3), 3169 BPF_ALU32_IMM(BPF_MOV, R4, 4), 3170 BPF_ALU32_IMM(BPF_MOV, R5, 5), 3171 BPF_ALU32_IMM(BPF_MOV, R6, 6), 3172 BPF_ALU32_IMM(BPF_MOV, R7, 7), 3173 BPF_ALU32_IMM(BPF_MOV, R8, 8), 3174 BPF_ALU32_IMM(BPF_MOV, R9, 9), 3175 BPF_ALU64_IMM(BPF_ADD, R1, 10), 3176 BPF_ALU64_IMM(BPF_ADD, R2, 10), 3177 BPF_ALU64_IMM(BPF_ADD, R3, 10), 3178 BPF_ALU64_IMM(BPF_ADD, R4, 10), 3179 BPF_ALU64_IMM(BPF_ADD, R5, 10), 3180 BPF_ALU64_IMM(BPF_ADD, R6, 10), 3181 BPF_ALU64_IMM(BPF_ADD, R7, 10), 3182 BPF_ALU64_IMM(BPF_ADD, R8, 10), 3183 BPF_ALU64_IMM(BPF_ADD, R9, 10), 3184 BPF_ALU32_REG(BPF_ADD, R0, R1), 3185 BPF_ALU32_REG(BPF_ADD, R0, R2), 3186 BPF_ALU32_REG(BPF_ADD, R0, R3), 3187 BPF_ALU32_REG(BPF_ADD, R0, R4), 3188 BPF_ALU32_REG(BPF_ADD, R0, R5), 3189 BPF_ALU32_REG(BPF_ADD, R0, R6), 3190 BPF_ALU32_REG(BPF_ADD, R0, R7), 3191 BPF_ALU32_REG(BPF_ADD, R0, R8), 3192 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 3193 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 3194 BPF_EXIT_INSN(), 3195 BPF_ALU32_REG(BPF_ADD, R1, R0), 3196 BPF_ALU32_REG(BPF_ADD, R1, R1), 3197 BPF_ALU32_REG(BPF_ADD, R1, R2), 3198 BPF_ALU32_REG(BPF_ADD, R1, R3), 3199 BPF_ALU32_REG(BPF_ADD, R1, R4), 3200 BPF_ALU32_REG(BPF_ADD, R1, R5), 3201 BPF_ALU32_REG(BPF_ADD, R1, R6), 3202 BPF_ALU32_REG(BPF_ADD, R1, R7), 3203 BPF_ALU32_REG(BPF_ADD, R1, R8), 3204 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 3205 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 3206 BPF_EXIT_INSN(), 3207 BPF_ALU32_REG(BPF_ADD, R2, R0), 3208 BPF_ALU32_REG(BPF_ADD, R2, R1), 3209 BPF_ALU32_REG(BPF_ADD, R2, R2), 3210 BPF_ALU32_REG(BPF_ADD, R2, R3), 3211 BPF_ALU32_REG(BPF_ADD, R2, R4), 3212 BPF_ALU32_REG(BPF_ADD, R2, R5), 3213 BPF_ALU32_REG(BPF_ADD, R2, R6), 3214 BPF_ALU32_REG(BPF_ADD, R2, R7), 3215 BPF_ALU32_REG(BPF_ADD, R2, R8), 3216 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 3217 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 3218 BPF_EXIT_INSN(), 3219 BPF_ALU32_REG(BPF_ADD, R3, R0), 3220 BPF_ALU32_REG(BPF_ADD, R3, R1), 3221 BPF_ALU32_REG(BPF_ADD, R3, R2), 3222 BPF_ALU32_REG(BPF_ADD, R3, R3), 3223 BPF_ALU32_REG(BPF_ADD, R3, R4), 3224 BPF_ALU32_REG(BPF_ADD, R3, R5), 3225 BPF_ALU32_REG(BPF_ADD, R3, R6), 3226 BPF_ALU32_REG(BPF_ADD, R3, R7), 3227 BPF_ALU32_REG(BPF_ADD, R3, R8), 3228 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 3229 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 3230 BPF_EXIT_INSN(), 3231 BPF_ALU32_REG(BPF_ADD, R4, R0), 3232 BPF_ALU32_REG(BPF_ADD, R4, R1), 3233 BPF_ALU32_REG(BPF_ADD, R4, R2), 3234 BPF_ALU32_REG(BPF_ADD, R4, R3), 3235 BPF_ALU32_REG(BPF_ADD, R4, R4), 3236 BPF_ALU32_REG(BPF_ADD, R4, R5), 3237 BPF_ALU32_REG(BPF_ADD, R4, R6), 3238 BPF_ALU32_REG(BPF_ADD, R4, R7), 3239 BPF_ALU32_REG(BPF_ADD, R4, R8), 3240 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 3241 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 3242 BPF_EXIT_INSN(), 3243 BPF_ALU32_REG(BPF_ADD, R5, R0), 3244 BPF_ALU32_REG(BPF_ADD, R5, R1), 3245 BPF_ALU32_REG(BPF_ADD, R5, R2), 3246 BPF_ALU32_REG(BPF_ADD, R5, R3), 3247 BPF_ALU32_REG(BPF_ADD, R5, R4), 3248 BPF_ALU32_REG(BPF_ADD, R5, R5), 3249 BPF_ALU32_REG(BPF_ADD, R5, R6), 3250 BPF_ALU32_REG(BPF_ADD, R5, R7), 3251 BPF_ALU32_REG(BPF_ADD, R5, R8), 3252 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 3253 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 3254 BPF_EXIT_INSN(), 3255 BPF_ALU32_REG(BPF_ADD, R6, R0), 3256 BPF_ALU32_REG(BPF_ADD, R6, R1), 3257 BPF_ALU32_REG(BPF_ADD, R6, R2), 3258 BPF_ALU32_REG(BPF_ADD, R6, R3), 3259 BPF_ALU32_REG(BPF_ADD, R6, R4), 3260 BPF_ALU32_REG(BPF_ADD, R6, R5), 3261 BPF_ALU32_REG(BPF_ADD, R6, R6), 3262 BPF_ALU32_REG(BPF_ADD, R6, R7), 3263 BPF_ALU32_REG(BPF_ADD, R6, R8), 3264 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 3265 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 3266 BPF_EXIT_INSN(), 3267 BPF_ALU32_REG(BPF_ADD, R7, R0), 3268 BPF_ALU32_REG(BPF_ADD, R7, R1), 3269 BPF_ALU32_REG(BPF_ADD, R7, R2), 3270 BPF_ALU32_REG(BPF_ADD, R7, R3), 3271 BPF_ALU32_REG(BPF_ADD, R7, R4), 3272 BPF_ALU32_REG(BPF_ADD, R7, R5), 3273 BPF_ALU32_REG(BPF_ADD, R7, R6), 3274 BPF_ALU32_REG(BPF_ADD, R7, R7), 3275 BPF_ALU32_REG(BPF_ADD, R7, R8), 3276 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 3277 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 3278 BPF_EXIT_INSN(), 3279 BPF_ALU32_REG(BPF_ADD, R8, R0), 3280 BPF_ALU32_REG(BPF_ADD, R8, R1), 3281 BPF_ALU32_REG(BPF_ADD, R8, R2), 3282 BPF_ALU32_REG(BPF_ADD, R8, R3), 3283 BPF_ALU32_REG(BPF_ADD, R8, R4), 3284 BPF_ALU32_REG(BPF_ADD, R8, R5), 3285 BPF_ALU32_REG(BPF_ADD, R8, R6), 3286 BPF_ALU32_REG(BPF_ADD, R8, R7), 3287 BPF_ALU32_REG(BPF_ADD, R8, R8), 3288 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 3289 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 3290 BPF_EXIT_INSN(), 3291 BPF_ALU32_REG(BPF_ADD, R9, R0), 3292 BPF_ALU32_REG(BPF_ADD, R9, R1), 3293 BPF_ALU32_REG(BPF_ADD, R9, R2), 3294 BPF_ALU32_REG(BPF_ADD, R9, R3), 3295 BPF_ALU32_REG(BPF_ADD, R9, R4), 3296 BPF_ALU32_REG(BPF_ADD, R9, R5), 3297 BPF_ALU32_REG(BPF_ADD, R9, R6), 3298 BPF_ALU32_REG(BPF_ADD, R9, R7), 3299 BPF_ALU32_REG(BPF_ADD, R9, R8), 3300 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 3301 BPF_ALU32_REG(BPF_MOV, R0, R9), 3302 BPF_EXIT_INSN(), 3303 }, 3304 INTERNAL, 3305 { }, 3306 { { 0, 2957380 } } 3307 }, 3308 { /* Mainly checking JIT here. */ 3309 "INT: SUB", 3310 .u.insns_int = { 3311 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3312 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3313 BPF_ALU64_IMM(BPF_MOV, R2, 2), 3314 BPF_ALU64_IMM(BPF_MOV, R3, 3), 3315 BPF_ALU64_IMM(BPF_MOV, R4, 4), 3316 BPF_ALU64_IMM(BPF_MOV, R5, 5), 3317 BPF_ALU64_IMM(BPF_MOV, R6, 6), 3318 BPF_ALU64_IMM(BPF_MOV, R7, 7), 3319 BPF_ALU64_IMM(BPF_MOV, R8, 8), 3320 BPF_ALU64_IMM(BPF_MOV, R9, 9), 3321 BPF_ALU64_REG(BPF_SUB, R0, R0), 3322 BPF_ALU64_REG(BPF_SUB, R0, R1), 3323 BPF_ALU64_REG(BPF_SUB, R0, R2), 3324 BPF_ALU64_REG(BPF_SUB, R0, R3), 3325 BPF_ALU64_REG(BPF_SUB, R0, R4), 3326 BPF_ALU64_REG(BPF_SUB, R0, R5), 3327 BPF_ALU64_REG(BPF_SUB, R0, R6), 3328 BPF_ALU64_REG(BPF_SUB, R0, R7), 3329 BPF_ALU64_REG(BPF_SUB, R0, R8), 3330 BPF_ALU64_REG(BPF_SUB, R0, R9), 3331 BPF_ALU64_IMM(BPF_SUB, R0, 10), 3332 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 3333 BPF_EXIT_INSN(), 3334 BPF_ALU64_REG(BPF_SUB, R1, R0), 3335 BPF_ALU64_REG(BPF_SUB, R1, R2), 3336 BPF_ALU64_REG(BPF_SUB, R1, R3), 3337 BPF_ALU64_REG(BPF_SUB, R1, R4), 3338 BPF_ALU64_REG(BPF_SUB, R1, R5), 3339 BPF_ALU64_REG(BPF_SUB, R1, R6), 3340 BPF_ALU64_REG(BPF_SUB, R1, R7), 3341 BPF_ALU64_REG(BPF_SUB, R1, R8), 3342 BPF_ALU64_REG(BPF_SUB, R1, R9), 3343 BPF_ALU64_IMM(BPF_SUB, R1, 10), 3344 BPF_ALU64_REG(BPF_SUB, R2, R0), 3345 BPF_ALU64_REG(BPF_SUB, R2, R1), 3346 BPF_ALU64_REG(BPF_SUB, R2, R3), 3347 BPF_ALU64_REG(BPF_SUB, R2, R4), 3348 BPF_ALU64_REG(BPF_SUB, R2, R5), 3349 BPF_ALU64_REG(BPF_SUB, R2, R6), 3350 BPF_ALU64_REG(BPF_SUB, R2, R7), 3351 BPF_ALU64_REG(BPF_SUB, R2, R8), 3352 BPF_ALU64_REG(BPF_SUB, R2, R9), 3353 BPF_ALU64_IMM(BPF_SUB, R2, 10), 3354 BPF_ALU64_REG(BPF_SUB, R3, R0), 3355 BPF_ALU64_REG(BPF_SUB, R3, R1), 3356 BPF_ALU64_REG(BPF_SUB, R3, R2), 3357 BPF_ALU64_REG(BPF_SUB, R3, R4), 3358 BPF_ALU64_REG(BPF_SUB, R3, R5), 3359 BPF_ALU64_REG(BPF_SUB, R3, R6), 3360 BPF_ALU64_REG(BPF_SUB, R3, R7), 3361 BPF_ALU64_REG(BPF_SUB, R3, R8), 3362 BPF_ALU64_REG(BPF_SUB, R3, R9), 3363 BPF_ALU64_IMM(BPF_SUB, R3, 10), 3364 BPF_ALU64_REG(BPF_SUB, R4, R0), 3365 BPF_ALU64_REG(BPF_SUB, R4, R1), 3366 BPF_ALU64_REG(BPF_SUB, R4, R2), 3367 BPF_ALU64_REG(BPF_SUB, R4, R3), 3368 BPF_ALU64_REG(BPF_SUB, R4, R5), 3369 BPF_ALU64_REG(BPF_SUB, R4, R6), 3370 BPF_ALU64_REG(BPF_SUB, R4, R7), 3371 BPF_ALU64_REG(BPF_SUB, R4, R8), 3372 BPF_ALU64_REG(BPF_SUB, R4, R9), 3373 BPF_ALU64_IMM(BPF_SUB, R4, 10), 3374 BPF_ALU64_REG(BPF_SUB, R5, R0), 3375 BPF_ALU64_REG(BPF_SUB, R5, R1), 3376 BPF_ALU64_REG(BPF_SUB, R5, R2), 3377 BPF_ALU64_REG(BPF_SUB, R5, R3), 3378 BPF_ALU64_REG(BPF_SUB, R5, R4), 3379 BPF_ALU64_REG(BPF_SUB, R5, R6), 3380 BPF_ALU64_REG(BPF_SUB, R5, R7), 3381 BPF_ALU64_REG(BPF_SUB, R5, R8), 3382 BPF_ALU64_REG(BPF_SUB, R5, R9), 3383 BPF_ALU64_IMM(BPF_SUB, R5, 10), 3384 BPF_ALU64_REG(BPF_SUB, R6, R0), 3385 BPF_ALU64_REG(BPF_SUB, R6, R1), 3386 BPF_ALU64_REG(BPF_SUB, R6, R2), 3387 BPF_ALU64_REG(BPF_SUB, R6, R3), 3388 BPF_ALU64_REG(BPF_SUB, R6, R4), 3389 BPF_ALU64_REG(BPF_SUB, R6, R5), 3390 BPF_ALU64_REG(BPF_SUB, R6, R7), 3391 BPF_ALU64_REG(BPF_SUB, R6, R8), 3392 BPF_ALU64_REG(BPF_SUB, R6, R9), 3393 BPF_ALU64_IMM(BPF_SUB, R6, 10), 3394 BPF_ALU64_REG(BPF_SUB, R7, R0), 3395 BPF_ALU64_REG(BPF_SUB, R7, R1), 3396 BPF_ALU64_REG(BPF_SUB, R7, R2), 3397 BPF_ALU64_REG(BPF_SUB, R7, R3), 3398 BPF_ALU64_REG(BPF_SUB, R7, R4), 3399 BPF_ALU64_REG(BPF_SUB, R7, R5), 3400 BPF_ALU64_REG(BPF_SUB, R7, R6), 3401 BPF_ALU64_REG(BPF_SUB, R7, R8), 3402 BPF_ALU64_REG(BPF_SUB, R7, R9), 3403 BPF_ALU64_IMM(BPF_SUB, R7, 10), 3404 BPF_ALU64_REG(BPF_SUB, R8, R0), 3405 BPF_ALU64_REG(BPF_SUB, R8, R1), 3406 BPF_ALU64_REG(BPF_SUB, R8, R2), 3407 BPF_ALU64_REG(BPF_SUB, R8, R3), 3408 BPF_ALU64_REG(BPF_SUB, R8, R4), 3409 BPF_ALU64_REG(BPF_SUB, R8, R5), 3410 BPF_ALU64_REG(BPF_SUB, R8, R6), 3411 BPF_ALU64_REG(BPF_SUB, R8, R7), 3412 BPF_ALU64_REG(BPF_SUB, R8, R9), 3413 BPF_ALU64_IMM(BPF_SUB, R8, 10), 3414 BPF_ALU64_REG(BPF_SUB, R9, R0), 3415 BPF_ALU64_REG(BPF_SUB, R9, R1), 3416 BPF_ALU64_REG(BPF_SUB, R9, R2), 3417 BPF_ALU64_REG(BPF_SUB, R9, R3), 3418 BPF_ALU64_REG(BPF_SUB, R9, R4), 3419 BPF_ALU64_REG(BPF_SUB, R9, R5), 3420 BPF_ALU64_REG(BPF_SUB, R9, R6), 3421 BPF_ALU64_REG(BPF_SUB, R9, R7), 3422 BPF_ALU64_REG(BPF_SUB, R9, R8), 3423 BPF_ALU64_IMM(BPF_SUB, R9, 10), 3424 BPF_ALU64_IMM(BPF_SUB, R0, 10), 3425 BPF_ALU64_IMM(BPF_NEG, R0, 0), 3426 BPF_ALU64_REG(BPF_SUB, R0, R1), 3427 BPF_ALU64_REG(BPF_SUB, R0, R2), 3428 BPF_ALU64_REG(BPF_SUB, R0, R3), 3429 BPF_ALU64_REG(BPF_SUB, R0, R4), 3430 BPF_ALU64_REG(BPF_SUB, R0, R5), 3431 BPF_ALU64_REG(BPF_SUB, R0, R6), 3432 BPF_ALU64_REG(BPF_SUB, R0, R7), 3433 BPF_ALU64_REG(BPF_SUB, R0, R8), 3434 BPF_ALU64_REG(BPF_SUB, R0, R9), 3435 BPF_EXIT_INSN(), 3436 }, 3437 INTERNAL, 3438 { }, 3439 { { 0, 11 } } 3440 }, 3441 { /* Mainly checking JIT here. */ 3442 "INT: XOR", 3443 .u.insns_int = { 3444 BPF_ALU64_REG(BPF_SUB, R0, R0), 3445 BPF_ALU64_REG(BPF_XOR, R1, R1), 3446 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 3447 BPF_EXIT_INSN(), 3448 BPF_ALU64_IMM(BPF_MOV, R0, 10), 3449 BPF_ALU64_IMM(BPF_MOV, R1, -1), 3450 BPF_ALU64_REG(BPF_SUB, R1, R1), 3451 BPF_ALU64_REG(BPF_XOR, R2, R2), 3452 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 3453 BPF_EXIT_INSN(), 3454 BPF_ALU64_REG(BPF_SUB, R2, R2), 3455 BPF_ALU64_REG(BPF_XOR, R3, R3), 3456 BPF_ALU64_IMM(BPF_MOV, R0, 10), 3457 BPF_ALU64_IMM(BPF_MOV, R1, -1), 3458 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 3459 BPF_EXIT_INSN(), 3460 BPF_ALU64_REG(BPF_SUB, R3, R3), 3461 BPF_ALU64_REG(BPF_XOR, R4, R4), 3462 BPF_ALU64_IMM(BPF_MOV, R2, 1), 3463 BPF_ALU64_IMM(BPF_MOV, R5, -1), 3464 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 3465 BPF_EXIT_INSN(), 3466 BPF_ALU64_REG(BPF_SUB, R4, R4), 3467 BPF_ALU64_REG(BPF_XOR, R5, R5), 3468 BPF_ALU64_IMM(BPF_MOV, R3, 1), 3469 BPF_ALU64_IMM(BPF_MOV, R7, -1), 3470 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 3471 BPF_EXIT_INSN(), 3472 BPF_ALU64_IMM(BPF_MOV, R5, 1), 3473 BPF_ALU64_REG(BPF_SUB, R5, R5), 3474 BPF_ALU64_REG(BPF_XOR, R6, R6), 3475 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3476 BPF_ALU64_IMM(BPF_MOV, R8, -1), 3477 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 3478 BPF_EXIT_INSN(), 3479 BPF_ALU64_REG(BPF_SUB, R6, R6), 3480 BPF_ALU64_REG(BPF_XOR, R7, R7), 3481 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 3482 BPF_EXIT_INSN(), 3483 BPF_ALU64_REG(BPF_SUB, R7, R7), 3484 BPF_ALU64_REG(BPF_XOR, R8, R8), 3485 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 3486 BPF_EXIT_INSN(), 3487 BPF_ALU64_REG(BPF_SUB, R8, R8), 3488 BPF_ALU64_REG(BPF_XOR, R9, R9), 3489 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 3490 BPF_EXIT_INSN(), 3491 BPF_ALU64_REG(BPF_SUB, R9, R9), 3492 BPF_ALU64_REG(BPF_XOR, R0, R0), 3493 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 3494 BPF_EXIT_INSN(), 3495 BPF_ALU64_REG(BPF_SUB, R1, R1), 3496 BPF_ALU64_REG(BPF_XOR, R0, R0), 3497 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 3498 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3499 BPF_EXIT_INSN(), 3500 BPF_ALU64_IMM(BPF_MOV, R0, 1), 3501 BPF_EXIT_INSN(), 3502 }, 3503 INTERNAL, 3504 { }, 3505 { { 0, 1 } } 3506 }, 3507 { /* Mainly checking JIT here. */ 3508 "INT: MUL", 3509 .u.insns_int = { 3510 BPF_ALU64_IMM(BPF_MOV, R0, 11), 3511 BPF_ALU64_IMM(BPF_MOV, R1, 1), 3512 BPF_ALU64_IMM(BPF_MOV, R2, 2), 3513 BPF_ALU64_IMM(BPF_MOV, R3, 3), 3514 BPF_ALU64_IMM(BPF_MOV, R4, 4), 3515 BPF_ALU64_IMM(BPF_MOV, R5, 5), 3516 BPF_ALU64_IMM(BPF_MOV, R6, 6), 3517 BPF_ALU64_IMM(BPF_MOV, R7, 7), 3518 BPF_ALU64_IMM(BPF_MOV, R8, 8), 3519 BPF_ALU64_IMM(BPF_MOV, R9, 9), 3520 BPF_ALU64_REG(BPF_MUL, R0, R0), 3521 BPF_ALU64_REG(BPF_MUL, R0, R1), 3522 BPF_ALU64_REG(BPF_MUL, R0, R2), 3523 BPF_ALU64_REG(BPF_MUL, R0, R3), 3524 BPF_ALU64_REG(BPF_MUL, R0, R4), 3525 BPF_ALU64_REG(BPF_MUL, R0, R5), 3526 BPF_ALU64_REG(BPF_MUL, R0, R6), 3527 BPF_ALU64_REG(BPF_MUL, R0, R7), 3528 BPF_ALU64_REG(BPF_MUL, R0, R8), 3529 BPF_ALU64_REG(BPF_MUL, R0, R9), 3530 BPF_ALU64_IMM(BPF_MUL, R0, 10), 3531 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 3532 BPF_EXIT_INSN(), 3533 BPF_ALU64_REG(BPF_MUL, R1, R0), 3534 BPF_ALU64_REG(BPF_MUL, R1, R2), 3535 BPF_ALU64_REG(BPF_MUL, R1, R3), 3536 BPF_ALU64_REG(BPF_MUL, R1, R4), 3537 BPF_ALU64_REG(BPF_MUL, R1, R5), 3538 BPF_ALU64_REG(BPF_MUL, R1, R6), 3539 BPF_ALU64_REG(BPF_MUL, R1, R7), 3540 BPF_ALU64_REG(BPF_MUL, R1, R8), 3541 BPF_ALU64_REG(BPF_MUL, R1, R9), 3542 BPF_ALU64_IMM(BPF_MUL, R1, 10), 3543 BPF_ALU64_REG(BPF_MOV, R2, R1), 3544 BPF_ALU64_IMM(BPF_RSH, R2, 32), 3545 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 3546 BPF_EXIT_INSN(), 3547 BPF_ALU64_IMM(BPF_LSH, R1, 32), 3548 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 3549 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 3550 BPF_EXIT_INSN(), 3551 BPF_ALU64_REG(BPF_MUL, R2, R0), 3552 BPF_ALU64_REG(BPF_MUL, R2, R1), 3553 BPF_ALU64_REG(BPF_MUL, R2, R3), 3554 BPF_ALU64_REG(BPF_MUL, R2, R4), 3555 BPF_ALU64_REG(BPF_MUL, R2, R5), 3556 BPF_ALU64_REG(BPF_MUL, R2, R6), 3557 BPF_ALU64_REG(BPF_MUL, R2, R7), 3558 BPF_ALU64_REG(BPF_MUL, R2, R8), 3559 BPF_ALU64_REG(BPF_MUL, R2, R9), 3560 BPF_ALU64_IMM(BPF_MUL, R2, 10), 3561 BPF_ALU64_IMM(BPF_RSH, R2, 32), 3562 BPF_ALU64_REG(BPF_MOV, R0, R2), 3563 BPF_EXIT_INSN(), 3564 }, 3565 INTERNAL, 3566 { }, 3567 { { 0, 0x35d97ef2 } } 3568 }, 3569 { /* Mainly checking JIT here. */ 3570 "MOV REG64", 3571 .u.insns_int = { 3572 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 3573 BPF_MOV64_REG(R1, R0), 3574 BPF_MOV64_REG(R2, R1), 3575 BPF_MOV64_REG(R3, R2), 3576 BPF_MOV64_REG(R4, R3), 3577 BPF_MOV64_REG(R5, R4), 3578 BPF_MOV64_REG(R6, R5), 3579 BPF_MOV64_REG(R7, R6), 3580 BPF_MOV64_REG(R8, R7), 3581 BPF_MOV64_REG(R9, R8), 3582 BPF_ALU64_IMM(BPF_MOV, R0, 0), 3583 BPF_ALU64_IMM(BPF_MOV, R1, 0), 3584 BPF_ALU64_IMM(BPF_MOV, R2, 0), 3585 BPF_ALU64_IMM(BPF_MOV, R3, 0), 3586 BPF_ALU64_IMM(BPF_MOV, R4, 0), 3587 BPF_ALU64_IMM(BPF_MOV, R5, 0), 3588 BPF_ALU64_IMM(BPF_MOV, R6, 0), 3589 BPF_ALU64_IMM(BPF_MOV, R7, 0), 3590 BPF_ALU64_IMM(BPF_MOV, R8, 0), 3591 BPF_ALU64_IMM(BPF_MOV, R9, 0), 3592 BPF_ALU64_REG(BPF_ADD, R0, R0), 3593 BPF_ALU64_REG(BPF_ADD, R0, R1), 3594 BPF_ALU64_REG(BPF_ADD, R0, R2), 3595 BPF_ALU64_REG(BPF_ADD, R0, R3), 3596 BPF_ALU64_REG(BPF_ADD, R0, R4), 3597 BPF_ALU64_REG(BPF_ADD, R0, R5), 3598 BPF_ALU64_REG(BPF_ADD, R0, R6), 3599 BPF_ALU64_REG(BPF_ADD, R0, R7), 3600 BPF_ALU64_REG(BPF_ADD, R0, R8), 3601 BPF_ALU64_REG(BPF_ADD, R0, R9), 3602 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 3603 BPF_EXIT_INSN(), 3604 }, 3605 INTERNAL, 3606 { }, 3607 { { 0, 0xfefe } } 3608 }, 3609 { /* Mainly checking JIT here. */ 3610 "MOV REG32", 3611 .u.insns_int = { 3612 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 3613 BPF_MOV64_REG(R1, R0), 3614 BPF_MOV64_REG(R2, R1), 3615 BPF_MOV64_REG(R3, R2), 3616 BPF_MOV64_REG(R4, R3), 3617 BPF_MOV64_REG(R5, R4), 3618 BPF_MOV64_REG(R6, R5), 3619 BPF_MOV64_REG(R7, R6), 3620 BPF_MOV64_REG(R8, R7), 3621 BPF_MOV64_REG(R9, R8), 3622 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3623 BPF_ALU32_IMM(BPF_MOV, R1, 0), 3624 BPF_ALU32_IMM(BPF_MOV, R2, 0), 3625 BPF_ALU32_IMM(BPF_MOV, R3, 0), 3626 BPF_ALU32_IMM(BPF_MOV, R4, 0), 3627 BPF_ALU32_IMM(BPF_MOV, R5, 0), 3628 BPF_ALU32_IMM(BPF_MOV, R6, 0), 3629 BPF_ALU32_IMM(BPF_MOV, R7, 0), 3630 BPF_ALU32_IMM(BPF_MOV, R8, 0), 3631 BPF_ALU32_IMM(BPF_MOV, R9, 0), 3632 BPF_ALU64_REG(BPF_ADD, R0, R0), 3633 BPF_ALU64_REG(BPF_ADD, R0, R1), 3634 BPF_ALU64_REG(BPF_ADD, R0, R2), 3635 BPF_ALU64_REG(BPF_ADD, R0, R3), 3636 BPF_ALU64_REG(BPF_ADD, R0, R4), 3637 BPF_ALU64_REG(BPF_ADD, R0, R5), 3638 BPF_ALU64_REG(BPF_ADD, R0, R6), 3639 BPF_ALU64_REG(BPF_ADD, R0, R7), 3640 BPF_ALU64_REG(BPF_ADD, R0, R8), 3641 BPF_ALU64_REG(BPF_ADD, R0, R9), 3642 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 3643 BPF_EXIT_INSN(), 3644 }, 3645 INTERNAL, 3646 { }, 3647 { { 0, 0xfefe } } 3648 }, 3649 { /* Mainly checking JIT here. */ 3650 "LD IMM64", 3651 .u.insns_int = { 3652 BPF_LD_IMM64(R0, 0xffffffffffffffffLL), 3653 BPF_MOV64_REG(R1, R0), 3654 BPF_MOV64_REG(R2, R1), 3655 BPF_MOV64_REG(R3, R2), 3656 BPF_MOV64_REG(R4, R3), 3657 BPF_MOV64_REG(R5, R4), 3658 BPF_MOV64_REG(R6, R5), 3659 BPF_MOV64_REG(R7, R6), 3660 BPF_MOV64_REG(R8, R7), 3661 BPF_MOV64_REG(R9, R8), 3662 BPF_LD_IMM64(R0, 0x0LL), 3663 BPF_LD_IMM64(R1, 0x0LL), 3664 BPF_LD_IMM64(R2, 0x0LL), 3665 BPF_LD_IMM64(R3, 0x0LL), 3666 BPF_LD_IMM64(R4, 0x0LL), 3667 BPF_LD_IMM64(R5, 0x0LL), 3668 BPF_LD_IMM64(R6, 0x0LL), 3669 BPF_LD_IMM64(R7, 0x0LL), 3670 BPF_LD_IMM64(R8, 0x0LL), 3671 BPF_LD_IMM64(R9, 0x0LL), 3672 BPF_ALU64_REG(BPF_ADD, R0, R0), 3673 BPF_ALU64_REG(BPF_ADD, R0, R1), 3674 BPF_ALU64_REG(BPF_ADD, R0, R2), 3675 BPF_ALU64_REG(BPF_ADD, R0, R3), 3676 BPF_ALU64_REG(BPF_ADD, R0, R4), 3677 BPF_ALU64_REG(BPF_ADD, R0, R5), 3678 BPF_ALU64_REG(BPF_ADD, R0, R6), 3679 BPF_ALU64_REG(BPF_ADD, R0, R7), 3680 BPF_ALU64_REG(BPF_ADD, R0, R8), 3681 BPF_ALU64_REG(BPF_ADD, R0, R9), 3682 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe), 3683 BPF_EXIT_INSN(), 3684 }, 3685 INTERNAL, 3686 { }, 3687 { { 0, 0xfefe } } 3688 }, 3689 { 3690 "INT: ALU MIX", 3691 .u.insns_int = { 3692 BPF_ALU64_IMM(BPF_MOV, R0, 11), 3693 BPF_ALU64_IMM(BPF_ADD, R0, -1), 3694 BPF_ALU64_IMM(BPF_MOV, R2, 2), 3695 BPF_ALU64_IMM(BPF_XOR, R2, 3), 3696 BPF_ALU64_REG(BPF_DIV, R0, R2), 3697 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 3698 BPF_EXIT_INSN(), 3699 BPF_ALU64_IMM(BPF_MOD, R0, 3), 3700 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 3701 BPF_EXIT_INSN(), 3702 BPF_ALU64_IMM(BPF_MOV, R0, -1), 3703 BPF_EXIT_INSN(), 3704 }, 3705 INTERNAL, 3706 { }, 3707 { { 0, -1 } } 3708 }, 3709 { 3710 "INT: shifts by register", 3711 .u.insns_int = { 3712 BPF_MOV64_IMM(R0, -1234), 3713 BPF_MOV64_IMM(R1, 1), 3714 BPF_ALU32_REG(BPF_RSH, R0, R1), 3715 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1), 3716 BPF_EXIT_INSN(), 3717 BPF_MOV64_IMM(R2, 1), 3718 BPF_ALU64_REG(BPF_LSH, R0, R2), 3719 BPF_MOV32_IMM(R4, -1234), 3720 BPF_JMP_REG(BPF_JEQ, R0, R4, 1), 3721 BPF_EXIT_INSN(), 3722 BPF_ALU64_IMM(BPF_AND, R4, 63), 3723 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */ 3724 BPF_MOV64_IMM(R3, 47), 3725 BPF_ALU64_REG(BPF_ARSH, R0, R3), 3726 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1), 3727 BPF_EXIT_INSN(), 3728 BPF_MOV64_IMM(R2, 1), 3729 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */ 3730 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1), 3731 BPF_EXIT_INSN(), 3732 BPF_MOV64_IMM(R4, 4), 3733 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */ 3734 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1), 3735 BPF_EXIT_INSN(), 3736 BPF_MOV64_IMM(R4, 5), 3737 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */ 3738 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1), 3739 BPF_EXIT_INSN(), 3740 BPF_MOV64_IMM(R0, -1), 3741 BPF_EXIT_INSN(), 3742 }, 3743 INTERNAL, 3744 { }, 3745 { { 0, -1 } } 3746 }, 3747 { 3748 /* 3749 * Register (non-)clobbering test, in the case where a 32-bit 3750 * JIT implements complex ALU64 operations via function calls. 3751 * If so, the function call must be invisible in the eBPF 3752 * registers. The JIT must then save and restore relevant 3753 * registers during the call. The following tests check that 3754 * the eBPF registers retain their values after such a call. 3755 */ 3756 "INT: Register clobbering, R1 updated", 3757 .u.insns_int = { 3758 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3759 BPF_ALU32_IMM(BPF_MOV, R1, 123456789), 3760 BPF_ALU32_IMM(BPF_MOV, R2, 2), 3761 BPF_ALU32_IMM(BPF_MOV, R3, 3), 3762 BPF_ALU32_IMM(BPF_MOV, R4, 4), 3763 BPF_ALU32_IMM(BPF_MOV, R5, 5), 3764 BPF_ALU32_IMM(BPF_MOV, R6, 6), 3765 BPF_ALU32_IMM(BPF_MOV, R7, 7), 3766 BPF_ALU32_IMM(BPF_MOV, R8, 8), 3767 BPF_ALU32_IMM(BPF_MOV, R9, 9), 3768 BPF_ALU64_IMM(BPF_DIV, R1, 123456789), 3769 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), 3770 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), 3771 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), 3772 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), 3773 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), 3774 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), 3775 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), 3776 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), 3777 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), 3778 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), 3779 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3780 BPF_EXIT_INSN(), 3781 }, 3782 INTERNAL, 3783 { }, 3784 { { 0, 1 } } 3785 }, 3786 { 3787 "INT: Register clobbering, R2 updated", 3788 .u.insns_int = { 3789 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3790 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3791 BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789), 3792 BPF_ALU32_IMM(BPF_MOV, R3, 3), 3793 BPF_ALU32_IMM(BPF_MOV, R4, 4), 3794 BPF_ALU32_IMM(BPF_MOV, R5, 5), 3795 BPF_ALU32_IMM(BPF_MOV, R6, 6), 3796 BPF_ALU32_IMM(BPF_MOV, R7, 7), 3797 BPF_ALU32_IMM(BPF_MOV, R8, 8), 3798 BPF_ALU32_IMM(BPF_MOV, R9, 9), 3799 BPF_ALU64_IMM(BPF_DIV, R2, 123456789), 3800 BPF_JMP_IMM(BPF_JNE, R0, 0, 10), 3801 BPF_JMP_IMM(BPF_JNE, R1, 1, 9), 3802 BPF_JMP_IMM(BPF_JNE, R2, 2, 8), 3803 BPF_JMP_IMM(BPF_JNE, R3, 3, 7), 3804 BPF_JMP_IMM(BPF_JNE, R4, 4, 6), 3805 BPF_JMP_IMM(BPF_JNE, R5, 5, 5), 3806 BPF_JMP_IMM(BPF_JNE, R6, 6, 4), 3807 BPF_JMP_IMM(BPF_JNE, R7, 7, 3), 3808 BPF_JMP_IMM(BPF_JNE, R8, 8, 2), 3809 BPF_JMP_IMM(BPF_JNE, R9, 9, 1), 3810 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3811 BPF_EXIT_INSN(), 3812 }, 3813 INTERNAL, 3814 { }, 3815 { { 0, 1 } } 3816 }, 3817 { 3818 /* 3819 * Test 32-bit JITs that implement complex ALU64 operations as 3820 * function calls R0 = f(R1, R2), and must re-arrange operands. 3821 */ 3822 #define NUMER 0xfedcba9876543210ULL 3823 #define DENOM 0x0123456789abcdefULL 3824 "ALU64_DIV X: Operand register permutations", 3825 .u.insns_int = { 3826 /* R0 / R2 */ 3827 BPF_LD_IMM64(R0, NUMER), 3828 BPF_LD_IMM64(R2, DENOM), 3829 BPF_ALU64_REG(BPF_DIV, R0, R2), 3830 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1), 3831 BPF_EXIT_INSN(), 3832 /* R1 / R0 */ 3833 BPF_LD_IMM64(R1, NUMER), 3834 BPF_LD_IMM64(R0, DENOM), 3835 BPF_ALU64_REG(BPF_DIV, R1, R0), 3836 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1), 3837 BPF_EXIT_INSN(), 3838 /* R0 / R1 */ 3839 BPF_LD_IMM64(R0, NUMER), 3840 BPF_LD_IMM64(R1, DENOM), 3841 BPF_ALU64_REG(BPF_DIV, R0, R1), 3842 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1), 3843 BPF_EXIT_INSN(), 3844 /* R2 / R0 */ 3845 BPF_LD_IMM64(R2, NUMER), 3846 BPF_LD_IMM64(R0, DENOM), 3847 BPF_ALU64_REG(BPF_DIV, R2, R0), 3848 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1), 3849 BPF_EXIT_INSN(), 3850 /* R2 / R1 */ 3851 BPF_LD_IMM64(R2, NUMER), 3852 BPF_LD_IMM64(R1, DENOM), 3853 BPF_ALU64_REG(BPF_DIV, R2, R1), 3854 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1), 3855 BPF_EXIT_INSN(), 3856 /* R1 / R2 */ 3857 BPF_LD_IMM64(R1, NUMER), 3858 BPF_LD_IMM64(R2, DENOM), 3859 BPF_ALU64_REG(BPF_DIV, R1, R2), 3860 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1), 3861 BPF_EXIT_INSN(), 3862 /* R1 / R1 */ 3863 BPF_LD_IMM64(R1, NUMER), 3864 BPF_ALU64_REG(BPF_DIV, R1, R1), 3865 BPF_JMP_IMM(BPF_JEQ, R1, 1, 1), 3866 BPF_EXIT_INSN(), 3867 /* R2 / R2 */ 3868 BPF_LD_IMM64(R2, DENOM), 3869 BPF_ALU64_REG(BPF_DIV, R2, R2), 3870 BPF_JMP_IMM(BPF_JEQ, R2, 1, 1), 3871 BPF_EXIT_INSN(), 3872 /* R3 / R4 */ 3873 BPF_LD_IMM64(R3, NUMER), 3874 BPF_LD_IMM64(R4, DENOM), 3875 BPF_ALU64_REG(BPF_DIV, R3, R4), 3876 BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1), 3877 BPF_EXIT_INSN(), 3878 /* Successful return */ 3879 BPF_LD_IMM64(R0, 1), 3880 BPF_EXIT_INSN(), 3881 }, 3882 INTERNAL, 3883 { }, 3884 { { 0, 1 } }, 3885 #undef NUMER 3886 #undef DENOM 3887 }, 3888 #ifdef CONFIG_32BIT 3889 { 3890 "INT: 32-bit context pointer word order and zero-extension", 3891 .u.insns_int = { 3892 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3893 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3), 3894 BPF_ALU64_IMM(BPF_RSH, R1, 32), 3895 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1), 3896 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3897 BPF_EXIT_INSN(), 3898 }, 3899 INTERNAL, 3900 { }, 3901 { { 0, 1 } } 3902 }, 3903 #endif 3904 { 3905 "check: missing ret", 3906 .u.insns = { 3907 BPF_STMT(BPF_LD | BPF_IMM, 1), 3908 }, 3909 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 3910 { }, 3911 { }, 3912 .fill_helper = NULL, 3913 .expected_errcode = -EINVAL, 3914 }, 3915 { 3916 "check: div_k_0", 3917 .u.insns = { 3918 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 3919 BPF_STMT(BPF_RET | BPF_K, 0) 3920 }, 3921 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 3922 { }, 3923 { }, 3924 .fill_helper = NULL, 3925 .expected_errcode = -EINVAL, 3926 }, 3927 { 3928 "check: unknown insn", 3929 .u.insns = { 3930 /* seccomp insn, rejected in socket filter */ 3931 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 3932 BPF_STMT(BPF_RET | BPF_K, 0) 3933 }, 3934 CLASSIC | FLAG_EXPECTED_FAIL, 3935 { }, 3936 { }, 3937 .fill_helper = NULL, 3938 .expected_errcode = -EINVAL, 3939 }, 3940 { 3941 "check: out of range spill/fill", 3942 .u.insns = { 3943 BPF_STMT(BPF_STX, 16), 3944 BPF_STMT(BPF_RET | BPF_K, 0) 3945 }, 3946 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 3947 { }, 3948 { }, 3949 .fill_helper = NULL, 3950 .expected_errcode = -EINVAL, 3951 }, 3952 { 3953 "JUMPS + HOLES", 3954 .u.insns = { 3955 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3956 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15), 3957 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3958 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3959 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3960 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3961 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3962 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3963 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3964 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3965 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3966 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3967 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3968 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3969 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3970 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4), 3971 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3972 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2), 3973 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3974 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 3975 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 3976 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3977 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3978 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3979 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3980 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3981 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3982 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3983 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3984 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3985 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3986 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3987 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3988 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3989 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3), 3990 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2), 3991 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3992 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 3993 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 3994 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3995 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3996 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3997 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3998 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 3999 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4000 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4001 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4002 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4003 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4004 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4005 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4006 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4007 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3), 4008 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2), 4009 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 4010 BPF_STMT(BPF_RET | BPF_A, 0), 4011 BPF_STMT(BPF_RET | BPF_A, 0), 4012 }, 4013 CLASSIC, 4014 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 4015 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4, 4016 0x08, 0x00, 4017 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 4018 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */ 4019 0xc0, 0xa8, 0x33, 0x01, 4020 0xc0, 0xa8, 0x33, 0x02, 4021 0xbb, 0xb6, 4022 0xa9, 0xfa, 4023 0x00, 0x14, 0x00, 0x00, 4024 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4025 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4026 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4027 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4028 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4029 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4030 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 4031 0xcc, 0xcc, 0xcc, 0xcc }, 4032 { { 88, 0x001b } } 4033 }, 4034 { 4035 "check: RET X", 4036 .u.insns = { 4037 BPF_STMT(BPF_RET | BPF_X, 0), 4038 }, 4039 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4040 { }, 4041 { }, 4042 .fill_helper = NULL, 4043 .expected_errcode = -EINVAL, 4044 }, 4045 { 4046 "check: LDX + RET X", 4047 .u.insns = { 4048 BPF_STMT(BPF_LDX | BPF_IMM, 42), 4049 BPF_STMT(BPF_RET | BPF_X, 0), 4050 }, 4051 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4052 { }, 4053 { }, 4054 .fill_helper = NULL, 4055 .expected_errcode = -EINVAL, 4056 }, 4057 { /* Mainly checking JIT here. */ 4058 "M[]: alt STX + LDX", 4059 .u.insns = { 4060 BPF_STMT(BPF_LDX | BPF_IMM, 100), 4061 BPF_STMT(BPF_STX, 0), 4062 BPF_STMT(BPF_LDX | BPF_MEM, 0), 4063 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4064 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4065 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4066 BPF_STMT(BPF_STX, 1), 4067 BPF_STMT(BPF_LDX | BPF_MEM, 1), 4068 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4069 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4070 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4071 BPF_STMT(BPF_STX, 2), 4072 BPF_STMT(BPF_LDX | BPF_MEM, 2), 4073 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4074 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4075 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4076 BPF_STMT(BPF_STX, 3), 4077 BPF_STMT(BPF_LDX | BPF_MEM, 3), 4078 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4079 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4080 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4081 BPF_STMT(BPF_STX, 4), 4082 BPF_STMT(BPF_LDX | BPF_MEM, 4), 4083 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4084 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4085 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4086 BPF_STMT(BPF_STX, 5), 4087 BPF_STMT(BPF_LDX | BPF_MEM, 5), 4088 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4089 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4090 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4091 BPF_STMT(BPF_STX, 6), 4092 BPF_STMT(BPF_LDX | BPF_MEM, 6), 4093 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4094 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4095 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4096 BPF_STMT(BPF_STX, 7), 4097 BPF_STMT(BPF_LDX | BPF_MEM, 7), 4098 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4099 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4100 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4101 BPF_STMT(BPF_STX, 8), 4102 BPF_STMT(BPF_LDX | BPF_MEM, 8), 4103 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4104 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4105 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4106 BPF_STMT(BPF_STX, 9), 4107 BPF_STMT(BPF_LDX | BPF_MEM, 9), 4108 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4109 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4110 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4111 BPF_STMT(BPF_STX, 10), 4112 BPF_STMT(BPF_LDX | BPF_MEM, 10), 4113 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4114 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4115 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4116 BPF_STMT(BPF_STX, 11), 4117 BPF_STMT(BPF_LDX | BPF_MEM, 11), 4118 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4119 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4120 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4121 BPF_STMT(BPF_STX, 12), 4122 BPF_STMT(BPF_LDX | BPF_MEM, 12), 4123 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4124 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4125 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4126 BPF_STMT(BPF_STX, 13), 4127 BPF_STMT(BPF_LDX | BPF_MEM, 13), 4128 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4129 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4130 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4131 BPF_STMT(BPF_STX, 14), 4132 BPF_STMT(BPF_LDX | BPF_MEM, 14), 4133 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4134 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4135 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4136 BPF_STMT(BPF_STX, 15), 4137 BPF_STMT(BPF_LDX | BPF_MEM, 15), 4138 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4139 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 4140 BPF_STMT(BPF_MISC | BPF_TAX, 0), 4141 BPF_STMT(BPF_RET | BPF_A, 0), 4142 }, 4143 CLASSIC | FLAG_NO_DATA, 4144 { }, 4145 { { 0, 116 } }, 4146 }, 4147 { /* Mainly checking JIT here. */ 4148 "M[]: full STX + full LDX", 4149 .u.insns = { 4150 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb), 4151 BPF_STMT(BPF_STX, 0), 4152 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae), 4153 BPF_STMT(BPF_STX, 1), 4154 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf), 4155 BPF_STMT(BPF_STX, 2), 4156 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc), 4157 BPF_STMT(BPF_STX, 3), 4158 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb), 4159 BPF_STMT(BPF_STX, 4), 4160 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda), 4161 BPF_STMT(BPF_STX, 5), 4162 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb), 4163 BPF_STMT(BPF_STX, 6), 4164 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade), 4165 BPF_STMT(BPF_STX, 7), 4166 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec), 4167 BPF_STMT(BPF_STX, 8), 4168 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc), 4169 BPF_STMT(BPF_STX, 9), 4170 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac), 4171 BPF_STMT(BPF_STX, 10), 4172 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea), 4173 BPF_STMT(BPF_STX, 11), 4174 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb), 4175 BPF_STMT(BPF_STX, 12), 4176 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf), 4177 BPF_STMT(BPF_STX, 13), 4178 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde), 4179 BPF_STMT(BPF_STX, 14), 4180 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad), 4181 BPF_STMT(BPF_STX, 15), 4182 BPF_STMT(BPF_LDX | BPF_MEM, 0), 4183 BPF_STMT(BPF_MISC | BPF_TXA, 0), 4184 BPF_STMT(BPF_LDX | BPF_MEM, 1), 4185 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4186 BPF_STMT(BPF_LDX | BPF_MEM, 2), 4187 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4188 BPF_STMT(BPF_LDX | BPF_MEM, 3), 4189 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4190 BPF_STMT(BPF_LDX | BPF_MEM, 4), 4191 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4192 BPF_STMT(BPF_LDX | BPF_MEM, 5), 4193 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4194 BPF_STMT(BPF_LDX | BPF_MEM, 6), 4195 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4196 BPF_STMT(BPF_LDX | BPF_MEM, 7), 4197 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4198 BPF_STMT(BPF_LDX | BPF_MEM, 8), 4199 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4200 BPF_STMT(BPF_LDX | BPF_MEM, 9), 4201 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4202 BPF_STMT(BPF_LDX | BPF_MEM, 10), 4203 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4204 BPF_STMT(BPF_LDX | BPF_MEM, 11), 4205 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4206 BPF_STMT(BPF_LDX | BPF_MEM, 12), 4207 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4208 BPF_STMT(BPF_LDX | BPF_MEM, 13), 4209 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4210 BPF_STMT(BPF_LDX | BPF_MEM, 14), 4211 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4212 BPF_STMT(BPF_LDX | BPF_MEM, 15), 4213 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 4214 BPF_STMT(BPF_RET | BPF_A, 0), 4215 }, 4216 CLASSIC | FLAG_NO_DATA, 4217 { }, 4218 { { 0, 0x2a5a5e5 } }, 4219 }, 4220 { 4221 "check: SKF_AD_MAX", 4222 .u.insns = { 4223 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 4224 SKF_AD_OFF + SKF_AD_MAX), 4225 BPF_STMT(BPF_RET | BPF_A, 0), 4226 }, 4227 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4228 { }, 4229 { }, 4230 .fill_helper = NULL, 4231 .expected_errcode = -EINVAL, 4232 }, 4233 { /* Passes checker but fails during runtime. */ 4234 "LD [SKF_AD_OFF-1]", 4235 .u.insns = { 4236 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 4237 SKF_AD_OFF - 1), 4238 BPF_STMT(BPF_RET | BPF_K, 1), 4239 }, 4240 CLASSIC, 4241 { }, 4242 { { 1, 0 } }, 4243 }, 4244 { 4245 "load 64-bit immediate", 4246 .u.insns_int = { 4247 BPF_LD_IMM64(R1, 0x567800001234LL), 4248 BPF_MOV64_REG(R2, R1), 4249 BPF_MOV64_REG(R3, R2), 4250 BPF_ALU64_IMM(BPF_RSH, R2, 32), 4251 BPF_ALU64_IMM(BPF_LSH, R3, 32), 4252 BPF_ALU64_IMM(BPF_RSH, R3, 32), 4253 BPF_ALU64_IMM(BPF_MOV, R0, 0), 4254 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1), 4255 BPF_EXIT_INSN(), 4256 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1), 4257 BPF_EXIT_INSN(), 4258 BPF_LD_IMM64(R0, 0x1ffffffffLL), 4259 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */ 4260 BPF_EXIT_INSN(), 4261 }, 4262 INTERNAL, 4263 { }, 4264 { { 0, 1 } } 4265 }, 4266 /* BPF_ALU | BPF_MOV | BPF_X */ 4267 { 4268 "ALU_MOV_X: dst = 2", 4269 .u.insns_int = { 4270 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4271 BPF_ALU32_REG(BPF_MOV, R0, R1), 4272 BPF_EXIT_INSN(), 4273 }, 4274 INTERNAL, 4275 { }, 4276 { { 0, 2 } }, 4277 }, 4278 { 4279 "ALU_MOV_X: dst = 4294967295", 4280 .u.insns_int = { 4281 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 4282 BPF_ALU32_REG(BPF_MOV, R0, R1), 4283 BPF_EXIT_INSN(), 4284 }, 4285 INTERNAL, 4286 { }, 4287 { { 0, 4294967295U } }, 4288 }, 4289 { 4290 "ALU64_MOV_X: dst = 2", 4291 .u.insns_int = { 4292 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4293 BPF_ALU64_REG(BPF_MOV, R0, R1), 4294 BPF_EXIT_INSN(), 4295 }, 4296 INTERNAL, 4297 { }, 4298 { { 0, 2 } }, 4299 }, 4300 { 4301 "ALU64_MOV_X: dst = 4294967295", 4302 .u.insns_int = { 4303 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 4304 BPF_ALU64_REG(BPF_MOV, R0, R1), 4305 BPF_EXIT_INSN(), 4306 }, 4307 INTERNAL, 4308 { }, 4309 { { 0, 4294967295U } }, 4310 }, 4311 /* BPF_ALU | BPF_MOV | BPF_K */ 4312 { 4313 "ALU_MOV_K: dst = 2", 4314 .u.insns_int = { 4315 BPF_ALU32_IMM(BPF_MOV, R0, 2), 4316 BPF_EXIT_INSN(), 4317 }, 4318 INTERNAL, 4319 { }, 4320 { { 0, 2 } }, 4321 }, 4322 { 4323 "ALU_MOV_K: dst = 4294967295", 4324 .u.insns_int = { 4325 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U), 4326 BPF_EXIT_INSN(), 4327 }, 4328 INTERNAL, 4329 { }, 4330 { { 0, 4294967295U } }, 4331 }, 4332 { 4333 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff", 4334 .u.insns_int = { 4335 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4336 BPF_LD_IMM64(R3, 0x00000000ffffffffLL), 4337 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff), 4338 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4339 BPF_MOV32_IMM(R0, 2), 4340 BPF_EXIT_INSN(), 4341 BPF_MOV32_IMM(R0, 1), 4342 BPF_EXIT_INSN(), 4343 }, 4344 INTERNAL, 4345 { }, 4346 { { 0, 0x1 } }, 4347 }, 4348 { 4349 "ALU_MOV_K: small negative", 4350 .u.insns_int = { 4351 BPF_ALU32_IMM(BPF_MOV, R0, -123), 4352 BPF_EXIT_INSN(), 4353 }, 4354 INTERNAL, 4355 { }, 4356 { { 0, -123 } } 4357 }, 4358 { 4359 "ALU_MOV_K: small negative zero extension", 4360 .u.insns_int = { 4361 BPF_ALU32_IMM(BPF_MOV, R0, -123), 4362 BPF_ALU64_IMM(BPF_RSH, R0, 32), 4363 BPF_EXIT_INSN(), 4364 }, 4365 INTERNAL, 4366 { }, 4367 { { 0, 0 } } 4368 }, 4369 { 4370 "ALU_MOV_K: large negative", 4371 .u.insns_int = { 4372 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 4373 BPF_EXIT_INSN(), 4374 }, 4375 INTERNAL, 4376 { }, 4377 { { 0, -123456789 } } 4378 }, 4379 { 4380 "ALU_MOV_K: large negative zero extension", 4381 .u.insns_int = { 4382 BPF_ALU32_IMM(BPF_MOV, R0, -123456789), 4383 BPF_ALU64_IMM(BPF_RSH, R0, 32), 4384 BPF_EXIT_INSN(), 4385 }, 4386 INTERNAL, 4387 { }, 4388 { { 0, 0 } } 4389 }, 4390 { 4391 "ALU64_MOV_K: dst = 2", 4392 .u.insns_int = { 4393 BPF_ALU64_IMM(BPF_MOV, R0, 2), 4394 BPF_EXIT_INSN(), 4395 }, 4396 INTERNAL, 4397 { }, 4398 { { 0, 2 } }, 4399 }, 4400 { 4401 "ALU64_MOV_K: dst = 2147483647", 4402 .u.insns_int = { 4403 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647), 4404 BPF_EXIT_INSN(), 4405 }, 4406 INTERNAL, 4407 { }, 4408 { { 0, 2147483647 } }, 4409 }, 4410 { 4411 "ALU64_OR_K: dst = 0x0", 4412 .u.insns_int = { 4413 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4414 BPF_LD_IMM64(R3, 0x0), 4415 BPF_ALU64_IMM(BPF_MOV, R2, 0x0), 4416 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4417 BPF_MOV32_IMM(R0, 2), 4418 BPF_EXIT_INSN(), 4419 BPF_MOV32_IMM(R0, 1), 4420 BPF_EXIT_INSN(), 4421 }, 4422 INTERNAL, 4423 { }, 4424 { { 0, 0x1 } }, 4425 }, 4426 { 4427 "ALU64_MOV_K: dst = -1", 4428 .u.insns_int = { 4429 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 4430 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4431 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff), 4432 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4433 BPF_MOV32_IMM(R0, 2), 4434 BPF_EXIT_INSN(), 4435 BPF_MOV32_IMM(R0, 1), 4436 BPF_EXIT_INSN(), 4437 }, 4438 INTERNAL, 4439 { }, 4440 { { 0, 0x1 } }, 4441 }, 4442 { 4443 "ALU64_MOV_K: small negative", 4444 .u.insns_int = { 4445 BPF_ALU64_IMM(BPF_MOV, R0, -123), 4446 BPF_EXIT_INSN(), 4447 }, 4448 INTERNAL, 4449 { }, 4450 { { 0, -123 } } 4451 }, 4452 { 4453 "ALU64_MOV_K: small negative sign extension", 4454 .u.insns_int = { 4455 BPF_ALU64_IMM(BPF_MOV, R0, -123), 4456 BPF_ALU64_IMM(BPF_RSH, R0, 32), 4457 BPF_EXIT_INSN(), 4458 }, 4459 INTERNAL, 4460 { }, 4461 { { 0, 0xffffffff } } 4462 }, 4463 { 4464 "ALU64_MOV_K: large negative", 4465 .u.insns_int = { 4466 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 4467 BPF_EXIT_INSN(), 4468 }, 4469 INTERNAL, 4470 { }, 4471 { { 0, -123456789 } } 4472 }, 4473 { 4474 "ALU64_MOV_K: large negative sign extension", 4475 .u.insns_int = { 4476 BPF_ALU64_IMM(BPF_MOV, R0, -123456789), 4477 BPF_ALU64_IMM(BPF_RSH, R0, 32), 4478 BPF_EXIT_INSN(), 4479 }, 4480 INTERNAL, 4481 { }, 4482 { { 0, 0xffffffff } } 4483 }, 4484 /* BPF_ALU | BPF_ADD | BPF_X */ 4485 { 4486 "ALU_ADD_X: 1 + 2 = 3", 4487 .u.insns_int = { 4488 BPF_LD_IMM64(R0, 1), 4489 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4490 BPF_ALU32_REG(BPF_ADD, R0, R1), 4491 BPF_EXIT_INSN(), 4492 }, 4493 INTERNAL, 4494 { }, 4495 { { 0, 3 } }, 4496 }, 4497 { 4498 "ALU_ADD_X: 1 + 4294967294 = 4294967295", 4499 .u.insns_int = { 4500 BPF_LD_IMM64(R0, 1), 4501 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 4502 BPF_ALU32_REG(BPF_ADD, R0, R1), 4503 BPF_EXIT_INSN(), 4504 }, 4505 INTERNAL, 4506 { }, 4507 { { 0, 4294967295U } }, 4508 }, 4509 { 4510 "ALU_ADD_X: 2 + 4294967294 = 0", 4511 .u.insns_int = { 4512 BPF_LD_IMM64(R0, 2), 4513 BPF_LD_IMM64(R1, 4294967294U), 4514 BPF_ALU32_REG(BPF_ADD, R0, R1), 4515 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 4516 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4517 BPF_EXIT_INSN(), 4518 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4519 BPF_EXIT_INSN(), 4520 }, 4521 INTERNAL, 4522 { }, 4523 { { 0, 1 } }, 4524 }, 4525 { 4526 "ALU64_ADD_X: 1 + 2 = 3", 4527 .u.insns_int = { 4528 BPF_LD_IMM64(R0, 1), 4529 BPF_ALU32_IMM(BPF_MOV, R1, 2), 4530 BPF_ALU64_REG(BPF_ADD, R0, R1), 4531 BPF_EXIT_INSN(), 4532 }, 4533 INTERNAL, 4534 { }, 4535 { { 0, 3 } }, 4536 }, 4537 { 4538 "ALU64_ADD_X: 1 + 4294967294 = 4294967295", 4539 .u.insns_int = { 4540 BPF_LD_IMM64(R0, 1), 4541 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 4542 BPF_ALU64_REG(BPF_ADD, R0, R1), 4543 BPF_EXIT_INSN(), 4544 }, 4545 INTERNAL, 4546 { }, 4547 { { 0, 4294967295U } }, 4548 }, 4549 { 4550 "ALU64_ADD_X: 2 + 4294967294 = 4294967296", 4551 .u.insns_int = { 4552 BPF_LD_IMM64(R0, 2), 4553 BPF_LD_IMM64(R1, 4294967294U), 4554 BPF_LD_IMM64(R2, 4294967296ULL), 4555 BPF_ALU64_REG(BPF_ADD, R0, R1), 4556 BPF_JMP_REG(BPF_JEQ, R0, R2, 2), 4557 BPF_MOV32_IMM(R0, 0), 4558 BPF_EXIT_INSN(), 4559 BPF_MOV32_IMM(R0, 1), 4560 BPF_EXIT_INSN(), 4561 }, 4562 INTERNAL, 4563 { }, 4564 { { 0, 1 } }, 4565 }, 4566 /* BPF_ALU | BPF_ADD | BPF_K */ 4567 { 4568 "ALU_ADD_K: 1 + 2 = 3", 4569 .u.insns_int = { 4570 BPF_LD_IMM64(R0, 1), 4571 BPF_ALU32_IMM(BPF_ADD, R0, 2), 4572 BPF_EXIT_INSN(), 4573 }, 4574 INTERNAL, 4575 { }, 4576 { { 0, 3 } }, 4577 }, 4578 { 4579 "ALU_ADD_K: 3 + 0 = 3", 4580 .u.insns_int = { 4581 BPF_LD_IMM64(R0, 3), 4582 BPF_ALU32_IMM(BPF_ADD, R0, 0), 4583 BPF_EXIT_INSN(), 4584 }, 4585 INTERNAL, 4586 { }, 4587 { { 0, 3 } }, 4588 }, 4589 { 4590 "ALU_ADD_K: 1 + 4294967294 = 4294967295", 4591 .u.insns_int = { 4592 BPF_LD_IMM64(R0, 1), 4593 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U), 4594 BPF_EXIT_INSN(), 4595 }, 4596 INTERNAL, 4597 { }, 4598 { { 0, 4294967295U } }, 4599 }, 4600 { 4601 "ALU_ADD_K: 4294967294 + 2 = 0", 4602 .u.insns_int = { 4603 BPF_LD_IMM64(R0, 4294967294U), 4604 BPF_ALU32_IMM(BPF_ADD, R0, 2), 4605 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 4606 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4607 BPF_EXIT_INSN(), 4608 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4609 BPF_EXIT_INSN(), 4610 }, 4611 INTERNAL, 4612 { }, 4613 { { 0, 1 } }, 4614 }, 4615 { 4616 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff", 4617 .u.insns_int = { 4618 BPF_LD_IMM64(R2, 0x0), 4619 BPF_LD_IMM64(R3, 0x00000000ffffffff), 4620 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff), 4621 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4622 BPF_MOV32_IMM(R0, 2), 4623 BPF_EXIT_INSN(), 4624 BPF_MOV32_IMM(R0, 1), 4625 BPF_EXIT_INSN(), 4626 }, 4627 INTERNAL, 4628 { }, 4629 { { 0, 0x1 } }, 4630 }, 4631 { 4632 "ALU_ADD_K: 0 + 0xffff = 0xffff", 4633 .u.insns_int = { 4634 BPF_LD_IMM64(R2, 0x0), 4635 BPF_LD_IMM64(R3, 0xffff), 4636 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff), 4637 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4638 BPF_MOV32_IMM(R0, 2), 4639 BPF_EXIT_INSN(), 4640 BPF_MOV32_IMM(R0, 1), 4641 BPF_EXIT_INSN(), 4642 }, 4643 INTERNAL, 4644 { }, 4645 { { 0, 0x1 } }, 4646 }, 4647 { 4648 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 4649 .u.insns_int = { 4650 BPF_LD_IMM64(R2, 0x0), 4651 BPF_LD_IMM64(R3, 0x7fffffff), 4652 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff), 4653 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4654 BPF_MOV32_IMM(R0, 2), 4655 BPF_EXIT_INSN(), 4656 BPF_MOV32_IMM(R0, 1), 4657 BPF_EXIT_INSN(), 4658 }, 4659 INTERNAL, 4660 { }, 4661 { { 0, 0x1 } }, 4662 }, 4663 { 4664 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000", 4665 .u.insns_int = { 4666 BPF_LD_IMM64(R2, 0x0), 4667 BPF_LD_IMM64(R3, 0x80000000), 4668 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000), 4669 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4670 BPF_MOV32_IMM(R0, 2), 4671 BPF_EXIT_INSN(), 4672 BPF_MOV32_IMM(R0, 1), 4673 BPF_EXIT_INSN(), 4674 }, 4675 INTERNAL, 4676 { }, 4677 { { 0, 0x1 } }, 4678 }, 4679 { 4680 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000", 4681 .u.insns_int = { 4682 BPF_LD_IMM64(R2, 0x0), 4683 BPF_LD_IMM64(R3, 0x80008000), 4684 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000), 4685 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4686 BPF_MOV32_IMM(R0, 2), 4687 BPF_EXIT_INSN(), 4688 BPF_MOV32_IMM(R0, 1), 4689 BPF_EXIT_INSN(), 4690 }, 4691 INTERNAL, 4692 { }, 4693 { { 0, 0x1 } }, 4694 }, 4695 { 4696 "ALU64_ADD_K: 1 + 2 = 3", 4697 .u.insns_int = { 4698 BPF_LD_IMM64(R0, 1), 4699 BPF_ALU64_IMM(BPF_ADD, R0, 2), 4700 BPF_EXIT_INSN(), 4701 }, 4702 INTERNAL, 4703 { }, 4704 { { 0, 3 } }, 4705 }, 4706 { 4707 "ALU64_ADD_K: 3 + 0 = 3", 4708 .u.insns_int = { 4709 BPF_LD_IMM64(R0, 3), 4710 BPF_ALU64_IMM(BPF_ADD, R0, 0), 4711 BPF_EXIT_INSN(), 4712 }, 4713 INTERNAL, 4714 { }, 4715 { { 0, 3 } }, 4716 }, 4717 { 4718 "ALU64_ADD_K: 1 + 2147483646 = 2147483647", 4719 .u.insns_int = { 4720 BPF_LD_IMM64(R0, 1), 4721 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646), 4722 BPF_EXIT_INSN(), 4723 }, 4724 INTERNAL, 4725 { }, 4726 { { 0, 2147483647 } }, 4727 }, 4728 { 4729 "ALU64_ADD_K: 4294967294 + 2 = 4294967296", 4730 .u.insns_int = { 4731 BPF_LD_IMM64(R0, 4294967294U), 4732 BPF_LD_IMM64(R1, 4294967296ULL), 4733 BPF_ALU64_IMM(BPF_ADD, R0, 2), 4734 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 4735 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4736 BPF_EXIT_INSN(), 4737 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4738 BPF_EXIT_INSN(), 4739 }, 4740 INTERNAL, 4741 { }, 4742 { { 0, 1 } }, 4743 }, 4744 { 4745 "ALU64_ADD_K: 2147483646 + -2147483647 = -1", 4746 .u.insns_int = { 4747 BPF_LD_IMM64(R0, 2147483646), 4748 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647), 4749 BPF_EXIT_INSN(), 4750 }, 4751 INTERNAL, 4752 { }, 4753 { { 0, -1 } }, 4754 }, 4755 { 4756 "ALU64_ADD_K: 1 + 0 = 1", 4757 .u.insns_int = { 4758 BPF_LD_IMM64(R2, 0x1), 4759 BPF_LD_IMM64(R3, 0x1), 4760 BPF_ALU64_IMM(BPF_ADD, R2, 0x0), 4761 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4762 BPF_MOV32_IMM(R0, 2), 4763 BPF_EXIT_INSN(), 4764 BPF_MOV32_IMM(R0, 1), 4765 BPF_EXIT_INSN(), 4766 }, 4767 INTERNAL, 4768 { }, 4769 { { 0, 0x1 } }, 4770 }, 4771 { 4772 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff", 4773 .u.insns_int = { 4774 BPF_LD_IMM64(R2, 0x0), 4775 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 4776 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff), 4777 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4778 BPF_MOV32_IMM(R0, 2), 4779 BPF_EXIT_INSN(), 4780 BPF_MOV32_IMM(R0, 1), 4781 BPF_EXIT_INSN(), 4782 }, 4783 INTERNAL, 4784 { }, 4785 { { 0, 0x1 } }, 4786 }, 4787 { 4788 "ALU64_ADD_K: 0 + 0xffff = 0xffff", 4789 .u.insns_int = { 4790 BPF_LD_IMM64(R2, 0x0), 4791 BPF_LD_IMM64(R3, 0xffff), 4792 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff), 4793 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4794 BPF_MOV32_IMM(R0, 2), 4795 BPF_EXIT_INSN(), 4796 BPF_MOV32_IMM(R0, 1), 4797 BPF_EXIT_INSN(), 4798 }, 4799 INTERNAL, 4800 { }, 4801 { { 0, 0x1 } }, 4802 }, 4803 { 4804 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff", 4805 .u.insns_int = { 4806 BPF_LD_IMM64(R2, 0x0), 4807 BPF_LD_IMM64(R3, 0x7fffffff), 4808 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff), 4809 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4810 BPF_MOV32_IMM(R0, 2), 4811 BPF_EXIT_INSN(), 4812 BPF_MOV32_IMM(R0, 1), 4813 BPF_EXIT_INSN(), 4814 }, 4815 INTERNAL, 4816 { }, 4817 { { 0, 0x1 } }, 4818 }, 4819 { 4820 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000", 4821 .u.insns_int = { 4822 BPF_LD_IMM64(R2, 0x0), 4823 BPF_LD_IMM64(R3, 0xffffffff80000000LL), 4824 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000), 4825 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4826 BPF_MOV32_IMM(R0, 2), 4827 BPF_EXIT_INSN(), 4828 BPF_MOV32_IMM(R0, 1), 4829 BPF_EXIT_INSN(), 4830 }, 4831 INTERNAL, 4832 { }, 4833 { { 0, 0x1 } }, 4834 }, 4835 { 4836 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000", 4837 .u.insns_int = { 4838 BPF_LD_IMM64(R2, 0x0), 4839 BPF_LD_IMM64(R3, 0xffffffff80008000LL), 4840 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000), 4841 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 4842 BPF_MOV32_IMM(R0, 2), 4843 BPF_EXIT_INSN(), 4844 BPF_MOV32_IMM(R0, 1), 4845 BPF_EXIT_INSN(), 4846 }, 4847 INTERNAL, 4848 { }, 4849 { { 0, 0x1 } }, 4850 }, 4851 /* BPF_ALU | BPF_SUB | BPF_X */ 4852 { 4853 "ALU_SUB_X: 3 - 1 = 2", 4854 .u.insns_int = { 4855 BPF_LD_IMM64(R0, 3), 4856 BPF_ALU32_IMM(BPF_MOV, R1, 1), 4857 BPF_ALU32_REG(BPF_SUB, R0, R1), 4858 BPF_EXIT_INSN(), 4859 }, 4860 INTERNAL, 4861 { }, 4862 { { 0, 2 } }, 4863 }, 4864 { 4865 "ALU_SUB_X: 4294967295 - 4294967294 = 1", 4866 .u.insns_int = { 4867 BPF_LD_IMM64(R0, 4294967295U), 4868 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 4869 BPF_ALU32_REG(BPF_SUB, R0, R1), 4870 BPF_EXIT_INSN(), 4871 }, 4872 INTERNAL, 4873 { }, 4874 { { 0, 1 } }, 4875 }, 4876 { 4877 "ALU64_SUB_X: 3 - 1 = 2", 4878 .u.insns_int = { 4879 BPF_LD_IMM64(R0, 3), 4880 BPF_ALU32_IMM(BPF_MOV, R1, 1), 4881 BPF_ALU64_REG(BPF_SUB, R0, R1), 4882 BPF_EXIT_INSN(), 4883 }, 4884 INTERNAL, 4885 { }, 4886 { { 0, 2 } }, 4887 }, 4888 { 4889 "ALU64_SUB_X: 4294967295 - 4294967294 = 1", 4890 .u.insns_int = { 4891 BPF_LD_IMM64(R0, 4294967295U), 4892 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 4893 BPF_ALU64_REG(BPF_SUB, R0, R1), 4894 BPF_EXIT_INSN(), 4895 }, 4896 INTERNAL, 4897 { }, 4898 { { 0, 1 } }, 4899 }, 4900 /* BPF_ALU | BPF_SUB | BPF_K */ 4901 { 4902 "ALU_SUB_K: 3 - 1 = 2", 4903 .u.insns_int = { 4904 BPF_LD_IMM64(R0, 3), 4905 BPF_ALU32_IMM(BPF_SUB, R0, 1), 4906 BPF_EXIT_INSN(), 4907 }, 4908 INTERNAL, 4909 { }, 4910 { { 0, 2 } }, 4911 }, 4912 { 4913 "ALU_SUB_K: 3 - 0 = 3", 4914 .u.insns_int = { 4915 BPF_LD_IMM64(R0, 3), 4916 BPF_ALU32_IMM(BPF_SUB, R0, 0), 4917 BPF_EXIT_INSN(), 4918 }, 4919 INTERNAL, 4920 { }, 4921 { { 0, 3 } }, 4922 }, 4923 { 4924 "ALU_SUB_K: 4294967295 - 4294967294 = 1", 4925 .u.insns_int = { 4926 BPF_LD_IMM64(R0, 4294967295U), 4927 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U), 4928 BPF_EXIT_INSN(), 4929 }, 4930 INTERNAL, 4931 { }, 4932 { { 0, 1 } }, 4933 }, 4934 { 4935 "ALU64_SUB_K: 3 - 1 = 2", 4936 .u.insns_int = { 4937 BPF_LD_IMM64(R0, 3), 4938 BPF_ALU64_IMM(BPF_SUB, R0, 1), 4939 BPF_EXIT_INSN(), 4940 }, 4941 INTERNAL, 4942 { }, 4943 { { 0, 2 } }, 4944 }, 4945 { 4946 "ALU64_SUB_K: 3 - 0 = 3", 4947 .u.insns_int = { 4948 BPF_LD_IMM64(R0, 3), 4949 BPF_ALU64_IMM(BPF_SUB, R0, 0), 4950 BPF_EXIT_INSN(), 4951 }, 4952 INTERNAL, 4953 { }, 4954 { { 0, 3 } }, 4955 }, 4956 { 4957 "ALU64_SUB_K: 4294967294 - 4294967295 = -1", 4958 .u.insns_int = { 4959 BPF_LD_IMM64(R0, 4294967294U), 4960 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U), 4961 BPF_EXIT_INSN(), 4962 }, 4963 INTERNAL, 4964 { }, 4965 { { 0, -1 } }, 4966 }, 4967 { 4968 "ALU64_ADD_K: 2147483646 - 2147483647 = -1", 4969 .u.insns_int = { 4970 BPF_LD_IMM64(R0, 2147483646), 4971 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647), 4972 BPF_EXIT_INSN(), 4973 }, 4974 INTERNAL, 4975 { }, 4976 { { 0, -1 } }, 4977 }, 4978 /* BPF_ALU | BPF_MUL | BPF_X */ 4979 { 4980 "ALU_MUL_X: 2 * 3 = 6", 4981 .u.insns_int = { 4982 BPF_LD_IMM64(R0, 2), 4983 BPF_ALU32_IMM(BPF_MOV, R1, 3), 4984 BPF_ALU32_REG(BPF_MUL, R0, R1), 4985 BPF_EXIT_INSN(), 4986 }, 4987 INTERNAL, 4988 { }, 4989 { { 0, 6 } }, 4990 }, 4991 { 4992 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 4993 .u.insns_int = { 4994 BPF_LD_IMM64(R0, 2), 4995 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8), 4996 BPF_ALU32_REG(BPF_MUL, R0, R1), 4997 BPF_EXIT_INSN(), 4998 }, 4999 INTERNAL, 5000 { }, 5001 { { 0, 0xFFFFFFF0 } }, 5002 }, 5003 { 5004 "ALU_MUL_X: -1 * -1 = 1", 5005 .u.insns_int = { 5006 BPF_LD_IMM64(R0, -1), 5007 BPF_ALU32_IMM(BPF_MOV, R1, -1), 5008 BPF_ALU32_REG(BPF_MUL, R0, R1), 5009 BPF_EXIT_INSN(), 5010 }, 5011 INTERNAL, 5012 { }, 5013 { { 0, 1 } }, 5014 }, 5015 { 5016 "ALU64_MUL_X: 2 * 3 = 6", 5017 .u.insns_int = { 5018 BPF_LD_IMM64(R0, 2), 5019 BPF_ALU32_IMM(BPF_MOV, R1, 3), 5020 BPF_ALU64_REG(BPF_MUL, R0, R1), 5021 BPF_EXIT_INSN(), 5022 }, 5023 INTERNAL, 5024 { }, 5025 { { 0, 6 } }, 5026 }, 5027 { 5028 "ALU64_MUL_X: 1 * 2147483647 = 2147483647", 5029 .u.insns_int = { 5030 BPF_LD_IMM64(R0, 1), 5031 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 5032 BPF_ALU64_REG(BPF_MUL, R0, R1), 5033 BPF_EXIT_INSN(), 5034 }, 5035 INTERNAL, 5036 { }, 5037 { { 0, 2147483647 } }, 5038 }, 5039 { 5040 "ALU64_MUL_X: 64x64 multiply, low word", 5041 .u.insns_int = { 5042 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 5043 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 5044 BPF_ALU64_REG(BPF_MUL, R0, R1), 5045 BPF_EXIT_INSN(), 5046 }, 5047 INTERNAL, 5048 { }, 5049 { { 0, 0xe5618cf0 } } 5050 }, 5051 { 5052 "ALU64_MUL_X: 64x64 multiply, high word", 5053 .u.insns_int = { 5054 BPF_LD_IMM64(R0, 0x0fedcba987654321LL), 5055 BPF_LD_IMM64(R1, 0x123456789abcdef0LL), 5056 BPF_ALU64_REG(BPF_MUL, R0, R1), 5057 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5058 BPF_EXIT_INSN(), 5059 }, 5060 INTERNAL, 5061 { }, 5062 { { 0, 0x2236d88f } } 5063 }, 5064 /* BPF_ALU | BPF_MUL | BPF_K */ 5065 { 5066 "ALU_MUL_K: 2 * 3 = 6", 5067 .u.insns_int = { 5068 BPF_LD_IMM64(R0, 2), 5069 BPF_ALU32_IMM(BPF_MUL, R0, 3), 5070 BPF_EXIT_INSN(), 5071 }, 5072 INTERNAL, 5073 { }, 5074 { { 0, 6 } }, 5075 }, 5076 { 5077 "ALU_MUL_K: 3 * 1 = 3", 5078 .u.insns_int = { 5079 BPF_LD_IMM64(R0, 3), 5080 BPF_ALU32_IMM(BPF_MUL, R0, 1), 5081 BPF_EXIT_INSN(), 5082 }, 5083 INTERNAL, 5084 { }, 5085 { { 0, 3 } }, 5086 }, 5087 { 5088 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 5089 .u.insns_int = { 5090 BPF_LD_IMM64(R0, 2), 5091 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8), 5092 BPF_EXIT_INSN(), 5093 }, 5094 INTERNAL, 5095 { }, 5096 { { 0, 0xFFFFFFF0 } }, 5097 }, 5098 { 5099 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff", 5100 .u.insns_int = { 5101 BPF_LD_IMM64(R2, 0x1), 5102 BPF_LD_IMM64(R3, 0x00000000ffffffff), 5103 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff), 5104 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5105 BPF_MOV32_IMM(R0, 2), 5106 BPF_EXIT_INSN(), 5107 BPF_MOV32_IMM(R0, 1), 5108 BPF_EXIT_INSN(), 5109 }, 5110 INTERNAL, 5111 { }, 5112 { { 0, 0x1 } }, 5113 }, 5114 { 5115 "ALU64_MUL_K: 2 * 3 = 6", 5116 .u.insns_int = { 5117 BPF_LD_IMM64(R0, 2), 5118 BPF_ALU64_IMM(BPF_MUL, R0, 3), 5119 BPF_EXIT_INSN(), 5120 }, 5121 INTERNAL, 5122 { }, 5123 { { 0, 6 } }, 5124 }, 5125 { 5126 "ALU64_MUL_K: 3 * 1 = 3", 5127 .u.insns_int = { 5128 BPF_LD_IMM64(R0, 3), 5129 BPF_ALU64_IMM(BPF_MUL, R0, 1), 5130 BPF_EXIT_INSN(), 5131 }, 5132 INTERNAL, 5133 { }, 5134 { { 0, 3 } }, 5135 }, 5136 { 5137 "ALU64_MUL_K: 1 * 2147483647 = 2147483647", 5138 .u.insns_int = { 5139 BPF_LD_IMM64(R0, 1), 5140 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647), 5141 BPF_EXIT_INSN(), 5142 }, 5143 INTERNAL, 5144 { }, 5145 { { 0, 2147483647 } }, 5146 }, 5147 { 5148 "ALU64_MUL_K: 1 * -2147483647 = -2147483647", 5149 .u.insns_int = { 5150 BPF_LD_IMM64(R0, 1), 5151 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647), 5152 BPF_EXIT_INSN(), 5153 }, 5154 INTERNAL, 5155 { }, 5156 { { 0, -2147483647 } }, 5157 }, 5158 { 5159 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff", 5160 .u.insns_int = { 5161 BPF_LD_IMM64(R2, 0x1), 5162 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5163 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff), 5164 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5165 BPF_MOV32_IMM(R0, 2), 5166 BPF_EXIT_INSN(), 5167 BPF_MOV32_IMM(R0, 1), 5168 BPF_EXIT_INSN(), 5169 }, 5170 INTERNAL, 5171 { }, 5172 { { 0, 0x1 } }, 5173 }, 5174 { 5175 "ALU64_MUL_K: 64x32 multiply, low word", 5176 .u.insns_int = { 5177 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5178 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 5179 BPF_EXIT_INSN(), 5180 }, 5181 INTERNAL, 5182 { }, 5183 { { 0, 0xe242d208 } } 5184 }, 5185 { 5186 "ALU64_MUL_K: 64x32 multiply, high word", 5187 .u.insns_int = { 5188 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5189 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678), 5190 BPF_ALU64_IMM(BPF_RSH, R0, 32), 5191 BPF_EXIT_INSN(), 5192 }, 5193 INTERNAL, 5194 { }, 5195 { { 0, 0xc28f5c28 } } 5196 }, 5197 /* BPF_ALU | BPF_DIV | BPF_X */ 5198 { 5199 "ALU_DIV_X: 6 / 2 = 3", 5200 .u.insns_int = { 5201 BPF_LD_IMM64(R0, 6), 5202 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5203 BPF_ALU32_REG(BPF_DIV, R0, R1), 5204 BPF_EXIT_INSN(), 5205 }, 5206 INTERNAL, 5207 { }, 5208 { { 0, 3 } }, 5209 }, 5210 { 5211 "ALU_DIV_X: 4294967295 / 4294967295 = 1", 5212 .u.insns_int = { 5213 BPF_LD_IMM64(R0, 4294967295U), 5214 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 5215 BPF_ALU32_REG(BPF_DIV, R0, R1), 5216 BPF_EXIT_INSN(), 5217 }, 5218 INTERNAL, 5219 { }, 5220 { { 0, 1 } }, 5221 }, 5222 { 5223 "ALU64_DIV_X: 6 / 2 = 3", 5224 .u.insns_int = { 5225 BPF_LD_IMM64(R0, 6), 5226 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5227 BPF_ALU64_REG(BPF_DIV, R0, R1), 5228 BPF_EXIT_INSN(), 5229 }, 5230 INTERNAL, 5231 { }, 5232 { { 0, 3 } }, 5233 }, 5234 { 5235 "ALU64_DIV_X: 2147483647 / 2147483647 = 1", 5236 .u.insns_int = { 5237 BPF_LD_IMM64(R0, 2147483647), 5238 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 5239 BPF_ALU64_REG(BPF_DIV, R0, R1), 5240 BPF_EXIT_INSN(), 5241 }, 5242 INTERNAL, 5243 { }, 5244 { { 0, 1 } }, 5245 }, 5246 { 5247 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001", 5248 .u.insns_int = { 5249 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 5250 BPF_LD_IMM64(R4, 0xffffffffffffffffLL), 5251 BPF_LD_IMM64(R3, 0x0000000000000001LL), 5252 BPF_ALU64_REG(BPF_DIV, R2, R4), 5253 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5254 BPF_MOV32_IMM(R0, 2), 5255 BPF_EXIT_INSN(), 5256 BPF_MOV32_IMM(R0, 1), 5257 BPF_EXIT_INSN(), 5258 }, 5259 INTERNAL, 5260 { }, 5261 { { 0, 0x1 } }, 5262 }, 5263 /* BPF_ALU | BPF_DIV | BPF_K */ 5264 { 5265 "ALU_DIV_K: 6 / 2 = 3", 5266 .u.insns_int = { 5267 BPF_LD_IMM64(R0, 6), 5268 BPF_ALU32_IMM(BPF_DIV, R0, 2), 5269 BPF_EXIT_INSN(), 5270 }, 5271 INTERNAL, 5272 { }, 5273 { { 0, 3 } }, 5274 }, 5275 { 5276 "ALU_DIV_K: 3 / 1 = 3", 5277 .u.insns_int = { 5278 BPF_LD_IMM64(R0, 3), 5279 BPF_ALU32_IMM(BPF_DIV, R0, 1), 5280 BPF_EXIT_INSN(), 5281 }, 5282 INTERNAL, 5283 { }, 5284 { { 0, 3 } }, 5285 }, 5286 { 5287 "ALU_DIV_K: 4294967295 / 4294967295 = 1", 5288 .u.insns_int = { 5289 BPF_LD_IMM64(R0, 4294967295U), 5290 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U), 5291 BPF_EXIT_INSN(), 5292 }, 5293 INTERNAL, 5294 { }, 5295 { { 0, 1 } }, 5296 }, 5297 { 5298 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1", 5299 .u.insns_int = { 5300 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 5301 BPF_LD_IMM64(R3, 0x1UL), 5302 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff), 5303 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5304 BPF_MOV32_IMM(R0, 2), 5305 BPF_EXIT_INSN(), 5306 BPF_MOV32_IMM(R0, 1), 5307 BPF_EXIT_INSN(), 5308 }, 5309 INTERNAL, 5310 { }, 5311 { { 0, 0x1 } }, 5312 }, 5313 { 5314 "ALU64_DIV_K: 6 / 2 = 3", 5315 .u.insns_int = { 5316 BPF_LD_IMM64(R0, 6), 5317 BPF_ALU64_IMM(BPF_DIV, R0, 2), 5318 BPF_EXIT_INSN(), 5319 }, 5320 INTERNAL, 5321 { }, 5322 { { 0, 3 } }, 5323 }, 5324 { 5325 "ALU64_DIV_K: 3 / 1 = 3", 5326 .u.insns_int = { 5327 BPF_LD_IMM64(R0, 3), 5328 BPF_ALU64_IMM(BPF_DIV, R0, 1), 5329 BPF_EXIT_INSN(), 5330 }, 5331 INTERNAL, 5332 { }, 5333 { { 0, 3 } }, 5334 }, 5335 { 5336 "ALU64_DIV_K: 2147483647 / 2147483647 = 1", 5337 .u.insns_int = { 5338 BPF_LD_IMM64(R0, 2147483647), 5339 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647), 5340 BPF_EXIT_INSN(), 5341 }, 5342 INTERNAL, 5343 { }, 5344 { { 0, 1 } }, 5345 }, 5346 { 5347 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001", 5348 .u.insns_int = { 5349 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 5350 BPF_LD_IMM64(R3, 0x0000000000000001LL), 5351 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff), 5352 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5353 BPF_MOV32_IMM(R0, 2), 5354 BPF_EXIT_INSN(), 5355 BPF_MOV32_IMM(R0, 1), 5356 BPF_EXIT_INSN(), 5357 }, 5358 INTERNAL, 5359 { }, 5360 { { 0, 0x1 } }, 5361 }, 5362 /* BPF_ALU | BPF_MOD | BPF_X */ 5363 { 5364 "ALU_MOD_X: 3 % 2 = 1", 5365 .u.insns_int = { 5366 BPF_LD_IMM64(R0, 3), 5367 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5368 BPF_ALU32_REG(BPF_MOD, R0, R1), 5369 BPF_EXIT_INSN(), 5370 }, 5371 INTERNAL, 5372 { }, 5373 { { 0, 1 } }, 5374 }, 5375 { 5376 "ALU_MOD_X: 4294967295 % 4294967293 = 2", 5377 .u.insns_int = { 5378 BPF_LD_IMM64(R0, 4294967295U), 5379 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U), 5380 BPF_ALU32_REG(BPF_MOD, R0, R1), 5381 BPF_EXIT_INSN(), 5382 }, 5383 INTERNAL, 5384 { }, 5385 { { 0, 2 } }, 5386 }, 5387 { 5388 "ALU64_MOD_X: 3 % 2 = 1", 5389 .u.insns_int = { 5390 BPF_LD_IMM64(R0, 3), 5391 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5392 BPF_ALU64_REG(BPF_MOD, R0, R1), 5393 BPF_EXIT_INSN(), 5394 }, 5395 INTERNAL, 5396 { }, 5397 { { 0, 1 } }, 5398 }, 5399 { 5400 "ALU64_MOD_X: 2147483647 % 2147483645 = 2", 5401 .u.insns_int = { 5402 BPF_LD_IMM64(R0, 2147483647), 5403 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645), 5404 BPF_ALU64_REG(BPF_MOD, R0, R1), 5405 BPF_EXIT_INSN(), 5406 }, 5407 INTERNAL, 5408 { }, 5409 { { 0, 2 } }, 5410 }, 5411 /* BPF_ALU | BPF_MOD | BPF_K */ 5412 { 5413 "ALU_MOD_K: 3 % 2 = 1", 5414 .u.insns_int = { 5415 BPF_LD_IMM64(R0, 3), 5416 BPF_ALU32_IMM(BPF_MOD, R0, 2), 5417 BPF_EXIT_INSN(), 5418 }, 5419 INTERNAL, 5420 { }, 5421 { { 0, 1 } }, 5422 }, 5423 { 5424 "ALU_MOD_K: 3 % 1 = 0", 5425 .u.insns_int = { 5426 BPF_LD_IMM64(R0, 3), 5427 BPF_ALU32_IMM(BPF_MOD, R0, 1), 5428 BPF_EXIT_INSN(), 5429 }, 5430 INTERNAL, 5431 { }, 5432 { { 0, 0 } }, 5433 }, 5434 { 5435 "ALU_MOD_K: 4294967295 % 4294967293 = 2", 5436 .u.insns_int = { 5437 BPF_LD_IMM64(R0, 4294967295U), 5438 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U), 5439 BPF_EXIT_INSN(), 5440 }, 5441 INTERNAL, 5442 { }, 5443 { { 0, 2 } }, 5444 }, 5445 { 5446 "ALU64_MOD_K: 3 % 2 = 1", 5447 .u.insns_int = { 5448 BPF_LD_IMM64(R0, 3), 5449 BPF_ALU64_IMM(BPF_MOD, R0, 2), 5450 BPF_EXIT_INSN(), 5451 }, 5452 INTERNAL, 5453 { }, 5454 { { 0, 1 } }, 5455 }, 5456 { 5457 "ALU64_MOD_K: 3 % 1 = 0", 5458 .u.insns_int = { 5459 BPF_LD_IMM64(R0, 3), 5460 BPF_ALU64_IMM(BPF_MOD, R0, 1), 5461 BPF_EXIT_INSN(), 5462 }, 5463 INTERNAL, 5464 { }, 5465 { { 0, 0 } }, 5466 }, 5467 { 5468 "ALU64_MOD_K: 2147483647 % 2147483645 = 2", 5469 .u.insns_int = { 5470 BPF_LD_IMM64(R0, 2147483647), 5471 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645), 5472 BPF_EXIT_INSN(), 5473 }, 5474 INTERNAL, 5475 { }, 5476 { { 0, 2 } }, 5477 }, 5478 /* BPF_ALU | BPF_AND | BPF_X */ 5479 { 5480 "ALU_AND_X: 3 & 2 = 2", 5481 .u.insns_int = { 5482 BPF_LD_IMM64(R0, 3), 5483 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5484 BPF_ALU32_REG(BPF_AND, R0, R1), 5485 BPF_EXIT_INSN(), 5486 }, 5487 INTERNAL, 5488 { }, 5489 { { 0, 2 } }, 5490 }, 5491 { 5492 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 5493 .u.insns_int = { 5494 BPF_LD_IMM64(R0, 0xffffffff), 5495 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5496 BPF_ALU32_REG(BPF_AND, R0, R1), 5497 BPF_EXIT_INSN(), 5498 }, 5499 INTERNAL, 5500 { }, 5501 { { 0, 0xffffffff } }, 5502 }, 5503 { 5504 "ALU64_AND_X: 3 & 2 = 2", 5505 .u.insns_int = { 5506 BPF_LD_IMM64(R0, 3), 5507 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5508 BPF_ALU64_REG(BPF_AND, R0, R1), 5509 BPF_EXIT_INSN(), 5510 }, 5511 INTERNAL, 5512 { }, 5513 { { 0, 2 } }, 5514 }, 5515 { 5516 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 5517 .u.insns_int = { 5518 BPF_LD_IMM64(R0, 0xffffffff), 5519 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5520 BPF_ALU64_REG(BPF_AND, R0, R1), 5521 BPF_EXIT_INSN(), 5522 }, 5523 INTERNAL, 5524 { }, 5525 { { 0, 0xffffffff } }, 5526 }, 5527 /* BPF_ALU | BPF_AND | BPF_K */ 5528 { 5529 "ALU_AND_K: 3 & 2 = 2", 5530 .u.insns_int = { 5531 BPF_LD_IMM64(R0, 3), 5532 BPF_ALU32_IMM(BPF_AND, R0, 2), 5533 BPF_EXIT_INSN(), 5534 }, 5535 INTERNAL, 5536 { }, 5537 { { 0, 2 } }, 5538 }, 5539 { 5540 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 5541 .u.insns_int = { 5542 BPF_LD_IMM64(R0, 0xffffffff), 5543 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff), 5544 BPF_EXIT_INSN(), 5545 }, 5546 INTERNAL, 5547 { }, 5548 { { 0, 0xffffffff } }, 5549 }, 5550 { 5551 "ALU_AND_K: Small immediate", 5552 .u.insns_int = { 5553 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 5554 BPF_ALU32_IMM(BPF_AND, R0, 15), 5555 BPF_EXIT_INSN(), 5556 }, 5557 INTERNAL, 5558 { }, 5559 { { 0, 4 } } 5560 }, 5561 { 5562 "ALU_AND_K: Large immediate", 5563 .u.insns_int = { 5564 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 5565 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf), 5566 BPF_EXIT_INSN(), 5567 }, 5568 INTERNAL, 5569 { }, 5570 { { 0, 0xa1b2c3d4 } } 5571 }, 5572 { 5573 "ALU_AND_K: Zero extension", 5574 .u.insns_int = { 5575 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5576 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL), 5577 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0), 5578 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5579 BPF_MOV32_IMM(R0, 2), 5580 BPF_EXIT_INSN(), 5581 BPF_MOV32_IMM(R0, 1), 5582 BPF_EXIT_INSN(), 5583 }, 5584 INTERNAL, 5585 { }, 5586 { { 0, 1 } } 5587 }, 5588 { 5589 "ALU64_AND_K: 3 & 2 = 2", 5590 .u.insns_int = { 5591 BPF_LD_IMM64(R0, 3), 5592 BPF_ALU64_IMM(BPF_AND, R0, 2), 5593 BPF_EXIT_INSN(), 5594 }, 5595 INTERNAL, 5596 { }, 5597 { { 0, 2 } }, 5598 }, 5599 { 5600 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 5601 .u.insns_int = { 5602 BPF_LD_IMM64(R0, 0xffffffff), 5603 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff), 5604 BPF_EXIT_INSN(), 5605 }, 5606 INTERNAL, 5607 { }, 5608 { { 0, 0xffffffff } }, 5609 }, 5610 { 5611 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000", 5612 .u.insns_int = { 5613 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5614 BPF_LD_IMM64(R3, 0x0000000000000000LL), 5615 BPF_ALU64_IMM(BPF_AND, R2, 0x0), 5616 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5617 BPF_MOV32_IMM(R0, 2), 5618 BPF_EXIT_INSN(), 5619 BPF_MOV32_IMM(R0, 1), 5620 BPF_EXIT_INSN(), 5621 }, 5622 INTERNAL, 5623 { }, 5624 { { 0, 0x1 } }, 5625 }, 5626 { 5627 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000", 5628 .u.insns_int = { 5629 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5630 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 5631 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 5632 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5633 BPF_MOV32_IMM(R0, 2), 5634 BPF_EXIT_INSN(), 5635 BPF_MOV32_IMM(R0, 1), 5636 BPF_EXIT_INSN(), 5637 }, 5638 INTERNAL, 5639 { }, 5640 { { 0, 0x1 } }, 5641 }, 5642 { 5643 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff", 5644 .u.insns_int = { 5645 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 5646 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5647 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 5648 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5649 BPF_MOV32_IMM(R0, 2), 5650 BPF_EXIT_INSN(), 5651 BPF_MOV32_IMM(R0, 1), 5652 BPF_EXIT_INSN(), 5653 }, 5654 INTERNAL, 5655 { }, 5656 { { 0, 0x1 } }, 5657 }, 5658 { 5659 "ALU64_AND_K: Sign extension 1", 5660 .u.insns_int = { 5661 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5662 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL), 5663 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f), 5664 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5665 BPF_MOV32_IMM(R0, 2), 5666 BPF_EXIT_INSN(), 5667 BPF_MOV32_IMM(R0, 1), 5668 BPF_EXIT_INSN(), 5669 }, 5670 INTERNAL, 5671 { }, 5672 { { 0, 1 } } 5673 }, 5674 { 5675 "ALU64_AND_K: Sign extension 2", 5676 .u.insns_int = { 5677 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5678 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL), 5679 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0), 5680 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5681 BPF_MOV32_IMM(R0, 2), 5682 BPF_EXIT_INSN(), 5683 BPF_MOV32_IMM(R0, 1), 5684 BPF_EXIT_INSN(), 5685 }, 5686 INTERNAL, 5687 { }, 5688 { { 0, 1 } } 5689 }, 5690 /* BPF_ALU | BPF_OR | BPF_X */ 5691 { 5692 "ALU_OR_X: 1 | 2 = 3", 5693 .u.insns_int = { 5694 BPF_LD_IMM64(R0, 1), 5695 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5696 BPF_ALU32_REG(BPF_OR, R0, R1), 5697 BPF_EXIT_INSN(), 5698 }, 5699 INTERNAL, 5700 { }, 5701 { { 0, 3 } }, 5702 }, 5703 { 5704 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff", 5705 .u.insns_int = { 5706 BPF_LD_IMM64(R0, 0), 5707 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5708 BPF_ALU32_REG(BPF_OR, R0, R1), 5709 BPF_EXIT_INSN(), 5710 }, 5711 INTERNAL, 5712 { }, 5713 { { 0, 0xffffffff } }, 5714 }, 5715 { 5716 "ALU64_OR_X: 1 | 2 = 3", 5717 .u.insns_int = { 5718 BPF_LD_IMM64(R0, 1), 5719 BPF_ALU32_IMM(BPF_MOV, R1, 2), 5720 BPF_ALU64_REG(BPF_OR, R0, R1), 5721 BPF_EXIT_INSN(), 5722 }, 5723 INTERNAL, 5724 { }, 5725 { { 0, 3 } }, 5726 }, 5727 { 5728 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff", 5729 .u.insns_int = { 5730 BPF_LD_IMM64(R0, 0), 5731 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5732 BPF_ALU64_REG(BPF_OR, R0, R1), 5733 BPF_EXIT_INSN(), 5734 }, 5735 INTERNAL, 5736 { }, 5737 { { 0, 0xffffffff } }, 5738 }, 5739 /* BPF_ALU | BPF_OR | BPF_K */ 5740 { 5741 "ALU_OR_K: 1 | 2 = 3", 5742 .u.insns_int = { 5743 BPF_LD_IMM64(R0, 1), 5744 BPF_ALU32_IMM(BPF_OR, R0, 2), 5745 BPF_EXIT_INSN(), 5746 }, 5747 INTERNAL, 5748 { }, 5749 { { 0, 3 } }, 5750 }, 5751 { 5752 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff", 5753 .u.insns_int = { 5754 BPF_LD_IMM64(R0, 0), 5755 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff), 5756 BPF_EXIT_INSN(), 5757 }, 5758 INTERNAL, 5759 { }, 5760 { { 0, 0xffffffff } }, 5761 }, 5762 { 5763 "ALU_OR_K: Small immediate", 5764 .u.insns_int = { 5765 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 5766 BPF_ALU32_IMM(BPF_OR, R0, 1), 5767 BPF_EXIT_INSN(), 5768 }, 5769 INTERNAL, 5770 { }, 5771 { { 0, 0x01020305 } } 5772 }, 5773 { 5774 "ALU_OR_K: Large immediate", 5775 .u.insns_int = { 5776 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 5777 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0), 5778 BPF_EXIT_INSN(), 5779 }, 5780 INTERNAL, 5781 { }, 5782 { { 0, 0xa1b2c3d4 } } 5783 }, 5784 { 5785 "ALU_OR_K: Zero extension", 5786 .u.insns_int = { 5787 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5788 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL), 5789 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0), 5790 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5791 BPF_MOV32_IMM(R0, 2), 5792 BPF_EXIT_INSN(), 5793 BPF_MOV32_IMM(R0, 1), 5794 BPF_EXIT_INSN(), 5795 }, 5796 INTERNAL, 5797 { }, 5798 { { 0, 1 } } 5799 }, 5800 { 5801 "ALU64_OR_K: 1 | 2 = 3", 5802 .u.insns_int = { 5803 BPF_LD_IMM64(R0, 1), 5804 BPF_ALU64_IMM(BPF_OR, R0, 2), 5805 BPF_EXIT_INSN(), 5806 }, 5807 INTERNAL, 5808 { }, 5809 { { 0, 3 } }, 5810 }, 5811 { 5812 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff", 5813 .u.insns_int = { 5814 BPF_LD_IMM64(R0, 0), 5815 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff), 5816 BPF_EXIT_INSN(), 5817 }, 5818 INTERNAL, 5819 { }, 5820 { { 0, 0xffffffff } }, 5821 }, 5822 { 5823 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000", 5824 .u.insns_int = { 5825 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5826 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 5827 BPF_ALU64_IMM(BPF_OR, R2, 0x0), 5828 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5829 BPF_MOV32_IMM(R0, 2), 5830 BPF_EXIT_INSN(), 5831 BPF_MOV32_IMM(R0, 1), 5832 BPF_EXIT_INSN(), 5833 }, 5834 INTERNAL, 5835 { }, 5836 { { 0, 0x1 } }, 5837 }, 5838 { 5839 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff", 5840 .u.insns_int = { 5841 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 5842 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5843 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 5844 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5845 BPF_MOV32_IMM(R0, 2), 5846 BPF_EXIT_INSN(), 5847 BPF_MOV32_IMM(R0, 1), 5848 BPF_EXIT_INSN(), 5849 }, 5850 INTERNAL, 5851 { }, 5852 { { 0, 0x1 } }, 5853 }, 5854 { 5855 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff", 5856 .u.insns_int = { 5857 BPF_LD_IMM64(R2, 0x0000000000000000LL), 5858 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 5859 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 5860 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 5861 BPF_MOV32_IMM(R0, 2), 5862 BPF_EXIT_INSN(), 5863 BPF_MOV32_IMM(R0, 1), 5864 BPF_EXIT_INSN(), 5865 }, 5866 INTERNAL, 5867 { }, 5868 { { 0, 0x1 } }, 5869 }, 5870 { 5871 "ALU64_OR_K: Sign extension 1", 5872 .u.insns_int = { 5873 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5874 BPF_LD_IMM64(R1, 0x012345678fafcfefLL), 5875 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f), 5876 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5877 BPF_MOV32_IMM(R0, 2), 5878 BPF_EXIT_INSN(), 5879 BPF_MOV32_IMM(R0, 1), 5880 BPF_EXIT_INSN(), 5881 }, 5882 INTERNAL, 5883 { }, 5884 { { 0, 1 } } 5885 }, 5886 { 5887 "ALU64_OR_K: Sign extension 2", 5888 .u.insns_int = { 5889 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 5890 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL), 5891 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0), 5892 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 5893 BPF_MOV32_IMM(R0, 2), 5894 BPF_EXIT_INSN(), 5895 BPF_MOV32_IMM(R0, 1), 5896 BPF_EXIT_INSN(), 5897 }, 5898 INTERNAL, 5899 { }, 5900 { { 0, 1 } } 5901 }, 5902 /* BPF_ALU | BPF_XOR | BPF_X */ 5903 { 5904 "ALU_XOR_X: 5 ^ 6 = 3", 5905 .u.insns_int = { 5906 BPF_LD_IMM64(R0, 5), 5907 BPF_ALU32_IMM(BPF_MOV, R1, 6), 5908 BPF_ALU32_REG(BPF_XOR, R0, R1), 5909 BPF_EXIT_INSN(), 5910 }, 5911 INTERNAL, 5912 { }, 5913 { { 0, 3 } }, 5914 }, 5915 { 5916 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe", 5917 .u.insns_int = { 5918 BPF_LD_IMM64(R0, 1), 5919 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5920 BPF_ALU32_REG(BPF_XOR, R0, R1), 5921 BPF_EXIT_INSN(), 5922 }, 5923 INTERNAL, 5924 { }, 5925 { { 0, 0xfffffffe } }, 5926 }, 5927 { 5928 "ALU64_XOR_X: 5 ^ 6 = 3", 5929 .u.insns_int = { 5930 BPF_LD_IMM64(R0, 5), 5931 BPF_ALU32_IMM(BPF_MOV, R1, 6), 5932 BPF_ALU64_REG(BPF_XOR, R0, R1), 5933 BPF_EXIT_INSN(), 5934 }, 5935 INTERNAL, 5936 { }, 5937 { { 0, 3 } }, 5938 }, 5939 { 5940 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe", 5941 .u.insns_int = { 5942 BPF_LD_IMM64(R0, 1), 5943 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 5944 BPF_ALU64_REG(BPF_XOR, R0, R1), 5945 BPF_EXIT_INSN(), 5946 }, 5947 INTERNAL, 5948 { }, 5949 { { 0, 0xfffffffe } }, 5950 }, 5951 /* BPF_ALU | BPF_XOR | BPF_K */ 5952 { 5953 "ALU_XOR_K: 5 ^ 6 = 3", 5954 .u.insns_int = { 5955 BPF_LD_IMM64(R0, 5), 5956 BPF_ALU32_IMM(BPF_XOR, R0, 6), 5957 BPF_EXIT_INSN(), 5958 }, 5959 INTERNAL, 5960 { }, 5961 { { 0, 3 } }, 5962 }, 5963 { 5964 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 5965 .u.insns_int = { 5966 BPF_LD_IMM64(R0, 1), 5967 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff), 5968 BPF_EXIT_INSN(), 5969 }, 5970 INTERNAL, 5971 { }, 5972 { { 0, 0xfffffffe } }, 5973 }, 5974 { 5975 "ALU_XOR_K: Small immediate", 5976 .u.insns_int = { 5977 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304), 5978 BPF_ALU32_IMM(BPF_XOR, R0, 15), 5979 BPF_EXIT_INSN(), 5980 }, 5981 INTERNAL, 5982 { }, 5983 { { 0, 0x0102030b } } 5984 }, 5985 { 5986 "ALU_XOR_K: Large immediate", 5987 .u.insns_int = { 5988 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4), 5989 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf), 5990 BPF_EXIT_INSN(), 5991 }, 5992 INTERNAL, 5993 { }, 5994 { { 0, 0x5e4d3c2b } } 5995 }, 5996 { 5997 "ALU_XOR_K: Zero extension", 5998 .u.insns_int = { 5999 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6000 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL), 6001 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0), 6002 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6003 BPF_MOV32_IMM(R0, 2), 6004 BPF_EXIT_INSN(), 6005 BPF_MOV32_IMM(R0, 1), 6006 BPF_EXIT_INSN(), 6007 }, 6008 INTERNAL, 6009 { }, 6010 { { 0, 1 } } 6011 }, 6012 { 6013 "ALU64_XOR_K: 5 ^ 6 = 3", 6014 .u.insns_int = { 6015 BPF_LD_IMM64(R0, 5), 6016 BPF_ALU64_IMM(BPF_XOR, R0, 6), 6017 BPF_EXIT_INSN(), 6018 }, 6019 INTERNAL, 6020 { }, 6021 { { 0, 3 } }, 6022 }, 6023 { 6024 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 6025 .u.insns_int = { 6026 BPF_LD_IMM64(R0, 1), 6027 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff), 6028 BPF_EXIT_INSN(), 6029 }, 6030 INTERNAL, 6031 { }, 6032 { { 0, 0xfffffffe } }, 6033 }, 6034 { 6035 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000", 6036 .u.insns_int = { 6037 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6038 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 6039 BPF_ALU64_IMM(BPF_XOR, R2, 0x0), 6040 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6041 BPF_MOV32_IMM(R0, 2), 6042 BPF_EXIT_INSN(), 6043 BPF_MOV32_IMM(R0, 1), 6044 BPF_EXIT_INSN(), 6045 }, 6046 INTERNAL, 6047 { }, 6048 { { 0, 0x1 } }, 6049 }, 6050 { 6051 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff", 6052 .u.insns_int = { 6053 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 6054 BPF_LD_IMM64(R3, 0xffff00000000ffffLL), 6055 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 6056 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6057 BPF_MOV32_IMM(R0, 2), 6058 BPF_EXIT_INSN(), 6059 BPF_MOV32_IMM(R0, 1), 6060 BPF_EXIT_INSN(), 6061 }, 6062 INTERNAL, 6063 { }, 6064 { { 0, 0x1 } }, 6065 }, 6066 { 6067 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff", 6068 .u.insns_int = { 6069 BPF_LD_IMM64(R2, 0x0000000000000000LL), 6070 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 6071 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 6072 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 6073 BPF_MOV32_IMM(R0, 2), 6074 BPF_EXIT_INSN(), 6075 BPF_MOV32_IMM(R0, 1), 6076 BPF_EXIT_INSN(), 6077 }, 6078 INTERNAL, 6079 { }, 6080 { { 0, 0x1 } }, 6081 }, 6082 { 6083 "ALU64_XOR_K: Sign extension 1", 6084 .u.insns_int = { 6085 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6086 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL), 6087 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f), 6088 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6089 BPF_MOV32_IMM(R0, 2), 6090 BPF_EXIT_INSN(), 6091 BPF_MOV32_IMM(R0, 1), 6092 BPF_EXIT_INSN(), 6093 }, 6094 INTERNAL, 6095 { }, 6096 { { 0, 1 } } 6097 }, 6098 { 6099 "ALU64_XOR_K: Sign extension 2", 6100 .u.insns_int = { 6101 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6102 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL), 6103 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0), 6104 BPF_JMP_REG(BPF_JEQ, R0, R1, 2), 6105 BPF_MOV32_IMM(R0, 2), 6106 BPF_EXIT_INSN(), 6107 BPF_MOV32_IMM(R0, 1), 6108 BPF_EXIT_INSN(), 6109 }, 6110 INTERNAL, 6111 { }, 6112 { { 0, 1 } } 6113 }, 6114 /* BPF_ALU | BPF_LSH | BPF_X */ 6115 { 6116 "ALU_LSH_X: 1 << 1 = 2", 6117 .u.insns_int = { 6118 BPF_LD_IMM64(R0, 1), 6119 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6120 BPF_ALU32_REG(BPF_LSH, R0, R1), 6121 BPF_EXIT_INSN(), 6122 }, 6123 INTERNAL, 6124 { }, 6125 { { 0, 2 } }, 6126 }, 6127 { 6128 "ALU_LSH_X: 1 << 31 = 0x80000000", 6129 .u.insns_int = { 6130 BPF_LD_IMM64(R0, 1), 6131 BPF_ALU32_IMM(BPF_MOV, R1, 31), 6132 BPF_ALU32_REG(BPF_LSH, R0, R1), 6133 BPF_EXIT_INSN(), 6134 }, 6135 INTERNAL, 6136 { }, 6137 { { 0, 0x80000000 } }, 6138 }, 6139 { 6140 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000", 6141 .u.insns_int = { 6142 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6143 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6144 BPF_ALU32_REG(BPF_LSH, R0, R1), 6145 BPF_EXIT_INSN(), 6146 }, 6147 INTERNAL, 6148 { }, 6149 { { 0, 0x45678000 } } 6150 }, 6151 { 6152 "ALU64_LSH_X: 1 << 1 = 2", 6153 .u.insns_int = { 6154 BPF_LD_IMM64(R0, 1), 6155 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6156 BPF_ALU64_REG(BPF_LSH, R0, R1), 6157 BPF_EXIT_INSN(), 6158 }, 6159 INTERNAL, 6160 { }, 6161 { { 0, 2 } }, 6162 }, 6163 { 6164 "ALU64_LSH_X: 1 << 31 = 0x80000000", 6165 .u.insns_int = { 6166 BPF_LD_IMM64(R0, 1), 6167 BPF_ALU32_IMM(BPF_MOV, R1, 31), 6168 BPF_ALU64_REG(BPF_LSH, R0, R1), 6169 BPF_EXIT_INSN(), 6170 }, 6171 INTERNAL, 6172 { }, 6173 { { 0, 0x80000000 } }, 6174 }, 6175 { 6176 "ALU64_LSH_X: Shift < 32, low word", 6177 .u.insns_int = { 6178 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6179 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6180 BPF_ALU64_REG(BPF_LSH, R0, R1), 6181 BPF_EXIT_INSN(), 6182 }, 6183 INTERNAL, 6184 { }, 6185 { { 0, 0xbcdef000 } } 6186 }, 6187 { 6188 "ALU64_LSH_X: Shift < 32, high word", 6189 .u.insns_int = { 6190 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6191 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6192 BPF_ALU64_REG(BPF_LSH, R0, R1), 6193 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6194 BPF_EXIT_INSN(), 6195 }, 6196 INTERNAL, 6197 { }, 6198 { { 0, 0x3456789a } } 6199 }, 6200 { 6201 "ALU64_LSH_X: Shift > 32, low word", 6202 .u.insns_int = { 6203 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6204 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6205 BPF_ALU64_REG(BPF_LSH, R0, R1), 6206 BPF_EXIT_INSN(), 6207 }, 6208 INTERNAL, 6209 { }, 6210 { { 0, 0 } } 6211 }, 6212 { 6213 "ALU64_LSH_X: Shift > 32, high word", 6214 .u.insns_int = { 6215 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6216 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6217 BPF_ALU64_REG(BPF_LSH, R0, R1), 6218 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6219 BPF_EXIT_INSN(), 6220 }, 6221 INTERNAL, 6222 { }, 6223 { { 0, 0x9abcdef0 } } 6224 }, 6225 { 6226 "ALU64_LSH_X: Shift == 32, low word", 6227 .u.insns_int = { 6228 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6229 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6230 BPF_ALU64_REG(BPF_LSH, R0, R1), 6231 BPF_EXIT_INSN(), 6232 }, 6233 INTERNAL, 6234 { }, 6235 { { 0, 0 } } 6236 }, 6237 { 6238 "ALU64_LSH_X: Shift == 32, high word", 6239 .u.insns_int = { 6240 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6241 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6242 BPF_ALU64_REG(BPF_LSH, R0, R1), 6243 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6244 BPF_EXIT_INSN(), 6245 }, 6246 INTERNAL, 6247 { }, 6248 { { 0, 0x89abcdef } } 6249 }, 6250 { 6251 "ALU64_LSH_X: Zero shift, low word", 6252 .u.insns_int = { 6253 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6254 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6255 BPF_ALU64_REG(BPF_LSH, R0, R1), 6256 BPF_EXIT_INSN(), 6257 }, 6258 INTERNAL, 6259 { }, 6260 { { 0, 0x89abcdef } } 6261 }, 6262 { 6263 "ALU64_LSH_X: Zero shift, high word", 6264 .u.insns_int = { 6265 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6266 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6267 BPF_ALU64_REG(BPF_LSH, R0, R1), 6268 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6269 BPF_EXIT_INSN(), 6270 }, 6271 INTERNAL, 6272 { }, 6273 { { 0, 0x01234567 } } 6274 }, 6275 /* BPF_ALU | BPF_LSH | BPF_K */ 6276 { 6277 "ALU_LSH_K: 1 << 1 = 2", 6278 .u.insns_int = { 6279 BPF_LD_IMM64(R0, 1), 6280 BPF_ALU32_IMM(BPF_LSH, R0, 1), 6281 BPF_EXIT_INSN(), 6282 }, 6283 INTERNAL, 6284 { }, 6285 { { 0, 2 } }, 6286 }, 6287 { 6288 "ALU_LSH_K: 1 << 31 = 0x80000000", 6289 .u.insns_int = { 6290 BPF_LD_IMM64(R0, 1), 6291 BPF_ALU32_IMM(BPF_LSH, R0, 31), 6292 BPF_EXIT_INSN(), 6293 }, 6294 INTERNAL, 6295 { }, 6296 { { 0, 0x80000000 } }, 6297 }, 6298 { 6299 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000", 6300 .u.insns_int = { 6301 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6302 BPF_ALU32_IMM(BPF_LSH, R0, 12), 6303 BPF_EXIT_INSN(), 6304 }, 6305 INTERNAL, 6306 { }, 6307 { { 0, 0x45678000 } } 6308 }, 6309 { 6310 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678", 6311 .u.insns_int = { 6312 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6313 BPF_ALU32_IMM(BPF_LSH, R0, 0), 6314 BPF_EXIT_INSN(), 6315 }, 6316 INTERNAL, 6317 { }, 6318 { { 0, 0x12345678 } } 6319 }, 6320 { 6321 "ALU64_LSH_K: 1 << 1 = 2", 6322 .u.insns_int = { 6323 BPF_LD_IMM64(R0, 1), 6324 BPF_ALU64_IMM(BPF_LSH, R0, 1), 6325 BPF_EXIT_INSN(), 6326 }, 6327 INTERNAL, 6328 { }, 6329 { { 0, 2 } }, 6330 }, 6331 { 6332 "ALU64_LSH_K: 1 << 31 = 0x80000000", 6333 .u.insns_int = { 6334 BPF_LD_IMM64(R0, 1), 6335 BPF_ALU64_IMM(BPF_LSH, R0, 31), 6336 BPF_EXIT_INSN(), 6337 }, 6338 INTERNAL, 6339 { }, 6340 { { 0, 0x80000000 } }, 6341 }, 6342 { 6343 "ALU64_LSH_K: Shift < 32, low word", 6344 .u.insns_int = { 6345 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6346 BPF_ALU64_IMM(BPF_LSH, R0, 12), 6347 BPF_EXIT_INSN(), 6348 }, 6349 INTERNAL, 6350 { }, 6351 { { 0, 0xbcdef000 } } 6352 }, 6353 { 6354 "ALU64_LSH_K: Shift < 32, high word", 6355 .u.insns_int = { 6356 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6357 BPF_ALU64_IMM(BPF_LSH, R0, 12), 6358 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6359 BPF_EXIT_INSN(), 6360 }, 6361 INTERNAL, 6362 { }, 6363 { { 0, 0x3456789a } } 6364 }, 6365 { 6366 "ALU64_LSH_K: Shift > 32, low word", 6367 .u.insns_int = { 6368 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6369 BPF_ALU64_IMM(BPF_LSH, R0, 36), 6370 BPF_EXIT_INSN(), 6371 }, 6372 INTERNAL, 6373 { }, 6374 { { 0, 0 } } 6375 }, 6376 { 6377 "ALU64_LSH_K: Shift > 32, high word", 6378 .u.insns_int = { 6379 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6380 BPF_ALU64_IMM(BPF_LSH, R0, 36), 6381 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6382 BPF_EXIT_INSN(), 6383 }, 6384 INTERNAL, 6385 { }, 6386 { { 0, 0x9abcdef0 } } 6387 }, 6388 { 6389 "ALU64_LSH_K: Shift == 32, low word", 6390 .u.insns_int = { 6391 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6392 BPF_ALU64_IMM(BPF_LSH, R0, 32), 6393 BPF_EXIT_INSN(), 6394 }, 6395 INTERNAL, 6396 { }, 6397 { { 0, 0 } } 6398 }, 6399 { 6400 "ALU64_LSH_K: Shift == 32, high word", 6401 .u.insns_int = { 6402 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6403 BPF_ALU64_IMM(BPF_LSH, R0, 32), 6404 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6405 BPF_EXIT_INSN(), 6406 }, 6407 INTERNAL, 6408 { }, 6409 { { 0, 0x89abcdef } } 6410 }, 6411 { 6412 "ALU64_LSH_K: Zero shift", 6413 .u.insns_int = { 6414 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6415 BPF_ALU64_IMM(BPF_LSH, R0, 0), 6416 BPF_EXIT_INSN(), 6417 }, 6418 INTERNAL, 6419 { }, 6420 { { 0, 0x89abcdef } } 6421 }, 6422 /* BPF_ALU | BPF_RSH | BPF_X */ 6423 { 6424 "ALU_RSH_X: 2 >> 1 = 1", 6425 .u.insns_int = { 6426 BPF_LD_IMM64(R0, 2), 6427 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6428 BPF_ALU32_REG(BPF_RSH, R0, R1), 6429 BPF_EXIT_INSN(), 6430 }, 6431 INTERNAL, 6432 { }, 6433 { { 0, 1 } }, 6434 }, 6435 { 6436 "ALU_RSH_X: 0x80000000 >> 31 = 1", 6437 .u.insns_int = { 6438 BPF_LD_IMM64(R0, 0x80000000), 6439 BPF_ALU32_IMM(BPF_MOV, R1, 31), 6440 BPF_ALU32_REG(BPF_RSH, R0, R1), 6441 BPF_EXIT_INSN(), 6442 }, 6443 INTERNAL, 6444 { }, 6445 { { 0, 1 } }, 6446 }, 6447 { 6448 "ALU_RSH_X: 0x12345678 >> 20 = 0x123", 6449 .u.insns_int = { 6450 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6451 BPF_ALU32_IMM(BPF_MOV, R1, 20), 6452 BPF_ALU32_REG(BPF_RSH, R0, R1), 6453 BPF_EXIT_INSN(), 6454 }, 6455 INTERNAL, 6456 { }, 6457 { { 0, 0x123 } } 6458 }, 6459 { 6460 "ALU64_RSH_X: 2 >> 1 = 1", 6461 .u.insns_int = { 6462 BPF_LD_IMM64(R0, 2), 6463 BPF_ALU32_IMM(BPF_MOV, R1, 1), 6464 BPF_ALU64_REG(BPF_RSH, R0, R1), 6465 BPF_EXIT_INSN(), 6466 }, 6467 INTERNAL, 6468 { }, 6469 { { 0, 1 } }, 6470 }, 6471 { 6472 "ALU64_RSH_X: 0x80000000 >> 31 = 1", 6473 .u.insns_int = { 6474 BPF_LD_IMM64(R0, 0x80000000), 6475 BPF_ALU32_IMM(BPF_MOV, R1, 31), 6476 BPF_ALU64_REG(BPF_RSH, R0, R1), 6477 BPF_EXIT_INSN(), 6478 }, 6479 INTERNAL, 6480 { }, 6481 { { 0, 1 } }, 6482 }, 6483 { 6484 "ALU64_RSH_X: Shift < 32, low word", 6485 .u.insns_int = { 6486 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6487 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6488 BPF_ALU64_REG(BPF_RSH, R0, R1), 6489 BPF_EXIT_INSN(), 6490 }, 6491 INTERNAL, 6492 { }, 6493 { { 0, 0x56789abc } } 6494 }, 6495 { 6496 "ALU64_RSH_X: Shift < 32, high word", 6497 .u.insns_int = { 6498 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6499 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6500 BPF_ALU64_REG(BPF_RSH, R0, R1), 6501 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6502 BPF_EXIT_INSN(), 6503 }, 6504 INTERNAL, 6505 { }, 6506 { { 0, 0x00081234 } } 6507 }, 6508 { 6509 "ALU64_RSH_X: Shift > 32, low word", 6510 .u.insns_int = { 6511 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6512 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6513 BPF_ALU64_REG(BPF_RSH, R0, R1), 6514 BPF_EXIT_INSN(), 6515 }, 6516 INTERNAL, 6517 { }, 6518 { { 0, 0x08123456 } } 6519 }, 6520 { 6521 "ALU64_RSH_X: Shift > 32, high word", 6522 .u.insns_int = { 6523 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6524 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6525 BPF_ALU64_REG(BPF_RSH, R0, R1), 6526 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6527 BPF_EXIT_INSN(), 6528 }, 6529 INTERNAL, 6530 { }, 6531 { { 0, 0 } } 6532 }, 6533 { 6534 "ALU64_RSH_X: Shift == 32, low word", 6535 .u.insns_int = { 6536 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6537 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6538 BPF_ALU64_REG(BPF_RSH, R0, R1), 6539 BPF_EXIT_INSN(), 6540 }, 6541 INTERNAL, 6542 { }, 6543 { { 0, 0x81234567 } } 6544 }, 6545 { 6546 "ALU64_RSH_X: Shift == 32, high word", 6547 .u.insns_int = { 6548 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6549 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6550 BPF_ALU64_REG(BPF_RSH, R0, R1), 6551 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6552 BPF_EXIT_INSN(), 6553 }, 6554 INTERNAL, 6555 { }, 6556 { { 0, 0 } } 6557 }, 6558 { 6559 "ALU64_RSH_X: Zero shift, low word", 6560 .u.insns_int = { 6561 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6562 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6563 BPF_ALU64_REG(BPF_RSH, R0, R1), 6564 BPF_EXIT_INSN(), 6565 }, 6566 INTERNAL, 6567 { }, 6568 { { 0, 0x89abcdef } } 6569 }, 6570 { 6571 "ALU64_RSH_X: Zero shift, high word", 6572 .u.insns_int = { 6573 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6574 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6575 BPF_ALU64_REG(BPF_RSH, R0, R1), 6576 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6577 BPF_EXIT_INSN(), 6578 }, 6579 INTERNAL, 6580 { }, 6581 { { 0, 0x81234567 } } 6582 }, 6583 /* BPF_ALU | BPF_RSH | BPF_K */ 6584 { 6585 "ALU_RSH_K: 2 >> 1 = 1", 6586 .u.insns_int = { 6587 BPF_LD_IMM64(R0, 2), 6588 BPF_ALU32_IMM(BPF_RSH, R0, 1), 6589 BPF_EXIT_INSN(), 6590 }, 6591 INTERNAL, 6592 { }, 6593 { { 0, 1 } }, 6594 }, 6595 { 6596 "ALU_RSH_K: 0x80000000 >> 31 = 1", 6597 .u.insns_int = { 6598 BPF_LD_IMM64(R0, 0x80000000), 6599 BPF_ALU32_IMM(BPF_RSH, R0, 31), 6600 BPF_EXIT_INSN(), 6601 }, 6602 INTERNAL, 6603 { }, 6604 { { 0, 1 } }, 6605 }, 6606 { 6607 "ALU_RSH_K: 0x12345678 >> 20 = 0x123", 6608 .u.insns_int = { 6609 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6610 BPF_ALU32_IMM(BPF_RSH, R0, 20), 6611 BPF_EXIT_INSN(), 6612 }, 6613 INTERNAL, 6614 { }, 6615 { { 0, 0x123 } } 6616 }, 6617 { 6618 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678", 6619 .u.insns_int = { 6620 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678), 6621 BPF_ALU32_IMM(BPF_RSH, R0, 0), 6622 BPF_EXIT_INSN(), 6623 }, 6624 INTERNAL, 6625 { }, 6626 { { 0, 0x12345678 } } 6627 }, 6628 { 6629 "ALU64_RSH_K: 2 >> 1 = 1", 6630 .u.insns_int = { 6631 BPF_LD_IMM64(R0, 2), 6632 BPF_ALU64_IMM(BPF_RSH, R0, 1), 6633 BPF_EXIT_INSN(), 6634 }, 6635 INTERNAL, 6636 { }, 6637 { { 0, 1 } }, 6638 }, 6639 { 6640 "ALU64_RSH_K: 0x80000000 >> 31 = 1", 6641 .u.insns_int = { 6642 BPF_LD_IMM64(R0, 0x80000000), 6643 BPF_ALU64_IMM(BPF_RSH, R0, 31), 6644 BPF_EXIT_INSN(), 6645 }, 6646 INTERNAL, 6647 { }, 6648 { { 0, 1 } }, 6649 }, 6650 { 6651 "ALU64_RSH_K: Shift < 32, low word", 6652 .u.insns_int = { 6653 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6654 BPF_ALU64_IMM(BPF_RSH, R0, 12), 6655 BPF_EXIT_INSN(), 6656 }, 6657 INTERNAL, 6658 { }, 6659 { { 0, 0x56789abc } } 6660 }, 6661 { 6662 "ALU64_RSH_K: Shift < 32, high word", 6663 .u.insns_int = { 6664 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6665 BPF_ALU64_IMM(BPF_RSH, R0, 12), 6666 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6667 BPF_EXIT_INSN(), 6668 }, 6669 INTERNAL, 6670 { }, 6671 { { 0, 0x00081234 } } 6672 }, 6673 { 6674 "ALU64_RSH_K: Shift > 32, low word", 6675 .u.insns_int = { 6676 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6677 BPF_ALU64_IMM(BPF_RSH, R0, 36), 6678 BPF_EXIT_INSN(), 6679 }, 6680 INTERNAL, 6681 { }, 6682 { { 0, 0x08123456 } } 6683 }, 6684 { 6685 "ALU64_RSH_K: Shift > 32, high word", 6686 .u.insns_int = { 6687 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6688 BPF_ALU64_IMM(BPF_RSH, R0, 36), 6689 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6690 BPF_EXIT_INSN(), 6691 }, 6692 INTERNAL, 6693 { }, 6694 { { 0, 0 } } 6695 }, 6696 { 6697 "ALU64_RSH_K: Shift == 32, low word", 6698 .u.insns_int = { 6699 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6700 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6701 BPF_EXIT_INSN(), 6702 }, 6703 INTERNAL, 6704 { }, 6705 { { 0, 0x81234567 } } 6706 }, 6707 { 6708 "ALU64_RSH_K: Shift == 32, high word", 6709 .u.insns_int = { 6710 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6711 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6712 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6713 BPF_EXIT_INSN(), 6714 }, 6715 INTERNAL, 6716 { }, 6717 { { 0, 0 } } 6718 }, 6719 { 6720 "ALU64_RSH_K: Zero shift", 6721 .u.insns_int = { 6722 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 6723 BPF_ALU64_IMM(BPF_RSH, R0, 0), 6724 BPF_EXIT_INSN(), 6725 }, 6726 INTERNAL, 6727 { }, 6728 { { 0, 0x89abcdef } } 6729 }, 6730 /* BPF_ALU | BPF_ARSH | BPF_X */ 6731 { 6732 "ALU32_ARSH_X: -1234 >> 7 = -10", 6733 .u.insns_int = { 6734 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 6735 BPF_ALU32_IMM(BPF_MOV, R1, 7), 6736 BPF_ALU32_REG(BPF_ARSH, R0, R1), 6737 BPF_EXIT_INSN(), 6738 }, 6739 INTERNAL, 6740 { }, 6741 { { 0, -10 } } 6742 }, 6743 { 6744 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 6745 .u.insns_int = { 6746 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 6747 BPF_ALU32_IMM(BPF_MOV, R1, 40), 6748 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6749 BPF_EXIT_INSN(), 6750 }, 6751 INTERNAL, 6752 { }, 6753 { { 0, 0xffff00ff } }, 6754 }, 6755 { 6756 "ALU64_ARSH_X: Shift < 32, low word", 6757 .u.insns_int = { 6758 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6759 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6760 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6761 BPF_EXIT_INSN(), 6762 }, 6763 INTERNAL, 6764 { }, 6765 { { 0, 0x56789abc } } 6766 }, 6767 { 6768 "ALU64_ARSH_X: Shift < 32, high word", 6769 .u.insns_int = { 6770 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6771 BPF_ALU32_IMM(BPF_MOV, R1, 12), 6772 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6773 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6774 BPF_EXIT_INSN(), 6775 }, 6776 INTERNAL, 6777 { }, 6778 { { 0, 0xfff81234 } } 6779 }, 6780 { 6781 "ALU64_ARSH_X: Shift > 32, low word", 6782 .u.insns_int = { 6783 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6784 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6785 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6786 BPF_EXIT_INSN(), 6787 }, 6788 INTERNAL, 6789 { }, 6790 { { 0, 0xf8123456 } } 6791 }, 6792 { 6793 "ALU64_ARSH_X: Shift > 32, high word", 6794 .u.insns_int = { 6795 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6796 BPF_ALU32_IMM(BPF_MOV, R1, 36), 6797 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6798 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6799 BPF_EXIT_INSN(), 6800 }, 6801 INTERNAL, 6802 { }, 6803 { { 0, -1 } } 6804 }, 6805 { 6806 "ALU64_ARSH_X: Shift == 32, low word", 6807 .u.insns_int = { 6808 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6809 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6810 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6811 BPF_EXIT_INSN(), 6812 }, 6813 INTERNAL, 6814 { }, 6815 { { 0, 0x81234567 } } 6816 }, 6817 { 6818 "ALU64_ARSH_X: Shift == 32, high word", 6819 .u.insns_int = { 6820 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6821 BPF_ALU32_IMM(BPF_MOV, R1, 32), 6822 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6823 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6824 BPF_EXIT_INSN(), 6825 }, 6826 INTERNAL, 6827 { }, 6828 { { 0, -1 } } 6829 }, 6830 { 6831 "ALU64_ARSH_X: Zero shift, low word", 6832 .u.insns_int = { 6833 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6834 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6835 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6836 BPF_EXIT_INSN(), 6837 }, 6838 INTERNAL, 6839 { }, 6840 { { 0, 0x89abcdef } } 6841 }, 6842 { 6843 "ALU64_ARSH_X: Zero shift, high word", 6844 .u.insns_int = { 6845 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6846 BPF_ALU32_IMM(BPF_MOV, R1, 0), 6847 BPF_ALU64_REG(BPF_ARSH, R0, R1), 6848 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6849 BPF_EXIT_INSN(), 6850 }, 6851 INTERNAL, 6852 { }, 6853 { { 0, 0x81234567 } } 6854 }, 6855 /* BPF_ALU | BPF_ARSH | BPF_K */ 6856 { 6857 "ALU32_ARSH_K: -1234 >> 7 = -10", 6858 .u.insns_int = { 6859 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 6860 BPF_ALU32_IMM(BPF_ARSH, R0, 7), 6861 BPF_EXIT_INSN(), 6862 }, 6863 INTERNAL, 6864 { }, 6865 { { 0, -10 } } 6866 }, 6867 { 6868 "ALU32_ARSH_K: -1234 >> 0 = -1234", 6869 .u.insns_int = { 6870 BPF_ALU32_IMM(BPF_MOV, R0, -1234), 6871 BPF_ALU32_IMM(BPF_ARSH, R0, 0), 6872 BPF_EXIT_INSN(), 6873 }, 6874 INTERNAL, 6875 { }, 6876 { { 0, -1234 } } 6877 }, 6878 { 6879 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 6880 .u.insns_int = { 6881 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 6882 BPF_ALU64_IMM(BPF_ARSH, R0, 40), 6883 BPF_EXIT_INSN(), 6884 }, 6885 INTERNAL, 6886 { }, 6887 { { 0, 0xffff00ff } }, 6888 }, 6889 { 6890 "ALU64_ARSH_K: Shift < 32, low word", 6891 .u.insns_int = { 6892 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6893 BPF_ALU64_IMM(BPF_RSH, R0, 12), 6894 BPF_EXIT_INSN(), 6895 }, 6896 INTERNAL, 6897 { }, 6898 { { 0, 0x56789abc } } 6899 }, 6900 { 6901 "ALU64_ARSH_K: Shift < 32, high word", 6902 .u.insns_int = { 6903 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6904 BPF_ALU64_IMM(BPF_ARSH, R0, 12), 6905 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6906 BPF_EXIT_INSN(), 6907 }, 6908 INTERNAL, 6909 { }, 6910 { { 0, 0xfff81234 } } 6911 }, 6912 { 6913 "ALU64_ARSH_K: Shift > 32, low word", 6914 .u.insns_int = { 6915 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6916 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 6917 BPF_EXIT_INSN(), 6918 }, 6919 INTERNAL, 6920 { }, 6921 { { 0, 0xf8123456 } } 6922 }, 6923 { 6924 "ALU64_ARSH_K: Shift > 32, high word", 6925 .u.insns_int = { 6926 BPF_LD_IMM64(R0, 0xf123456789abcdefLL), 6927 BPF_ALU64_IMM(BPF_ARSH, R0, 36), 6928 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6929 BPF_EXIT_INSN(), 6930 }, 6931 INTERNAL, 6932 { }, 6933 { { 0, -1 } } 6934 }, 6935 { 6936 "ALU64_ARSH_K: Shift == 32, low word", 6937 .u.insns_int = { 6938 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6939 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 6940 BPF_EXIT_INSN(), 6941 }, 6942 INTERNAL, 6943 { }, 6944 { { 0, 0x81234567 } } 6945 }, 6946 { 6947 "ALU64_ARSH_K: Shift == 32, high word", 6948 .u.insns_int = { 6949 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6950 BPF_ALU64_IMM(BPF_ARSH, R0, 32), 6951 BPF_ALU64_IMM(BPF_RSH, R0, 32), 6952 BPF_EXIT_INSN(), 6953 }, 6954 INTERNAL, 6955 { }, 6956 { { 0, -1 } } 6957 }, 6958 { 6959 "ALU64_ARSH_K: Zero shift", 6960 .u.insns_int = { 6961 BPF_LD_IMM64(R0, 0x8123456789abcdefLL), 6962 BPF_ALU64_IMM(BPF_ARSH, R0, 0), 6963 BPF_EXIT_INSN(), 6964 }, 6965 INTERNAL, 6966 { }, 6967 { { 0, 0x89abcdef } } 6968 }, 6969 /* BPF_ALU | BPF_NEG */ 6970 { 6971 "ALU_NEG: -(3) = -3", 6972 .u.insns_int = { 6973 BPF_ALU32_IMM(BPF_MOV, R0, 3), 6974 BPF_ALU32_IMM(BPF_NEG, R0, 0), 6975 BPF_EXIT_INSN(), 6976 }, 6977 INTERNAL, 6978 { }, 6979 { { 0, -3 } }, 6980 }, 6981 { 6982 "ALU_NEG: -(-3) = 3", 6983 .u.insns_int = { 6984 BPF_ALU32_IMM(BPF_MOV, R0, -3), 6985 BPF_ALU32_IMM(BPF_NEG, R0, 0), 6986 BPF_EXIT_INSN(), 6987 }, 6988 INTERNAL, 6989 { }, 6990 { { 0, 3 } }, 6991 }, 6992 { 6993 "ALU64_NEG: -(3) = -3", 6994 .u.insns_int = { 6995 BPF_LD_IMM64(R0, 3), 6996 BPF_ALU64_IMM(BPF_NEG, R0, 0), 6997 BPF_EXIT_INSN(), 6998 }, 6999 INTERNAL, 7000 { }, 7001 { { 0, -3 } }, 7002 }, 7003 { 7004 "ALU64_NEG: -(-3) = 3", 7005 .u.insns_int = { 7006 BPF_LD_IMM64(R0, -3), 7007 BPF_ALU64_IMM(BPF_NEG, R0, 0), 7008 BPF_EXIT_INSN(), 7009 }, 7010 INTERNAL, 7011 { }, 7012 { { 0, 3 } }, 7013 }, 7014 /* BPF_ALU | BPF_END | BPF_FROM_BE */ 7015 { 7016 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef", 7017 .u.insns_int = { 7018 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7019 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 7020 BPF_EXIT_INSN(), 7021 }, 7022 INTERNAL, 7023 { }, 7024 { { 0, cpu_to_be16(0xcdef) } }, 7025 }, 7026 { 7027 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef", 7028 .u.insns_int = { 7029 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7030 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 7031 BPF_ALU64_REG(BPF_MOV, R1, R0), 7032 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7033 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7034 BPF_EXIT_INSN(), 7035 }, 7036 INTERNAL, 7037 { }, 7038 { { 0, cpu_to_be32(0x89abcdef) } }, 7039 }, 7040 { 7041 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef", 7042 .u.insns_int = { 7043 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7044 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7045 BPF_EXIT_INSN(), 7046 }, 7047 INTERNAL, 7048 { }, 7049 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } }, 7050 }, 7051 { 7052 "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567", 7053 .u.insns_int = { 7054 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7055 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7056 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7057 BPF_EXIT_INSN(), 7058 }, 7059 INTERNAL, 7060 { }, 7061 { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } }, 7062 }, 7063 /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */ 7064 { 7065 "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210", 7066 .u.insns_int = { 7067 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7068 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 7069 BPF_EXIT_INSN(), 7070 }, 7071 INTERNAL, 7072 { }, 7073 { { 0, cpu_to_be16(0x3210) } }, 7074 }, 7075 { 7076 "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210", 7077 .u.insns_int = { 7078 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7079 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 7080 BPF_ALU64_REG(BPF_MOV, R1, R0), 7081 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7082 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7083 BPF_EXIT_INSN(), 7084 }, 7085 INTERNAL, 7086 { }, 7087 { { 0, cpu_to_be32(0x76543210) } }, 7088 }, 7089 { 7090 "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210", 7091 .u.insns_int = { 7092 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7093 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7094 BPF_EXIT_INSN(), 7095 }, 7096 INTERNAL, 7097 { }, 7098 { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } }, 7099 }, 7100 { 7101 "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98", 7102 .u.insns_int = { 7103 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7104 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 7105 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7106 BPF_EXIT_INSN(), 7107 }, 7108 INTERNAL, 7109 { }, 7110 { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } }, 7111 }, 7112 /* BPF_ALU | BPF_END | BPF_FROM_LE */ 7113 { 7114 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd", 7115 .u.insns_int = { 7116 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7117 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 7118 BPF_EXIT_INSN(), 7119 }, 7120 INTERNAL, 7121 { }, 7122 { { 0, cpu_to_le16(0xcdef) } }, 7123 }, 7124 { 7125 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89", 7126 .u.insns_int = { 7127 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7128 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 7129 BPF_ALU64_REG(BPF_MOV, R1, R0), 7130 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7131 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7132 BPF_EXIT_INSN(), 7133 }, 7134 INTERNAL, 7135 { }, 7136 { { 0, cpu_to_le32(0x89abcdef) } }, 7137 }, 7138 { 7139 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301", 7140 .u.insns_int = { 7141 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7142 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7143 BPF_EXIT_INSN(), 7144 }, 7145 INTERNAL, 7146 { }, 7147 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } }, 7148 }, 7149 { 7150 "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89", 7151 .u.insns_int = { 7152 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 7153 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7154 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7155 BPF_EXIT_INSN(), 7156 }, 7157 INTERNAL, 7158 { }, 7159 { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } }, 7160 }, 7161 /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */ 7162 { 7163 "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032", 7164 .u.insns_int = { 7165 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7166 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 7167 BPF_EXIT_INSN(), 7168 }, 7169 INTERNAL, 7170 { }, 7171 { { 0, cpu_to_le16(0x3210) } }, 7172 }, 7173 { 7174 "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476", 7175 .u.insns_int = { 7176 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7177 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 7178 BPF_ALU64_REG(BPF_MOV, R1, R0), 7179 BPF_ALU64_IMM(BPF_RSH, R1, 32), 7180 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */ 7181 BPF_EXIT_INSN(), 7182 }, 7183 INTERNAL, 7184 { }, 7185 { { 0, cpu_to_le32(0x76543210) } }, 7186 }, 7187 { 7188 "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476", 7189 .u.insns_int = { 7190 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7191 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7192 BPF_EXIT_INSN(), 7193 }, 7194 INTERNAL, 7195 { }, 7196 { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } }, 7197 }, 7198 { 7199 "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe", 7200 .u.insns_int = { 7201 BPF_LD_IMM64(R0, 0xfedcba9876543210ULL), 7202 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 7203 BPF_ALU64_IMM(BPF_RSH, R0, 32), 7204 BPF_EXIT_INSN(), 7205 }, 7206 INTERNAL, 7207 { }, 7208 { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } }, 7209 }, 7210 /* BPF_LDX_MEM B/H/W/DW */ 7211 { 7212 "BPF_LDX_MEM | BPF_B", 7213 .u.insns_int = { 7214 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 7215 BPF_LD_IMM64(R2, 0x0000000000000008ULL), 7216 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7217 #ifdef __BIG_ENDIAN 7218 BPF_LDX_MEM(BPF_B, R0, R10, -1), 7219 #else 7220 BPF_LDX_MEM(BPF_B, R0, R10, -8), 7221 #endif 7222 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7223 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7224 BPF_EXIT_INSN(), 7225 }, 7226 INTERNAL, 7227 { }, 7228 { { 0, 0 } }, 7229 .stack_depth = 8, 7230 }, 7231 { 7232 "BPF_LDX_MEM | BPF_B, MSB set", 7233 .u.insns_int = { 7234 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 7235 BPF_LD_IMM64(R2, 0x0000000000000088ULL), 7236 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7237 #ifdef __BIG_ENDIAN 7238 BPF_LDX_MEM(BPF_B, R0, R10, -1), 7239 #else 7240 BPF_LDX_MEM(BPF_B, R0, R10, -8), 7241 #endif 7242 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7243 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7244 BPF_EXIT_INSN(), 7245 }, 7246 INTERNAL, 7247 { }, 7248 { { 0, 0 } }, 7249 .stack_depth = 8, 7250 }, 7251 { 7252 "BPF_LDX_MEM | BPF_H", 7253 .u.insns_int = { 7254 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 7255 BPF_LD_IMM64(R2, 0x0000000000000708ULL), 7256 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7257 #ifdef __BIG_ENDIAN 7258 BPF_LDX_MEM(BPF_H, R0, R10, -2), 7259 #else 7260 BPF_LDX_MEM(BPF_H, R0, R10, -8), 7261 #endif 7262 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7263 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7264 BPF_EXIT_INSN(), 7265 }, 7266 INTERNAL, 7267 { }, 7268 { { 0, 0 } }, 7269 .stack_depth = 8, 7270 }, 7271 { 7272 "BPF_LDX_MEM | BPF_H, MSB set", 7273 .u.insns_int = { 7274 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 7275 BPF_LD_IMM64(R2, 0x0000000000008788ULL), 7276 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7277 #ifdef __BIG_ENDIAN 7278 BPF_LDX_MEM(BPF_H, R0, R10, -2), 7279 #else 7280 BPF_LDX_MEM(BPF_H, R0, R10, -8), 7281 #endif 7282 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7283 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7284 BPF_EXIT_INSN(), 7285 }, 7286 INTERNAL, 7287 { }, 7288 { { 0, 0 } }, 7289 .stack_depth = 8, 7290 }, 7291 { 7292 "BPF_LDX_MEM | BPF_W", 7293 .u.insns_int = { 7294 BPF_LD_IMM64(R1, 0x0102030405060708ULL), 7295 BPF_LD_IMM64(R2, 0x0000000005060708ULL), 7296 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7297 #ifdef __BIG_ENDIAN 7298 BPF_LDX_MEM(BPF_W, R0, R10, -4), 7299 #else 7300 BPF_LDX_MEM(BPF_W, R0, R10, -8), 7301 #endif 7302 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7303 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7304 BPF_EXIT_INSN(), 7305 }, 7306 INTERNAL, 7307 { }, 7308 { { 0, 0 } }, 7309 .stack_depth = 8, 7310 }, 7311 { 7312 "BPF_LDX_MEM | BPF_W, MSB set", 7313 .u.insns_int = { 7314 BPF_LD_IMM64(R1, 0x8182838485868788ULL), 7315 BPF_LD_IMM64(R2, 0x0000000085868788ULL), 7316 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7317 #ifdef __BIG_ENDIAN 7318 BPF_LDX_MEM(BPF_W, R0, R10, -4), 7319 #else 7320 BPF_LDX_MEM(BPF_W, R0, R10, -8), 7321 #endif 7322 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7323 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7324 BPF_EXIT_INSN(), 7325 }, 7326 INTERNAL, 7327 { }, 7328 { { 0, 0 } }, 7329 .stack_depth = 8, 7330 }, 7331 /* BPF_STX_MEM B/H/W/DW */ 7332 { 7333 "BPF_STX_MEM | BPF_B", 7334 .u.insns_int = { 7335 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7336 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 7337 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL), 7338 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7339 #ifdef __BIG_ENDIAN 7340 BPF_STX_MEM(BPF_B, R10, R2, -1), 7341 #else 7342 BPF_STX_MEM(BPF_B, R10, R2, -8), 7343 #endif 7344 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7345 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7346 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7347 BPF_EXIT_INSN(), 7348 }, 7349 INTERNAL, 7350 { }, 7351 { { 0, 0 } }, 7352 .stack_depth = 8, 7353 }, 7354 { 7355 "BPF_STX_MEM | BPF_B, MSB set", 7356 .u.insns_int = { 7357 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7358 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 7359 BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL), 7360 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7361 #ifdef __BIG_ENDIAN 7362 BPF_STX_MEM(BPF_B, R10, R2, -1), 7363 #else 7364 BPF_STX_MEM(BPF_B, R10, R2, -8), 7365 #endif 7366 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7367 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7368 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7369 BPF_EXIT_INSN(), 7370 }, 7371 INTERNAL, 7372 { }, 7373 { { 0, 0 } }, 7374 .stack_depth = 8, 7375 }, 7376 { 7377 "BPF_STX_MEM | BPF_H", 7378 .u.insns_int = { 7379 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7380 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 7381 BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL), 7382 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7383 #ifdef __BIG_ENDIAN 7384 BPF_STX_MEM(BPF_H, R10, R2, -2), 7385 #else 7386 BPF_STX_MEM(BPF_H, R10, R2, -8), 7387 #endif 7388 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7389 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7390 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7391 BPF_EXIT_INSN(), 7392 }, 7393 INTERNAL, 7394 { }, 7395 { { 0, 0 } }, 7396 .stack_depth = 8, 7397 }, 7398 { 7399 "BPF_STX_MEM | BPF_H, MSB set", 7400 .u.insns_int = { 7401 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7402 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 7403 BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL), 7404 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7405 #ifdef __BIG_ENDIAN 7406 BPF_STX_MEM(BPF_H, R10, R2, -2), 7407 #else 7408 BPF_STX_MEM(BPF_H, R10, R2, -8), 7409 #endif 7410 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7411 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7412 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7413 BPF_EXIT_INSN(), 7414 }, 7415 INTERNAL, 7416 { }, 7417 { { 0, 0 } }, 7418 .stack_depth = 8, 7419 }, 7420 { 7421 "BPF_STX_MEM | BPF_W", 7422 .u.insns_int = { 7423 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7424 BPF_LD_IMM64(R2, 0x0102030405060708ULL), 7425 BPF_LD_IMM64(R3, 0x8090a0b005060708ULL), 7426 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7427 #ifdef __BIG_ENDIAN 7428 BPF_STX_MEM(BPF_W, R10, R2, -4), 7429 #else 7430 BPF_STX_MEM(BPF_W, R10, R2, -8), 7431 #endif 7432 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7433 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7434 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7435 BPF_EXIT_INSN(), 7436 }, 7437 INTERNAL, 7438 { }, 7439 { { 0, 0 } }, 7440 .stack_depth = 8, 7441 }, 7442 { 7443 "BPF_STX_MEM | BPF_W, MSB set", 7444 .u.insns_int = { 7445 BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL), 7446 BPF_LD_IMM64(R2, 0x8182838485868788ULL), 7447 BPF_LD_IMM64(R3, 0x8090a0b085868788ULL), 7448 BPF_STX_MEM(BPF_DW, R10, R1, -8), 7449 #ifdef __BIG_ENDIAN 7450 BPF_STX_MEM(BPF_W, R10, R2, -4), 7451 #else 7452 BPF_STX_MEM(BPF_W, R10, R2, -8), 7453 #endif 7454 BPF_LDX_MEM(BPF_DW, R0, R10, -8), 7455 BPF_JMP_REG(BPF_JNE, R0, R3, 1), 7456 BPF_ALU64_IMM(BPF_MOV, R0, 0), 7457 BPF_EXIT_INSN(), 7458 }, 7459 INTERNAL, 7460 { }, 7461 { { 0, 0 } }, 7462 .stack_depth = 8, 7463 }, 7464 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */ 7465 { 7466 "ST_MEM_B: Store/Load byte: max negative", 7467 .u.insns_int = { 7468 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7469 BPF_ST_MEM(BPF_B, R10, -40, 0xff), 7470 BPF_LDX_MEM(BPF_B, R0, R10, -40), 7471 BPF_EXIT_INSN(), 7472 }, 7473 INTERNAL, 7474 { }, 7475 { { 0, 0xff } }, 7476 .stack_depth = 40, 7477 }, 7478 { 7479 "ST_MEM_B: Store/Load byte: max positive", 7480 .u.insns_int = { 7481 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7482 BPF_ST_MEM(BPF_H, R10, -40, 0x7f), 7483 BPF_LDX_MEM(BPF_H, R0, R10, -40), 7484 BPF_EXIT_INSN(), 7485 }, 7486 INTERNAL, 7487 { }, 7488 { { 0, 0x7f } }, 7489 .stack_depth = 40, 7490 }, 7491 { 7492 "STX_MEM_B: Store/Load byte: max negative", 7493 .u.insns_int = { 7494 BPF_LD_IMM64(R0, 0), 7495 BPF_LD_IMM64(R1, 0xffLL), 7496 BPF_STX_MEM(BPF_B, R10, R1, -40), 7497 BPF_LDX_MEM(BPF_B, R0, R10, -40), 7498 BPF_EXIT_INSN(), 7499 }, 7500 INTERNAL, 7501 { }, 7502 { { 0, 0xff } }, 7503 .stack_depth = 40, 7504 }, 7505 { 7506 "ST_MEM_H: Store/Load half word: max negative", 7507 .u.insns_int = { 7508 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7509 BPF_ST_MEM(BPF_H, R10, -40, 0xffff), 7510 BPF_LDX_MEM(BPF_H, R0, R10, -40), 7511 BPF_EXIT_INSN(), 7512 }, 7513 INTERNAL, 7514 { }, 7515 { { 0, 0xffff } }, 7516 .stack_depth = 40, 7517 }, 7518 { 7519 "ST_MEM_H: Store/Load half word: max positive", 7520 .u.insns_int = { 7521 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7522 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff), 7523 BPF_LDX_MEM(BPF_H, R0, R10, -40), 7524 BPF_EXIT_INSN(), 7525 }, 7526 INTERNAL, 7527 { }, 7528 { { 0, 0x7fff } }, 7529 .stack_depth = 40, 7530 }, 7531 { 7532 "STX_MEM_H: Store/Load half word: max negative", 7533 .u.insns_int = { 7534 BPF_LD_IMM64(R0, 0), 7535 BPF_LD_IMM64(R1, 0xffffLL), 7536 BPF_STX_MEM(BPF_H, R10, R1, -40), 7537 BPF_LDX_MEM(BPF_H, R0, R10, -40), 7538 BPF_EXIT_INSN(), 7539 }, 7540 INTERNAL, 7541 { }, 7542 { { 0, 0xffff } }, 7543 .stack_depth = 40, 7544 }, 7545 { 7546 "ST_MEM_W: Store/Load word: max negative", 7547 .u.insns_int = { 7548 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7549 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff), 7550 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7551 BPF_EXIT_INSN(), 7552 }, 7553 INTERNAL, 7554 { }, 7555 { { 0, 0xffffffff } }, 7556 .stack_depth = 40, 7557 }, 7558 { 7559 "ST_MEM_W: Store/Load word: max positive", 7560 .u.insns_int = { 7561 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7562 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff), 7563 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7564 BPF_EXIT_INSN(), 7565 }, 7566 INTERNAL, 7567 { }, 7568 { { 0, 0x7fffffff } }, 7569 .stack_depth = 40, 7570 }, 7571 { 7572 "STX_MEM_W: Store/Load word: max negative", 7573 .u.insns_int = { 7574 BPF_LD_IMM64(R0, 0), 7575 BPF_LD_IMM64(R1, 0xffffffffLL), 7576 BPF_STX_MEM(BPF_W, R10, R1, -40), 7577 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7578 BPF_EXIT_INSN(), 7579 }, 7580 INTERNAL, 7581 { }, 7582 { { 0, 0xffffffff } }, 7583 .stack_depth = 40, 7584 }, 7585 { 7586 "ST_MEM_DW: Store/Load double word: max negative", 7587 .u.insns_int = { 7588 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7589 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 7590 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 7591 BPF_EXIT_INSN(), 7592 }, 7593 INTERNAL, 7594 { }, 7595 { { 0, 0xffffffff } }, 7596 .stack_depth = 40, 7597 }, 7598 { 7599 "ST_MEM_DW: Store/Load double word: max negative 2", 7600 .u.insns_int = { 7601 BPF_LD_IMM64(R2, 0xffff00000000ffffLL), 7602 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 7603 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 7604 BPF_LDX_MEM(BPF_DW, R2, R10, -40), 7605 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 7606 BPF_MOV32_IMM(R0, 2), 7607 BPF_EXIT_INSN(), 7608 BPF_MOV32_IMM(R0, 1), 7609 BPF_EXIT_INSN(), 7610 }, 7611 INTERNAL, 7612 { }, 7613 { { 0, 0x1 } }, 7614 .stack_depth = 40, 7615 }, 7616 { 7617 "ST_MEM_DW: Store/Load double word: max positive", 7618 .u.insns_int = { 7619 BPF_ALU32_IMM(BPF_MOV, R0, 1), 7620 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff), 7621 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 7622 BPF_EXIT_INSN(), 7623 }, 7624 INTERNAL, 7625 { }, 7626 { { 0, 0x7fffffff } }, 7627 .stack_depth = 40, 7628 }, 7629 { 7630 "STX_MEM_DW: Store/Load double word: max negative", 7631 .u.insns_int = { 7632 BPF_LD_IMM64(R0, 0), 7633 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 7634 BPF_STX_MEM(BPF_DW, R10, R1, -40), 7635 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 7636 BPF_EXIT_INSN(), 7637 }, 7638 INTERNAL, 7639 { }, 7640 { { 0, 0xffffffff } }, 7641 .stack_depth = 40, 7642 }, 7643 { 7644 "STX_MEM_DW: Store double word: first word in memory", 7645 .u.insns_int = { 7646 BPF_LD_IMM64(R0, 0), 7647 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 7648 BPF_STX_MEM(BPF_DW, R10, R1, -40), 7649 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7650 BPF_EXIT_INSN(), 7651 }, 7652 INTERNAL, 7653 { }, 7654 #ifdef __BIG_ENDIAN 7655 { { 0, 0x01234567 } }, 7656 #else 7657 { { 0, 0x89abcdef } }, 7658 #endif 7659 .stack_depth = 40, 7660 }, 7661 { 7662 "STX_MEM_DW: Store double word: second word in memory", 7663 .u.insns_int = { 7664 BPF_LD_IMM64(R0, 0), 7665 BPF_LD_IMM64(R1, 0x0123456789abcdefLL), 7666 BPF_STX_MEM(BPF_DW, R10, R1, -40), 7667 BPF_LDX_MEM(BPF_W, R0, R10, -36), 7668 BPF_EXIT_INSN(), 7669 }, 7670 INTERNAL, 7671 { }, 7672 #ifdef __BIG_ENDIAN 7673 { { 0, 0x89abcdef } }, 7674 #else 7675 { { 0, 0x01234567 } }, 7676 #endif 7677 .stack_depth = 40, 7678 }, 7679 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */ 7680 { 7681 "STX_XADD_W: X + 1 + 1 + 1 + ...", 7682 { }, 7683 INTERNAL, 7684 { }, 7685 { { 0, 4134 } }, 7686 .fill_helper = bpf_fill_stxw, 7687 }, 7688 { 7689 "STX_XADD_DW: X + 1 + 1 + 1 + ...", 7690 { }, 7691 INTERNAL, 7692 { }, 7693 { { 0, 4134 } }, 7694 .fill_helper = bpf_fill_stxdw, 7695 }, 7696 /* 7697 * Exhaustive tests of atomic operation variants. 7698 * Individual tests are expanded from template macros for all 7699 * combinations of ALU operation, word size and fetching. 7700 */ 7701 #define BPF_ATOMIC_POISON(width) ((width) == BPF_W ? (0xbaadf00dULL << 32) : 0) 7702 7703 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \ 7704 { \ 7705 "BPF_ATOMIC | " #width ", " #op ": Test: " \ 7706 #old " " #logic " " #update " = " #result, \ 7707 .u.insns_int = { \ 7708 BPF_LD_IMM64(R5, (update) | BPF_ATOMIC_POISON(width)), \ 7709 BPF_ST_MEM(width, R10, -40, old), \ 7710 BPF_ATOMIC_OP(width, op, R10, R5, -40), \ 7711 BPF_LDX_MEM(width, R0, R10, -40), \ 7712 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 7713 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 7714 BPF_ALU64_REG(BPF_OR, R0, R1), \ 7715 BPF_EXIT_INSN(), \ 7716 }, \ 7717 INTERNAL, \ 7718 { }, \ 7719 { { 0, result } }, \ 7720 .stack_depth = 40, \ 7721 } 7722 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \ 7723 { \ 7724 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \ 7725 #old " " #logic " " #update " = " #result, \ 7726 .u.insns_int = { \ 7727 BPF_ALU64_REG(BPF_MOV, R1, R10), \ 7728 BPF_LD_IMM64(R0, (update) | BPF_ATOMIC_POISON(width)), \ 7729 BPF_ST_MEM(BPF_W, R10, -40, old), \ 7730 BPF_ATOMIC_OP(width, op, R10, R0, -40), \ 7731 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 7732 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 7733 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 7734 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 7735 BPF_ALU64_REG(BPF_OR, R0, R1), \ 7736 BPF_EXIT_INSN(), \ 7737 }, \ 7738 INTERNAL, \ 7739 { }, \ 7740 { { 0, 0 } }, \ 7741 .stack_depth = 40, \ 7742 } 7743 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \ 7744 { \ 7745 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \ 7746 #old " " #logic " " #update " = " #result, \ 7747 .u.insns_int = { \ 7748 BPF_ALU64_REG(BPF_MOV, R0, R10), \ 7749 BPF_LD_IMM64(R1, (update) | BPF_ATOMIC_POISON(width)), \ 7750 BPF_ST_MEM(width, R10, -40, old), \ 7751 BPF_ATOMIC_OP(width, op, R10, R1, -40), \ 7752 BPF_ALU64_REG(BPF_SUB, R0, R10), \ 7753 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 7754 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 7755 BPF_ALU64_REG(BPF_OR, R0, R1), \ 7756 BPF_EXIT_INSN(), \ 7757 }, \ 7758 INTERNAL, \ 7759 { }, \ 7760 { { 0, 0 } }, \ 7761 .stack_depth = 40, \ 7762 } 7763 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \ 7764 { \ 7765 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \ 7766 #old " " #logic " " #update " = " #result, \ 7767 .u.insns_int = { \ 7768 BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)), \ 7769 BPF_ST_MEM(width, R10, -40, old), \ 7770 BPF_ATOMIC_OP(width, op, R10, R3, -40), \ 7771 BPF_ALU32_REG(BPF_MOV, R0, R3), \ 7772 BPF_EXIT_INSN(), \ 7773 }, \ 7774 INTERNAL, \ 7775 { }, \ 7776 { { 0, (op) & BPF_FETCH ? old : update } }, \ 7777 .stack_depth = 40, \ 7778 } 7779 /* BPF_ATOMIC | BPF_W: BPF_ADD */ 7780 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 7781 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 7782 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 7783 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd), 7784 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */ 7785 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7786 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7787 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7788 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7789 /* BPF_ATOMIC | BPF_DW: BPF_ADD */ 7790 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 7791 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 7792 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 7793 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd), 7794 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */ 7795 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7796 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7797 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7798 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd), 7799 /* BPF_ATOMIC | BPF_W: BPF_AND */ 7800 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 7801 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 7802 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 7803 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02), 7804 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */ 7805 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7806 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7807 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7808 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7809 /* BPF_ATOMIC | BPF_DW: BPF_AND */ 7810 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 7811 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 7812 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 7813 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02), 7814 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */ 7815 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7816 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7817 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7818 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02), 7819 /* BPF_ATOMIC | BPF_W: BPF_OR */ 7820 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 7821 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 7822 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 7823 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb), 7824 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */ 7825 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7826 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7827 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7828 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7829 /* BPF_ATOMIC | BPF_DW: BPF_OR */ 7830 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 7831 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 7832 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 7833 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb), 7834 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */ 7835 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7836 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7837 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7838 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb), 7839 /* BPF_ATOMIC | BPF_W: BPF_XOR */ 7840 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7841 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7842 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7843 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7844 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */ 7845 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7846 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7847 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7848 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7849 /* BPF_ATOMIC | BPF_DW: BPF_XOR */ 7850 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7851 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7852 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7853 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9), 7854 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */ 7855 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7856 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7857 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7858 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9), 7859 /* BPF_ATOMIC | BPF_W: BPF_XCHG */ 7860 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7861 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7862 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7863 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7864 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */ 7865 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7866 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7867 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7868 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab), 7869 #undef BPF_ATOMIC_POISON 7870 #undef BPF_ATOMIC_OP_TEST1 7871 #undef BPF_ATOMIC_OP_TEST2 7872 #undef BPF_ATOMIC_OP_TEST3 7873 #undef BPF_ATOMIC_OP_TEST4 7874 /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */ 7875 { 7876 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return", 7877 .u.insns_int = { 7878 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 7879 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 7880 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 7881 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7882 BPF_EXIT_INSN(), 7883 }, 7884 INTERNAL, 7885 { }, 7886 { { 0, 0x01234567 } }, 7887 .stack_depth = 40, 7888 }, 7889 { 7890 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store", 7891 .u.insns_int = { 7892 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 7893 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 7894 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 7895 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7896 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7897 BPF_EXIT_INSN(), 7898 }, 7899 INTERNAL, 7900 { }, 7901 { { 0, 0x89abcdef } }, 7902 .stack_depth = 40, 7903 }, 7904 { 7905 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return", 7906 .u.insns_int = { 7907 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 7908 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 7909 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 7910 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7911 BPF_EXIT_INSN(), 7912 }, 7913 INTERNAL, 7914 { }, 7915 { { 0, 0x01234567 } }, 7916 .stack_depth = 40, 7917 }, 7918 { 7919 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store", 7920 .u.insns_int = { 7921 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 7922 BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210), 7923 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 7924 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7925 BPF_LDX_MEM(BPF_W, R0, R10, -40), 7926 BPF_EXIT_INSN(), 7927 }, 7928 INTERNAL, 7929 { }, 7930 { { 0, 0x01234567 } }, 7931 .stack_depth = 40, 7932 }, 7933 { 7934 "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects", 7935 .u.insns_int = { 7936 BPF_ST_MEM(BPF_W, R10, -40, 0x01234567), 7937 BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567), 7938 BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef), 7939 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7940 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40), 7941 BPF_ALU32_REG(BPF_MOV, R0, R3), 7942 BPF_EXIT_INSN(), 7943 }, 7944 INTERNAL, 7945 { }, 7946 { { 0, 0x89abcdef } }, 7947 .stack_depth = 40, 7948 }, 7949 /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */ 7950 { 7951 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return", 7952 .u.insns_int = { 7953 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 7954 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 7955 BPF_ALU64_REG(BPF_MOV, R0, R1), 7956 BPF_STX_MEM(BPF_DW, R10, R1, -40), 7957 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 7958 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 7959 BPF_ALU64_REG(BPF_SUB, R0, R1), 7960 BPF_EXIT_INSN(), 7961 }, 7962 INTERNAL, 7963 { }, 7964 { { 0, 0 } }, 7965 .stack_depth = 40, 7966 }, 7967 { 7968 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store", 7969 .u.insns_int = { 7970 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 7971 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 7972 BPF_ALU64_REG(BPF_MOV, R0, R1), 7973 BPF_STX_MEM(BPF_DW, R10, R0, -40), 7974 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 7975 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 7976 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 7977 BPF_ALU64_REG(BPF_SUB, R0, R2), 7978 BPF_EXIT_INSN(), 7979 }, 7980 INTERNAL, 7981 { }, 7982 { { 0, 0 } }, 7983 .stack_depth = 40, 7984 }, 7985 { 7986 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return", 7987 .u.insns_int = { 7988 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 7989 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 7990 BPF_ALU64_REG(BPF_MOV, R0, R1), 7991 BPF_ALU64_IMM(BPF_ADD, R0, 1), 7992 BPF_STX_MEM(BPF_DW, R10, R1, -40), 7993 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 7994 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 7995 BPF_ALU64_REG(BPF_SUB, R0, R1), 7996 BPF_EXIT_INSN(), 7997 }, 7998 INTERNAL, 7999 { }, 8000 { { 0, 0 } }, 8001 .stack_depth = 40, 8002 }, 8003 { 8004 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store", 8005 .u.insns_int = { 8006 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 8007 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 8008 BPF_ALU64_REG(BPF_MOV, R0, R1), 8009 BPF_ALU64_IMM(BPF_ADD, R0, 1), 8010 BPF_STX_MEM(BPF_DW, R10, R1, -40), 8011 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 8012 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 8013 BPF_JMP_REG(BPF_JNE, R0, R1, 1), 8014 BPF_ALU64_REG(BPF_SUB, R0, R1), 8015 BPF_EXIT_INSN(), 8016 }, 8017 INTERNAL, 8018 { }, 8019 { { 0, 0 } }, 8020 .stack_depth = 40, 8021 }, 8022 { 8023 "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects", 8024 .u.insns_int = { 8025 BPF_LD_IMM64(R1, 0x0123456789abcdefULL), 8026 BPF_LD_IMM64(R2, 0xfecdba9876543210ULL), 8027 BPF_ALU64_REG(BPF_MOV, R0, R1), 8028 BPF_STX_MEM(BPF_DW, R10, R1, -40), 8029 BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40), 8030 BPF_LD_IMM64(R0, 0xfecdba9876543210ULL), 8031 BPF_JMP_REG(BPF_JNE, R0, R2, 1), 8032 BPF_ALU64_REG(BPF_SUB, R0, R2), 8033 BPF_EXIT_INSN(), 8034 }, 8035 INTERNAL, 8036 { }, 8037 { { 0, 0 } }, 8038 .stack_depth = 40, 8039 }, 8040 /* BPF_JMP32 | BPF_JEQ | BPF_K */ 8041 { 8042 "JMP32_JEQ_K: Small immediate", 8043 .u.insns_int = { 8044 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8045 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1), 8046 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 8047 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8048 BPF_EXIT_INSN(), 8049 }, 8050 INTERNAL, 8051 { }, 8052 { { 0, 123 } } 8053 }, 8054 { 8055 "JMP32_JEQ_K: Large immediate", 8056 .u.insns_int = { 8057 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 8058 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1), 8059 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1), 8060 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8061 BPF_EXIT_INSN(), 8062 }, 8063 INTERNAL, 8064 { }, 8065 { { 0, 12345678 } } 8066 }, 8067 { 8068 "JMP32_JEQ_K: negative immediate", 8069 .u.insns_int = { 8070 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8071 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1), 8072 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1), 8073 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8074 BPF_EXIT_INSN(), 8075 }, 8076 INTERNAL, 8077 { }, 8078 { { 0, -123 } } 8079 }, 8080 /* BPF_JMP32 | BPF_JEQ | BPF_X */ 8081 { 8082 "JMP32_JEQ_X", 8083 .u.insns_int = { 8084 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 8085 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 8086 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2), 8087 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 8088 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1), 8089 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8090 BPF_EXIT_INSN(), 8091 }, 8092 INTERNAL, 8093 { }, 8094 { { 0, 1234 } } 8095 }, 8096 /* BPF_JMP32 | BPF_JNE | BPF_K */ 8097 { 8098 "JMP32_JNE_K: Small immediate", 8099 .u.insns_int = { 8100 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8101 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 8102 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1), 8103 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8104 BPF_EXIT_INSN(), 8105 }, 8106 INTERNAL, 8107 { }, 8108 { { 0, 123 } } 8109 }, 8110 { 8111 "JMP32_JNE_K: Large immediate", 8112 .u.insns_int = { 8113 BPF_ALU32_IMM(BPF_MOV, R0, 12345678), 8114 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1), 8115 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1), 8116 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8117 BPF_EXIT_INSN(), 8118 }, 8119 INTERNAL, 8120 { }, 8121 { { 0, 12345678 } } 8122 }, 8123 { 8124 "JMP32_JNE_K: negative immediate", 8125 .u.insns_int = { 8126 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8127 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1), 8128 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1), 8129 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8130 BPF_EXIT_INSN(), 8131 }, 8132 INTERNAL, 8133 { }, 8134 { { 0, -123 } } 8135 }, 8136 /* BPF_JMP32 | BPF_JNE | BPF_X */ 8137 { 8138 "JMP32_JNE_X", 8139 .u.insns_int = { 8140 BPF_ALU32_IMM(BPF_MOV, R0, 1234), 8141 BPF_ALU32_IMM(BPF_MOV, R1, 1234), 8142 BPF_JMP32_REG(BPF_JNE, R0, R1, 2), 8143 BPF_ALU32_IMM(BPF_MOV, R1, 4321), 8144 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 8145 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8146 BPF_EXIT_INSN(), 8147 }, 8148 INTERNAL, 8149 { }, 8150 { { 0, 1234 } } 8151 }, 8152 /* BPF_JMP32 | BPF_JSET | BPF_K */ 8153 { 8154 "JMP32_JSET_K: Small immediate", 8155 .u.insns_int = { 8156 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8157 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1), 8158 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1), 8159 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8160 BPF_EXIT_INSN(), 8161 }, 8162 INTERNAL, 8163 { }, 8164 { { 0, 1 } } 8165 }, 8166 { 8167 "JMP32_JSET_K: Large immediate", 8168 .u.insns_int = { 8169 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000), 8170 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1), 8171 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1), 8172 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8173 BPF_EXIT_INSN(), 8174 }, 8175 INTERNAL, 8176 { }, 8177 { { 0, 0x40000000 } } 8178 }, 8179 { 8180 "JMP32_JSET_K: negative immediate", 8181 .u.insns_int = { 8182 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8183 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1), 8184 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8185 BPF_EXIT_INSN(), 8186 }, 8187 INTERNAL, 8188 { }, 8189 { { 0, -123 } } 8190 }, 8191 /* BPF_JMP32 | BPF_JSET | BPF_X */ 8192 { 8193 "JMP32_JSET_X", 8194 .u.insns_int = { 8195 BPF_ALU32_IMM(BPF_MOV, R0, 8), 8196 BPF_ALU32_IMM(BPF_MOV, R1, 7), 8197 BPF_JMP32_REG(BPF_JSET, R0, R1, 2), 8198 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2), 8199 BPF_JMP32_REG(BPF_JNE, R0, R1, 1), 8200 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8201 BPF_EXIT_INSN(), 8202 }, 8203 INTERNAL, 8204 { }, 8205 { { 0, 8 } } 8206 }, 8207 /* BPF_JMP32 | BPF_JGT | BPF_K */ 8208 { 8209 "JMP32_JGT_K: Small immediate", 8210 .u.insns_int = { 8211 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8212 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1), 8213 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1), 8214 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8215 BPF_EXIT_INSN(), 8216 }, 8217 INTERNAL, 8218 { }, 8219 { { 0, 123 } } 8220 }, 8221 { 8222 "JMP32_JGT_K: Large immediate", 8223 .u.insns_int = { 8224 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8225 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1), 8226 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1), 8227 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8228 BPF_EXIT_INSN(), 8229 }, 8230 INTERNAL, 8231 { }, 8232 { { 0, 0xfffffffe } } 8233 }, 8234 /* BPF_JMP32 | BPF_JGT | BPF_X */ 8235 { 8236 "JMP32_JGT_X", 8237 .u.insns_int = { 8238 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8239 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 8240 BPF_JMP32_REG(BPF_JGT, R0, R1, 2), 8241 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 8242 BPF_JMP32_REG(BPF_JGT, R0, R1, 1), 8243 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8244 BPF_EXIT_INSN(), 8245 }, 8246 INTERNAL, 8247 { }, 8248 { { 0, 0xfffffffe } } 8249 }, 8250 /* BPF_JMP32 | BPF_JGE | BPF_K */ 8251 { 8252 "JMP32_JGE_K: Small immediate", 8253 .u.insns_int = { 8254 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8255 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1), 8256 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1), 8257 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8258 BPF_EXIT_INSN(), 8259 }, 8260 INTERNAL, 8261 { }, 8262 { { 0, 123 } } 8263 }, 8264 { 8265 "JMP32_JGE_K: Large immediate", 8266 .u.insns_int = { 8267 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8268 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1), 8269 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1), 8270 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8271 BPF_EXIT_INSN(), 8272 }, 8273 INTERNAL, 8274 { }, 8275 { { 0, 0xfffffffe } } 8276 }, 8277 /* BPF_JMP32 | BPF_JGE | BPF_X */ 8278 { 8279 "JMP32_JGE_X", 8280 .u.insns_int = { 8281 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8282 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 8283 BPF_JMP32_REG(BPF_JGE, R0, R1, 2), 8284 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 8285 BPF_JMP32_REG(BPF_JGE, R0, R1, 1), 8286 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8287 BPF_EXIT_INSN(), 8288 }, 8289 INTERNAL, 8290 { }, 8291 { { 0, 0xfffffffe } } 8292 }, 8293 /* BPF_JMP32 | BPF_JLT | BPF_K */ 8294 { 8295 "JMP32_JLT_K: Small immediate", 8296 .u.insns_int = { 8297 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8298 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1), 8299 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1), 8300 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8301 BPF_EXIT_INSN(), 8302 }, 8303 INTERNAL, 8304 { }, 8305 { { 0, 123 } } 8306 }, 8307 { 8308 "JMP32_JLT_K: Large immediate", 8309 .u.insns_int = { 8310 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8311 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1), 8312 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1), 8313 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8314 BPF_EXIT_INSN(), 8315 }, 8316 INTERNAL, 8317 { }, 8318 { { 0, 0xfffffffe } } 8319 }, 8320 /* BPF_JMP32 | BPF_JLT | BPF_X */ 8321 { 8322 "JMP32_JLT_X", 8323 .u.insns_int = { 8324 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8325 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 8326 BPF_JMP32_REG(BPF_JLT, R0, R1, 2), 8327 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 8328 BPF_JMP32_REG(BPF_JLT, R0, R1, 1), 8329 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8330 BPF_EXIT_INSN(), 8331 }, 8332 INTERNAL, 8333 { }, 8334 { { 0, 0xfffffffe } } 8335 }, 8336 /* BPF_JMP32 | BPF_JLE | BPF_K */ 8337 { 8338 "JMP32_JLE_K: Small immediate", 8339 .u.insns_int = { 8340 BPF_ALU32_IMM(BPF_MOV, R0, 123), 8341 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1), 8342 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1), 8343 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8344 BPF_EXIT_INSN(), 8345 }, 8346 INTERNAL, 8347 { }, 8348 { { 0, 123 } } 8349 }, 8350 { 8351 "JMP32_JLE_K: Large immediate", 8352 .u.insns_int = { 8353 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8354 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1), 8355 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1), 8356 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8357 BPF_EXIT_INSN(), 8358 }, 8359 INTERNAL, 8360 { }, 8361 { { 0, 0xfffffffe } } 8362 }, 8363 /* BPF_JMP32 | BPF_JLE | BPF_X */ 8364 { 8365 "JMP32_JLE_X", 8366 .u.insns_int = { 8367 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe), 8368 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd), 8369 BPF_JMP32_REG(BPF_JLE, R0, R1, 2), 8370 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe), 8371 BPF_JMP32_REG(BPF_JLE, R0, R1, 1), 8372 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8373 BPF_EXIT_INSN(), 8374 }, 8375 INTERNAL, 8376 { }, 8377 { { 0, 0xfffffffe } } 8378 }, 8379 /* BPF_JMP32 | BPF_JSGT | BPF_K */ 8380 { 8381 "JMP32_JSGT_K: Small immediate", 8382 .u.insns_int = { 8383 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8384 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1), 8385 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1), 8386 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8387 BPF_EXIT_INSN(), 8388 }, 8389 INTERNAL, 8390 { }, 8391 { { 0, -123 } } 8392 }, 8393 { 8394 "JMP32_JSGT_K: Large immediate", 8395 .u.insns_int = { 8396 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8397 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1), 8398 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1), 8399 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8400 BPF_EXIT_INSN(), 8401 }, 8402 INTERNAL, 8403 { }, 8404 { { 0, -12345678 } } 8405 }, 8406 /* BPF_JMP32 | BPF_JSGT | BPF_X */ 8407 { 8408 "JMP32_JSGT_X", 8409 .u.insns_int = { 8410 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8411 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 8412 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2), 8413 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 8414 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1), 8415 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8416 BPF_EXIT_INSN(), 8417 }, 8418 INTERNAL, 8419 { }, 8420 { { 0, -12345678 } } 8421 }, 8422 /* BPF_JMP32 | BPF_JSGE | BPF_K */ 8423 { 8424 "JMP32_JSGE_K: Small immediate", 8425 .u.insns_int = { 8426 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8427 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1), 8428 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1), 8429 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8430 BPF_EXIT_INSN(), 8431 }, 8432 INTERNAL, 8433 { }, 8434 { { 0, -123 } } 8435 }, 8436 { 8437 "JMP32_JSGE_K: Large immediate", 8438 .u.insns_int = { 8439 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8440 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1), 8441 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1), 8442 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8443 BPF_EXIT_INSN(), 8444 }, 8445 INTERNAL, 8446 { }, 8447 { { 0, -12345678 } } 8448 }, 8449 /* BPF_JMP32 | BPF_JSGE | BPF_X */ 8450 { 8451 "JMP32_JSGE_X", 8452 .u.insns_int = { 8453 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8454 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 8455 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2), 8456 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 8457 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1), 8458 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8459 BPF_EXIT_INSN(), 8460 }, 8461 INTERNAL, 8462 { }, 8463 { { 0, -12345678 } } 8464 }, 8465 /* BPF_JMP32 | BPF_JSLT | BPF_K */ 8466 { 8467 "JMP32_JSLT_K: Small immediate", 8468 .u.insns_int = { 8469 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8470 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1), 8471 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1), 8472 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8473 BPF_EXIT_INSN(), 8474 }, 8475 INTERNAL, 8476 { }, 8477 { { 0, -123 } } 8478 }, 8479 { 8480 "JMP32_JSLT_K: Large immediate", 8481 .u.insns_int = { 8482 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8483 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1), 8484 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1), 8485 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8486 BPF_EXIT_INSN(), 8487 }, 8488 INTERNAL, 8489 { }, 8490 { { 0, -12345678 } } 8491 }, 8492 /* BPF_JMP32 | BPF_JSLT | BPF_X */ 8493 { 8494 "JMP32_JSLT_X", 8495 .u.insns_int = { 8496 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8497 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 8498 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2), 8499 BPF_ALU32_IMM(BPF_MOV, R1, -12345677), 8500 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1), 8501 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8502 BPF_EXIT_INSN(), 8503 }, 8504 INTERNAL, 8505 { }, 8506 { { 0, -12345678 } } 8507 }, 8508 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 8509 { 8510 "JMP32_JSLE_K: Small immediate", 8511 .u.insns_int = { 8512 BPF_ALU32_IMM(BPF_MOV, R0, -123), 8513 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1), 8514 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1), 8515 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8516 BPF_EXIT_INSN(), 8517 }, 8518 INTERNAL, 8519 { }, 8520 { { 0, -123 } } 8521 }, 8522 { 8523 "JMP32_JSLE_K: Large immediate", 8524 .u.insns_int = { 8525 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8526 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1), 8527 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1), 8528 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8529 BPF_EXIT_INSN(), 8530 }, 8531 INTERNAL, 8532 { }, 8533 { { 0, -12345678 } } 8534 }, 8535 /* BPF_JMP32 | BPF_JSLE | BPF_K */ 8536 { 8537 "JMP32_JSLE_X", 8538 .u.insns_int = { 8539 BPF_ALU32_IMM(BPF_MOV, R0, -12345678), 8540 BPF_ALU32_IMM(BPF_MOV, R1, -12345679), 8541 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2), 8542 BPF_ALU32_IMM(BPF_MOV, R1, -12345678), 8543 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1), 8544 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8545 BPF_EXIT_INSN(), 8546 }, 8547 INTERNAL, 8548 { }, 8549 { { 0, -12345678 } } 8550 }, 8551 /* BPF_JMP | BPF_EXIT */ 8552 { 8553 "JMP_EXIT", 8554 .u.insns_int = { 8555 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711), 8556 BPF_EXIT_INSN(), 8557 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712), 8558 }, 8559 INTERNAL, 8560 { }, 8561 { { 0, 0x4711 } }, 8562 }, 8563 /* BPF_JMP | BPF_JA */ 8564 { 8565 "JMP_JA: Unconditional jump: if (true) return 1", 8566 .u.insns_int = { 8567 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8568 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 8569 BPF_EXIT_INSN(), 8570 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8571 BPF_EXIT_INSN(), 8572 }, 8573 INTERNAL, 8574 { }, 8575 { { 0, 1 } }, 8576 }, 8577 /* BPF_JMP | BPF_JSLT | BPF_K */ 8578 { 8579 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1", 8580 .u.insns_int = { 8581 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8582 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 8583 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 8584 BPF_EXIT_INSN(), 8585 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8586 BPF_EXIT_INSN(), 8587 }, 8588 INTERNAL, 8589 { }, 8590 { { 0, 1 } }, 8591 }, 8592 { 8593 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0", 8594 .u.insns_int = { 8595 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8596 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8597 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1), 8598 BPF_EXIT_INSN(), 8599 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8600 BPF_EXIT_INSN(), 8601 }, 8602 INTERNAL, 8603 { }, 8604 { { 0, 1 } }, 8605 }, 8606 /* BPF_JMP | BPF_JSGT | BPF_K */ 8607 { 8608 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1", 8609 .u.insns_int = { 8610 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8611 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8612 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1), 8613 BPF_EXIT_INSN(), 8614 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8615 BPF_EXIT_INSN(), 8616 }, 8617 INTERNAL, 8618 { }, 8619 { { 0, 1 } }, 8620 }, 8621 { 8622 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0", 8623 .u.insns_int = { 8624 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8625 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8626 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1), 8627 BPF_EXIT_INSN(), 8628 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8629 BPF_EXIT_INSN(), 8630 }, 8631 INTERNAL, 8632 { }, 8633 { { 0, 1 } }, 8634 }, 8635 /* BPF_JMP | BPF_JSLE | BPF_K */ 8636 { 8637 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1", 8638 .u.insns_int = { 8639 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8640 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL), 8641 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 8642 BPF_EXIT_INSN(), 8643 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8644 BPF_EXIT_INSN(), 8645 }, 8646 INTERNAL, 8647 { }, 8648 { { 0, 1 } }, 8649 }, 8650 { 8651 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1", 8652 .u.insns_int = { 8653 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8654 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8655 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1), 8656 BPF_EXIT_INSN(), 8657 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8658 BPF_EXIT_INSN(), 8659 }, 8660 INTERNAL, 8661 { }, 8662 { { 0, 1 } }, 8663 }, 8664 { 8665 "JMP_JSLE_K: Signed jump: value walk 1", 8666 .u.insns_int = { 8667 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8668 BPF_LD_IMM64(R1, 3), 8669 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6), 8670 BPF_ALU64_IMM(BPF_SUB, R1, 1), 8671 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 8672 BPF_ALU64_IMM(BPF_SUB, R1, 1), 8673 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 8674 BPF_ALU64_IMM(BPF_SUB, R1, 1), 8675 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 8676 BPF_EXIT_INSN(), /* bad exit */ 8677 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 8678 BPF_EXIT_INSN(), 8679 }, 8680 INTERNAL, 8681 { }, 8682 { { 0, 1 } }, 8683 }, 8684 { 8685 "JMP_JSLE_K: Signed jump: value walk 2", 8686 .u.insns_int = { 8687 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8688 BPF_LD_IMM64(R1, 3), 8689 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4), 8690 BPF_ALU64_IMM(BPF_SUB, R1, 2), 8691 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2), 8692 BPF_ALU64_IMM(BPF_SUB, R1, 2), 8693 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1), 8694 BPF_EXIT_INSN(), /* bad exit */ 8695 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 8696 BPF_EXIT_INSN(), 8697 }, 8698 INTERNAL, 8699 { }, 8700 { { 0, 1 } }, 8701 }, 8702 /* BPF_JMP | BPF_JSGE | BPF_K */ 8703 { 8704 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1", 8705 .u.insns_int = { 8706 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8707 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8708 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1), 8709 BPF_EXIT_INSN(), 8710 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8711 BPF_EXIT_INSN(), 8712 }, 8713 INTERNAL, 8714 { }, 8715 { { 0, 1 } }, 8716 }, 8717 { 8718 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1", 8719 .u.insns_int = { 8720 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8721 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 8722 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1), 8723 BPF_EXIT_INSN(), 8724 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8725 BPF_EXIT_INSN(), 8726 }, 8727 INTERNAL, 8728 { }, 8729 { { 0, 1 } }, 8730 }, 8731 { 8732 "JMP_JSGE_K: Signed jump: value walk 1", 8733 .u.insns_int = { 8734 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8735 BPF_LD_IMM64(R1, -3), 8736 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6), 8737 BPF_ALU64_IMM(BPF_ADD, R1, 1), 8738 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 8739 BPF_ALU64_IMM(BPF_ADD, R1, 1), 8740 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 8741 BPF_ALU64_IMM(BPF_ADD, R1, 1), 8742 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 8743 BPF_EXIT_INSN(), /* bad exit */ 8744 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 8745 BPF_EXIT_INSN(), 8746 }, 8747 INTERNAL, 8748 { }, 8749 { { 0, 1 } }, 8750 }, 8751 { 8752 "JMP_JSGE_K: Signed jump: value walk 2", 8753 .u.insns_int = { 8754 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8755 BPF_LD_IMM64(R1, -3), 8756 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4), 8757 BPF_ALU64_IMM(BPF_ADD, R1, 2), 8758 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2), 8759 BPF_ALU64_IMM(BPF_ADD, R1, 2), 8760 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1), 8761 BPF_EXIT_INSN(), /* bad exit */ 8762 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */ 8763 BPF_EXIT_INSN(), 8764 }, 8765 INTERNAL, 8766 { }, 8767 { { 0, 1 } }, 8768 }, 8769 /* BPF_JMP | BPF_JGT | BPF_K */ 8770 { 8771 "JMP_JGT_K: if (3 > 2) return 1", 8772 .u.insns_int = { 8773 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8774 BPF_LD_IMM64(R1, 3), 8775 BPF_JMP_IMM(BPF_JGT, R1, 2, 1), 8776 BPF_EXIT_INSN(), 8777 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8778 BPF_EXIT_INSN(), 8779 }, 8780 INTERNAL, 8781 { }, 8782 { { 0, 1 } }, 8783 }, 8784 { 8785 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1", 8786 .u.insns_int = { 8787 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8788 BPF_LD_IMM64(R1, -1), 8789 BPF_JMP_IMM(BPF_JGT, R1, 1, 1), 8790 BPF_EXIT_INSN(), 8791 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8792 BPF_EXIT_INSN(), 8793 }, 8794 INTERNAL, 8795 { }, 8796 { { 0, 1 } }, 8797 }, 8798 /* BPF_JMP | BPF_JLT | BPF_K */ 8799 { 8800 "JMP_JLT_K: if (2 < 3) return 1", 8801 .u.insns_int = { 8802 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8803 BPF_LD_IMM64(R1, 2), 8804 BPF_JMP_IMM(BPF_JLT, R1, 3, 1), 8805 BPF_EXIT_INSN(), 8806 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8807 BPF_EXIT_INSN(), 8808 }, 8809 INTERNAL, 8810 { }, 8811 { { 0, 1 } }, 8812 }, 8813 { 8814 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1", 8815 .u.insns_int = { 8816 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8817 BPF_LD_IMM64(R1, 1), 8818 BPF_JMP_IMM(BPF_JLT, R1, -1, 1), 8819 BPF_EXIT_INSN(), 8820 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8821 BPF_EXIT_INSN(), 8822 }, 8823 INTERNAL, 8824 { }, 8825 { { 0, 1 } }, 8826 }, 8827 /* BPF_JMP | BPF_JGE | BPF_K */ 8828 { 8829 "JMP_JGE_K: if (3 >= 2) return 1", 8830 .u.insns_int = { 8831 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8832 BPF_LD_IMM64(R1, 3), 8833 BPF_JMP_IMM(BPF_JGE, R1, 2, 1), 8834 BPF_EXIT_INSN(), 8835 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8836 BPF_EXIT_INSN(), 8837 }, 8838 INTERNAL, 8839 { }, 8840 { { 0, 1 } }, 8841 }, 8842 /* BPF_JMP | BPF_JLE | BPF_K */ 8843 { 8844 "JMP_JLE_K: if (2 <= 3) return 1", 8845 .u.insns_int = { 8846 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8847 BPF_LD_IMM64(R1, 2), 8848 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 8849 BPF_EXIT_INSN(), 8850 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8851 BPF_EXIT_INSN(), 8852 }, 8853 INTERNAL, 8854 { }, 8855 { { 0, 1 } }, 8856 }, 8857 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */ 8858 { 8859 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)", 8860 .u.insns_int = { 8861 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 8862 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 8863 BPF_EXIT_INSN(), 8864 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 8865 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */ 8866 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */ 8867 BPF_EXIT_INSN(), 8868 }, 8869 INTERNAL, 8870 { }, 8871 { { 0, 1 } }, 8872 }, 8873 { 8874 "JMP_JGE_K: if (3 >= 3) return 1", 8875 .u.insns_int = { 8876 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8877 BPF_LD_IMM64(R1, 3), 8878 BPF_JMP_IMM(BPF_JGE, R1, 3, 1), 8879 BPF_EXIT_INSN(), 8880 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8881 BPF_EXIT_INSN(), 8882 }, 8883 INTERNAL, 8884 { }, 8885 { { 0, 1 } }, 8886 }, 8887 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */ 8888 { 8889 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)", 8890 .u.insns_int = { 8891 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */ 8892 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */ 8893 BPF_EXIT_INSN(), 8894 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */ 8895 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */ 8896 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */ 8897 BPF_EXIT_INSN(), 8898 }, 8899 INTERNAL, 8900 { }, 8901 { { 0, 1 } }, 8902 }, 8903 { 8904 "JMP_JLE_K: if (3 <= 3) return 1", 8905 .u.insns_int = { 8906 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8907 BPF_LD_IMM64(R1, 3), 8908 BPF_JMP_IMM(BPF_JLE, R1, 3, 1), 8909 BPF_EXIT_INSN(), 8910 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8911 BPF_EXIT_INSN(), 8912 }, 8913 INTERNAL, 8914 { }, 8915 { { 0, 1 } }, 8916 }, 8917 /* BPF_JMP | BPF_JNE | BPF_K */ 8918 { 8919 "JMP_JNE_K: if (3 != 2) return 1", 8920 .u.insns_int = { 8921 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8922 BPF_LD_IMM64(R1, 3), 8923 BPF_JMP_IMM(BPF_JNE, R1, 2, 1), 8924 BPF_EXIT_INSN(), 8925 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8926 BPF_EXIT_INSN(), 8927 }, 8928 INTERNAL, 8929 { }, 8930 { { 0, 1 } }, 8931 }, 8932 /* BPF_JMP | BPF_JEQ | BPF_K */ 8933 { 8934 "JMP_JEQ_K: if (3 == 3) return 1", 8935 .u.insns_int = { 8936 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8937 BPF_LD_IMM64(R1, 3), 8938 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1), 8939 BPF_EXIT_INSN(), 8940 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8941 BPF_EXIT_INSN(), 8942 }, 8943 INTERNAL, 8944 { }, 8945 { { 0, 1 } }, 8946 }, 8947 /* BPF_JMP | BPF_JSET | BPF_K */ 8948 { 8949 "JMP_JSET_K: if (0x3 & 0x2) return 1", 8950 .u.insns_int = { 8951 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8952 BPF_LD_IMM64(R1, 3), 8953 BPF_JMP_IMM(BPF_JSET, R1, 2, 1), 8954 BPF_EXIT_INSN(), 8955 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8956 BPF_EXIT_INSN(), 8957 }, 8958 INTERNAL, 8959 { }, 8960 { { 0, 1 } }, 8961 }, 8962 { 8963 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1", 8964 .u.insns_int = { 8965 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8966 BPF_LD_IMM64(R1, 3), 8967 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1), 8968 BPF_EXIT_INSN(), 8969 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8970 BPF_EXIT_INSN(), 8971 }, 8972 INTERNAL, 8973 { }, 8974 { { 0, 1 } }, 8975 }, 8976 /* BPF_JMP | BPF_JSGT | BPF_X */ 8977 { 8978 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1", 8979 .u.insns_int = { 8980 BPF_ALU32_IMM(BPF_MOV, R0, 0), 8981 BPF_LD_IMM64(R1, -1), 8982 BPF_LD_IMM64(R2, -2), 8983 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 8984 BPF_EXIT_INSN(), 8985 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8986 BPF_EXIT_INSN(), 8987 }, 8988 INTERNAL, 8989 { }, 8990 { { 0, 1 } }, 8991 }, 8992 { 8993 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0", 8994 .u.insns_int = { 8995 BPF_ALU32_IMM(BPF_MOV, R0, 1), 8996 BPF_LD_IMM64(R1, -1), 8997 BPF_LD_IMM64(R2, -1), 8998 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 8999 BPF_EXIT_INSN(), 9000 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9001 BPF_EXIT_INSN(), 9002 }, 9003 INTERNAL, 9004 { }, 9005 { { 0, 1 } }, 9006 }, 9007 /* BPF_JMP | BPF_JSLT | BPF_X */ 9008 { 9009 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1", 9010 .u.insns_int = { 9011 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9012 BPF_LD_IMM64(R1, -1), 9013 BPF_LD_IMM64(R2, -2), 9014 BPF_JMP_REG(BPF_JSLT, R2, R1, 1), 9015 BPF_EXIT_INSN(), 9016 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9017 BPF_EXIT_INSN(), 9018 }, 9019 INTERNAL, 9020 { }, 9021 { { 0, 1 } }, 9022 }, 9023 { 9024 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0", 9025 .u.insns_int = { 9026 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9027 BPF_LD_IMM64(R1, -1), 9028 BPF_LD_IMM64(R2, -1), 9029 BPF_JMP_REG(BPF_JSLT, R1, R2, 1), 9030 BPF_EXIT_INSN(), 9031 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9032 BPF_EXIT_INSN(), 9033 }, 9034 INTERNAL, 9035 { }, 9036 { { 0, 1 } }, 9037 }, 9038 /* BPF_JMP | BPF_JSGE | BPF_X */ 9039 { 9040 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1", 9041 .u.insns_int = { 9042 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9043 BPF_LD_IMM64(R1, -1), 9044 BPF_LD_IMM64(R2, -2), 9045 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 9046 BPF_EXIT_INSN(), 9047 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9048 BPF_EXIT_INSN(), 9049 }, 9050 INTERNAL, 9051 { }, 9052 { { 0, 1 } }, 9053 }, 9054 { 9055 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1", 9056 .u.insns_int = { 9057 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9058 BPF_LD_IMM64(R1, -1), 9059 BPF_LD_IMM64(R2, -1), 9060 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 9061 BPF_EXIT_INSN(), 9062 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9063 BPF_EXIT_INSN(), 9064 }, 9065 INTERNAL, 9066 { }, 9067 { { 0, 1 } }, 9068 }, 9069 /* BPF_JMP | BPF_JSLE | BPF_X */ 9070 { 9071 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1", 9072 .u.insns_int = { 9073 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9074 BPF_LD_IMM64(R1, -1), 9075 BPF_LD_IMM64(R2, -2), 9076 BPF_JMP_REG(BPF_JSLE, R2, R1, 1), 9077 BPF_EXIT_INSN(), 9078 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9079 BPF_EXIT_INSN(), 9080 }, 9081 INTERNAL, 9082 { }, 9083 { { 0, 1 } }, 9084 }, 9085 { 9086 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1", 9087 .u.insns_int = { 9088 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9089 BPF_LD_IMM64(R1, -1), 9090 BPF_LD_IMM64(R2, -1), 9091 BPF_JMP_REG(BPF_JSLE, R1, R2, 1), 9092 BPF_EXIT_INSN(), 9093 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9094 BPF_EXIT_INSN(), 9095 }, 9096 INTERNAL, 9097 { }, 9098 { { 0, 1 } }, 9099 }, 9100 /* BPF_JMP | BPF_JGT | BPF_X */ 9101 { 9102 "JMP_JGT_X: if (3 > 2) return 1", 9103 .u.insns_int = { 9104 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9105 BPF_LD_IMM64(R1, 3), 9106 BPF_LD_IMM64(R2, 2), 9107 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 9108 BPF_EXIT_INSN(), 9109 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9110 BPF_EXIT_INSN(), 9111 }, 9112 INTERNAL, 9113 { }, 9114 { { 0, 1 } }, 9115 }, 9116 { 9117 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1", 9118 .u.insns_int = { 9119 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9120 BPF_LD_IMM64(R1, -1), 9121 BPF_LD_IMM64(R2, 1), 9122 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 9123 BPF_EXIT_INSN(), 9124 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9125 BPF_EXIT_INSN(), 9126 }, 9127 INTERNAL, 9128 { }, 9129 { { 0, 1 } }, 9130 }, 9131 /* BPF_JMP | BPF_JLT | BPF_X */ 9132 { 9133 "JMP_JLT_X: if (2 < 3) return 1", 9134 .u.insns_int = { 9135 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9136 BPF_LD_IMM64(R1, 3), 9137 BPF_LD_IMM64(R2, 2), 9138 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 9139 BPF_EXIT_INSN(), 9140 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9141 BPF_EXIT_INSN(), 9142 }, 9143 INTERNAL, 9144 { }, 9145 { { 0, 1 } }, 9146 }, 9147 { 9148 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1", 9149 .u.insns_int = { 9150 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9151 BPF_LD_IMM64(R1, -1), 9152 BPF_LD_IMM64(R2, 1), 9153 BPF_JMP_REG(BPF_JLT, R2, R1, 1), 9154 BPF_EXIT_INSN(), 9155 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9156 BPF_EXIT_INSN(), 9157 }, 9158 INTERNAL, 9159 { }, 9160 { { 0, 1 } }, 9161 }, 9162 /* BPF_JMP | BPF_JGE | BPF_X */ 9163 { 9164 "JMP_JGE_X: if (3 >= 2) return 1", 9165 .u.insns_int = { 9166 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9167 BPF_LD_IMM64(R1, 3), 9168 BPF_LD_IMM64(R2, 2), 9169 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 9170 BPF_EXIT_INSN(), 9171 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9172 BPF_EXIT_INSN(), 9173 }, 9174 INTERNAL, 9175 { }, 9176 { { 0, 1 } }, 9177 }, 9178 { 9179 "JMP_JGE_X: if (3 >= 3) return 1", 9180 .u.insns_int = { 9181 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9182 BPF_LD_IMM64(R1, 3), 9183 BPF_LD_IMM64(R2, 3), 9184 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 9185 BPF_EXIT_INSN(), 9186 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9187 BPF_EXIT_INSN(), 9188 }, 9189 INTERNAL, 9190 { }, 9191 { { 0, 1 } }, 9192 }, 9193 /* BPF_JMP | BPF_JLE | BPF_X */ 9194 { 9195 "JMP_JLE_X: if (2 <= 3) return 1", 9196 .u.insns_int = { 9197 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9198 BPF_LD_IMM64(R1, 3), 9199 BPF_LD_IMM64(R2, 2), 9200 BPF_JMP_REG(BPF_JLE, R2, R1, 1), 9201 BPF_EXIT_INSN(), 9202 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9203 BPF_EXIT_INSN(), 9204 }, 9205 INTERNAL, 9206 { }, 9207 { { 0, 1 } }, 9208 }, 9209 { 9210 "JMP_JLE_X: if (3 <= 3) return 1", 9211 .u.insns_int = { 9212 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9213 BPF_LD_IMM64(R1, 3), 9214 BPF_LD_IMM64(R2, 3), 9215 BPF_JMP_REG(BPF_JLE, R1, R2, 1), 9216 BPF_EXIT_INSN(), 9217 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9218 BPF_EXIT_INSN(), 9219 }, 9220 INTERNAL, 9221 { }, 9222 { { 0, 1 } }, 9223 }, 9224 { 9225 /* Mainly testing JIT + imm64 here. */ 9226 "JMP_JGE_X: ldimm64 test 1", 9227 .u.insns_int = { 9228 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9229 BPF_LD_IMM64(R1, 3), 9230 BPF_LD_IMM64(R2, 2), 9231 BPF_JMP_REG(BPF_JGE, R1, R2, 2), 9232 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9233 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 9234 BPF_EXIT_INSN(), 9235 }, 9236 INTERNAL, 9237 { }, 9238 { { 0, 0xeeeeeeeeU } }, 9239 }, 9240 { 9241 "JMP_JGE_X: ldimm64 test 2", 9242 .u.insns_int = { 9243 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9244 BPF_LD_IMM64(R1, 3), 9245 BPF_LD_IMM64(R2, 2), 9246 BPF_JMP_REG(BPF_JGE, R1, R2, 0), 9247 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9248 BPF_EXIT_INSN(), 9249 }, 9250 INTERNAL, 9251 { }, 9252 { { 0, 0xffffffffU } }, 9253 }, 9254 { 9255 "JMP_JGE_X: ldimm64 test 3", 9256 .u.insns_int = { 9257 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9258 BPF_LD_IMM64(R1, 3), 9259 BPF_LD_IMM64(R2, 2), 9260 BPF_JMP_REG(BPF_JGE, R1, R2, 4), 9261 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9262 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 9263 BPF_EXIT_INSN(), 9264 }, 9265 INTERNAL, 9266 { }, 9267 { { 0, 1 } }, 9268 }, 9269 { 9270 "JMP_JLE_X: ldimm64 test 1", 9271 .u.insns_int = { 9272 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9273 BPF_LD_IMM64(R1, 3), 9274 BPF_LD_IMM64(R2, 2), 9275 BPF_JMP_REG(BPF_JLE, R2, R1, 2), 9276 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9277 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 9278 BPF_EXIT_INSN(), 9279 }, 9280 INTERNAL, 9281 { }, 9282 { { 0, 0xeeeeeeeeU } }, 9283 }, 9284 { 9285 "JMP_JLE_X: ldimm64 test 2", 9286 .u.insns_int = { 9287 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9288 BPF_LD_IMM64(R1, 3), 9289 BPF_LD_IMM64(R2, 2), 9290 BPF_JMP_REG(BPF_JLE, R2, R1, 0), 9291 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9292 BPF_EXIT_INSN(), 9293 }, 9294 INTERNAL, 9295 { }, 9296 { { 0, 0xffffffffU } }, 9297 }, 9298 { 9299 "JMP_JLE_X: ldimm64 test 3", 9300 .u.insns_int = { 9301 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9302 BPF_LD_IMM64(R1, 3), 9303 BPF_LD_IMM64(R2, 2), 9304 BPF_JMP_REG(BPF_JLE, R2, R1, 4), 9305 BPF_LD_IMM64(R0, 0xffffffffffffffffULL), 9306 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL), 9307 BPF_EXIT_INSN(), 9308 }, 9309 INTERNAL, 9310 { }, 9311 { { 0, 1 } }, 9312 }, 9313 /* BPF_JMP | BPF_JNE | BPF_X */ 9314 { 9315 "JMP_JNE_X: if (3 != 2) return 1", 9316 .u.insns_int = { 9317 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9318 BPF_LD_IMM64(R1, 3), 9319 BPF_LD_IMM64(R2, 2), 9320 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 9321 BPF_EXIT_INSN(), 9322 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9323 BPF_EXIT_INSN(), 9324 }, 9325 INTERNAL, 9326 { }, 9327 { { 0, 1 } }, 9328 }, 9329 /* BPF_JMP | BPF_JEQ | BPF_X */ 9330 { 9331 "JMP_JEQ_X: if (3 == 3) return 1", 9332 .u.insns_int = { 9333 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9334 BPF_LD_IMM64(R1, 3), 9335 BPF_LD_IMM64(R2, 3), 9336 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 9337 BPF_EXIT_INSN(), 9338 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9339 BPF_EXIT_INSN(), 9340 }, 9341 INTERNAL, 9342 { }, 9343 { { 0, 1 } }, 9344 }, 9345 /* BPF_JMP | BPF_JSET | BPF_X */ 9346 { 9347 "JMP_JSET_X: if (0x3 & 0x2) return 1", 9348 .u.insns_int = { 9349 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9350 BPF_LD_IMM64(R1, 3), 9351 BPF_LD_IMM64(R2, 2), 9352 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 9353 BPF_EXIT_INSN(), 9354 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9355 BPF_EXIT_INSN(), 9356 }, 9357 INTERNAL, 9358 { }, 9359 { { 0, 1 } }, 9360 }, 9361 { 9362 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1", 9363 .u.insns_int = { 9364 BPF_ALU32_IMM(BPF_MOV, R0, 0), 9365 BPF_LD_IMM64(R1, 3), 9366 BPF_LD_IMM64(R2, 0xffffffff), 9367 BPF_JMP_REG(BPF_JSET, R1, R2, 1), 9368 BPF_EXIT_INSN(), 9369 BPF_ALU32_IMM(BPF_MOV, R0, 1), 9370 BPF_EXIT_INSN(), 9371 }, 9372 INTERNAL, 9373 { }, 9374 { { 0, 1 } }, 9375 }, 9376 { 9377 "JMP_JA: Jump, gap, jump, ...", 9378 { }, 9379 CLASSIC | FLAG_NO_DATA, 9380 { }, 9381 { { 0, 0xababcbac } }, 9382 .fill_helper = bpf_fill_ja, 9383 }, 9384 { /* Mainly checking JIT here. */ 9385 "BPF_MAXINSNS: Maximum possible literals", 9386 { }, 9387 CLASSIC | FLAG_NO_DATA, 9388 { }, 9389 { { 0, 0xffffffff } }, 9390 .fill_helper = bpf_fill_maxinsns1, 9391 }, 9392 { /* Mainly checking JIT here. */ 9393 "BPF_MAXINSNS: Single literal", 9394 { }, 9395 CLASSIC | FLAG_NO_DATA, 9396 { }, 9397 { { 0, 0xfefefefe } }, 9398 .fill_helper = bpf_fill_maxinsns2, 9399 }, 9400 { /* Mainly checking JIT here. */ 9401 "BPF_MAXINSNS: Run/add until end", 9402 { }, 9403 CLASSIC | FLAG_NO_DATA, 9404 { }, 9405 { { 0, 0x947bf368 } }, 9406 .fill_helper = bpf_fill_maxinsns3, 9407 }, 9408 { 9409 "BPF_MAXINSNS: Too many instructions", 9410 { }, 9411 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 9412 { }, 9413 { }, 9414 .fill_helper = bpf_fill_maxinsns4, 9415 .expected_errcode = -EINVAL, 9416 }, 9417 { /* Mainly checking JIT here. */ 9418 "BPF_MAXINSNS: Very long jump", 9419 { }, 9420 CLASSIC | FLAG_NO_DATA, 9421 { }, 9422 { { 0, 0xabababab } }, 9423 .fill_helper = bpf_fill_maxinsns5, 9424 }, 9425 { /* Mainly checking JIT here. */ 9426 "BPF_MAXINSNS: Ctx heavy transformations", 9427 { }, 9428 CLASSIC, 9429 { }, 9430 { 9431 { 1, SKB_VLAN_PRESENT }, 9432 { 10, SKB_VLAN_PRESENT } 9433 }, 9434 .fill_helper = bpf_fill_maxinsns6, 9435 }, 9436 { /* Mainly checking JIT here. */ 9437 "BPF_MAXINSNS: Call heavy transformations", 9438 { }, 9439 CLASSIC | FLAG_NO_DATA, 9440 { }, 9441 { { 1, 0 }, { 10, 0 } }, 9442 .fill_helper = bpf_fill_maxinsns7, 9443 }, 9444 { /* Mainly checking JIT here. */ 9445 "BPF_MAXINSNS: Jump heavy test", 9446 { }, 9447 CLASSIC | FLAG_NO_DATA, 9448 { }, 9449 { { 0, 0xffffffff } }, 9450 .fill_helper = bpf_fill_maxinsns8, 9451 }, 9452 { /* Mainly checking JIT here. */ 9453 "BPF_MAXINSNS: Very long jump backwards", 9454 { }, 9455 INTERNAL | FLAG_NO_DATA, 9456 { }, 9457 { { 0, 0xcbababab } }, 9458 .fill_helper = bpf_fill_maxinsns9, 9459 }, 9460 { /* Mainly checking JIT here. */ 9461 "BPF_MAXINSNS: Edge hopping nuthouse", 9462 { }, 9463 INTERNAL | FLAG_NO_DATA, 9464 { }, 9465 { { 0, 0xabababac } }, 9466 .fill_helper = bpf_fill_maxinsns10, 9467 }, 9468 { 9469 "BPF_MAXINSNS: Jump, gap, jump, ...", 9470 { }, 9471 CLASSIC | FLAG_NO_DATA, 9472 { }, 9473 { { 0, 0xababcbac } }, 9474 .fill_helper = bpf_fill_maxinsns11, 9475 }, 9476 { 9477 "BPF_MAXINSNS: jump over MSH", 9478 { }, 9479 CLASSIC | FLAG_EXPECTED_FAIL, 9480 { 0xfa, 0xfb, 0xfc, 0xfd, }, 9481 { { 4, 0xabababab } }, 9482 .fill_helper = bpf_fill_maxinsns12, 9483 .expected_errcode = -EINVAL, 9484 }, 9485 { 9486 "BPF_MAXINSNS: exec all MSH", 9487 { }, 9488 CLASSIC, 9489 { 0xfa, 0xfb, 0xfc, 0xfd, }, 9490 { { 4, 0xababab83 } }, 9491 .fill_helper = bpf_fill_maxinsns13, 9492 }, 9493 { 9494 "BPF_MAXINSNS: ld_abs+get_processor_id", 9495 { }, 9496 CLASSIC, 9497 { }, 9498 { { 1, 0xbee } }, 9499 .fill_helper = bpf_fill_ld_abs_get_processor_id, 9500 }, 9501 /* 9502 * LD_IND / LD_ABS on fragmented SKBs 9503 */ 9504 { 9505 "LD_IND byte frag", 9506 .u.insns = { 9507 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 9508 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0), 9509 BPF_STMT(BPF_RET | BPF_A, 0x0), 9510 }, 9511 CLASSIC | FLAG_SKB_FRAG, 9512 { }, 9513 { {0x40, 0x42} }, 9514 .frag_data = { 9515 0x42, 0x00, 0x00, 0x00, 9516 0x43, 0x44, 0x00, 0x00, 9517 0x21, 0x07, 0x19, 0x83, 9518 }, 9519 }, 9520 { 9521 "LD_IND halfword frag", 9522 .u.insns = { 9523 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 9524 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4), 9525 BPF_STMT(BPF_RET | BPF_A, 0x0), 9526 }, 9527 CLASSIC | FLAG_SKB_FRAG, 9528 { }, 9529 { {0x40, 0x4344} }, 9530 .frag_data = { 9531 0x42, 0x00, 0x00, 0x00, 9532 0x43, 0x44, 0x00, 0x00, 9533 0x21, 0x07, 0x19, 0x83, 9534 }, 9535 }, 9536 { 9537 "LD_IND word frag", 9538 .u.insns = { 9539 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 9540 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8), 9541 BPF_STMT(BPF_RET | BPF_A, 0x0), 9542 }, 9543 CLASSIC | FLAG_SKB_FRAG, 9544 { }, 9545 { {0x40, 0x21071983} }, 9546 .frag_data = { 9547 0x42, 0x00, 0x00, 0x00, 9548 0x43, 0x44, 0x00, 0x00, 9549 0x21, 0x07, 0x19, 0x83, 9550 }, 9551 }, 9552 { 9553 "LD_IND halfword mixed head/frag", 9554 .u.insns = { 9555 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 9556 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 9557 BPF_STMT(BPF_RET | BPF_A, 0x0), 9558 }, 9559 CLASSIC | FLAG_SKB_FRAG, 9560 { [0x3e] = 0x25, [0x3f] = 0x05, }, 9561 { {0x40, 0x0519} }, 9562 .frag_data = { 0x19, 0x82 }, 9563 }, 9564 { 9565 "LD_IND word mixed head/frag", 9566 .u.insns = { 9567 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 9568 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 9569 BPF_STMT(BPF_RET | BPF_A, 0x0), 9570 }, 9571 CLASSIC | FLAG_SKB_FRAG, 9572 { [0x3e] = 0x25, [0x3f] = 0x05, }, 9573 { {0x40, 0x25051982} }, 9574 .frag_data = { 0x19, 0x82 }, 9575 }, 9576 { 9577 "LD_ABS byte frag", 9578 .u.insns = { 9579 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40), 9580 BPF_STMT(BPF_RET | BPF_A, 0x0), 9581 }, 9582 CLASSIC | FLAG_SKB_FRAG, 9583 { }, 9584 { {0x40, 0x42} }, 9585 .frag_data = { 9586 0x42, 0x00, 0x00, 0x00, 9587 0x43, 0x44, 0x00, 0x00, 9588 0x21, 0x07, 0x19, 0x83, 9589 }, 9590 }, 9591 { 9592 "LD_ABS halfword frag", 9593 .u.insns = { 9594 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44), 9595 BPF_STMT(BPF_RET | BPF_A, 0x0), 9596 }, 9597 CLASSIC | FLAG_SKB_FRAG, 9598 { }, 9599 { {0x40, 0x4344} }, 9600 .frag_data = { 9601 0x42, 0x00, 0x00, 0x00, 9602 0x43, 0x44, 0x00, 0x00, 9603 0x21, 0x07, 0x19, 0x83, 9604 }, 9605 }, 9606 { 9607 "LD_ABS word frag", 9608 .u.insns = { 9609 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48), 9610 BPF_STMT(BPF_RET | BPF_A, 0x0), 9611 }, 9612 CLASSIC | FLAG_SKB_FRAG, 9613 { }, 9614 { {0x40, 0x21071983} }, 9615 .frag_data = { 9616 0x42, 0x00, 0x00, 0x00, 9617 0x43, 0x44, 0x00, 0x00, 9618 0x21, 0x07, 0x19, 0x83, 9619 }, 9620 }, 9621 { 9622 "LD_ABS halfword mixed head/frag", 9623 .u.insns = { 9624 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 9625 BPF_STMT(BPF_RET | BPF_A, 0x0), 9626 }, 9627 CLASSIC | FLAG_SKB_FRAG, 9628 { [0x3e] = 0x25, [0x3f] = 0x05, }, 9629 { {0x40, 0x0519} }, 9630 .frag_data = { 0x19, 0x82 }, 9631 }, 9632 { 9633 "LD_ABS word mixed head/frag", 9634 .u.insns = { 9635 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e), 9636 BPF_STMT(BPF_RET | BPF_A, 0x0), 9637 }, 9638 CLASSIC | FLAG_SKB_FRAG, 9639 { [0x3e] = 0x25, [0x3f] = 0x05, }, 9640 { {0x40, 0x25051982} }, 9641 .frag_data = { 0x19, 0x82 }, 9642 }, 9643 /* 9644 * LD_IND / LD_ABS on non fragmented SKBs 9645 */ 9646 { 9647 /* 9648 * this tests that the JIT/interpreter correctly resets X 9649 * before using it in an LD_IND instruction. 9650 */ 9651 "LD_IND byte default X", 9652 .u.insns = { 9653 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 9654 BPF_STMT(BPF_RET | BPF_A, 0x0), 9655 }, 9656 CLASSIC, 9657 { [0x1] = 0x42 }, 9658 { {0x40, 0x42 } }, 9659 }, 9660 { 9661 "LD_IND byte positive offset", 9662 .u.insns = { 9663 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9664 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 9665 BPF_STMT(BPF_RET | BPF_A, 0x0), 9666 }, 9667 CLASSIC, 9668 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9669 { {0x40, 0x82 } }, 9670 }, 9671 { 9672 "LD_IND byte negative offset", 9673 .u.insns = { 9674 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9675 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1), 9676 BPF_STMT(BPF_RET | BPF_A, 0x0), 9677 }, 9678 CLASSIC, 9679 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9680 { {0x40, 0x05 } }, 9681 }, 9682 { 9683 "LD_IND byte positive offset, all ff", 9684 .u.insns = { 9685 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9686 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 9687 BPF_STMT(BPF_RET | BPF_A, 0x0), 9688 }, 9689 CLASSIC, 9690 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 9691 { {0x40, 0xff } }, 9692 }, 9693 { 9694 "LD_IND byte positive offset, out of bounds", 9695 .u.insns = { 9696 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9697 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 9698 BPF_STMT(BPF_RET | BPF_A, 0x0), 9699 }, 9700 CLASSIC, 9701 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9702 { {0x3f, 0 }, }, 9703 }, 9704 { 9705 "LD_IND byte negative offset, out of bounds", 9706 .u.insns = { 9707 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9708 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f), 9709 BPF_STMT(BPF_RET | BPF_A, 0x0), 9710 }, 9711 CLASSIC, 9712 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9713 { {0x3f, 0 } }, 9714 }, 9715 { 9716 "LD_IND byte negative offset, multiple calls", 9717 .u.insns = { 9718 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 9719 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1), 9720 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2), 9721 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3), 9722 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4), 9723 BPF_STMT(BPF_RET | BPF_A, 0x0), 9724 }, 9725 CLASSIC, 9726 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9727 { {0x40, 0x82 }, }, 9728 }, 9729 { 9730 "LD_IND halfword positive offset", 9731 .u.insns = { 9732 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9733 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2), 9734 BPF_STMT(BPF_RET | BPF_A, 0x0), 9735 }, 9736 CLASSIC, 9737 { 9738 [0x1c] = 0xaa, [0x1d] = 0x55, 9739 [0x1e] = 0xbb, [0x1f] = 0x66, 9740 [0x20] = 0xcc, [0x21] = 0x77, 9741 [0x22] = 0xdd, [0x23] = 0x88, 9742 }, 9743 { {0x40, 0xdd88 } }, 9744 }, 9745 { 9746 "LD_IND halfword negative offset", 9747 .u.insns = { 9748 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9749 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2), 9750 BPF_STMT(BPF_RET | BPF_A, 0x0), 9751 }, 9752 CLASSIC, 9753 { 9754 [0x1c] = 0xaa, [0x1d] = 0x55, 9755 [0x1e] = 0xbb, [0x1f] = 0x66, 9756 [0x20] = 0xcc, [0x21] = 0x77, 9757 [0x22] = 0xdd, [0x23] = 0x88, 9758 }, 9759 { {0x40, 0xbb66 } }, 9760 }, 9761 { 9762 "LD_IND halfword unaligned", 9763 .u.insns = { 9764 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9765 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 9766 BPF_STMT(BPF_RET | BPF_A, 0x0), 9767 }, 9768 CLASSIC, 9769 { 9770 [0x1c] = 0xaa, [0x1d] = 0x55, 9771 [0x1e] = 0xbb, [0x1f] = 0x66, 9772 [0x20] = 0xcc, [0x21] = 0x77, 9773 [0x22] = 0xdd, [0x23] = 0x88, 9774 }, 9775 { {0x40, 0x66cc } }, 9776 }, 9777 { 9778 "LD_IND halfword positive offset, all ff", 9779 .u.insns = { 9780 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d), 9781 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 9782 BPF_STMT(BPF_RET | BPF_A, 0x0), 9783 }, 9784 CLASSIC, 9785 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 9786 { {0x40, 0xffff } }, 9787 }, 9788 { 9789 "LD_IND halfword positive offset, out of bounds", 9790 .u.insns = { 9791 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9792 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 9793 BPF_STMT(BPF_RET | BPF_A, 0x0), 9794 }, 9795 CLASSIC, 9796 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9797 { {0x3f, 0 }, }, 9798 }, 9799 { 9800 "LD_IND halfword negative offset, out of bounds", 9801 .u.insns = { 9802 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9803 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f), 9804 BPF_STMT(BPF_RET | BPF_A, 0x0), 9805 }, 9806 CLASSIC, 9807 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9808 { {0x3f, 0 } }, 9809 }, 9810 { 9811 "LD_IND word positive offset", 9812 .u.insns = { 9813 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9814 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4), 9815 BPF_STMT(BPF_RET | BPF_A, 0x0), 9816 }, 9817 CLASSIC, 9818 { 9819 [0x1c] = 0xaa, [0x1d] = 0x55, 9820 [0x1e] = 0xbb, [0x1f] = 0x66, 9821 [0x20] = 0xcc, [0x21] = 0x77, 9822 [0x22] = 0xdd, [0x23] = 0x88, 9823 [0x24] = 0xee, [0x25] = 0x99, 9824 [0x26] = 0xff, [0x27] = 0xaa, 9825 }, 9826 { {0x40, 0xee99ffaa } }, 9827 }, 9828 { 9829 "LD_IND word negative offset", 9830 .u.insns = { 9831 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9832 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4), 9833 BPF_STMT(BPF_RET | BPF_A, 0x0), 9834 }, 9835 CLASSIC, 9836 { 9837 [0x1c] = 0xaa, [0x1d] = 0x55, 9838 [0x1e] = 0xbb, [0x1f] = 0x66, 9839 [0x20] = 0xcc, [0x21] = 0x77, 9840 [0x22] = 0xdd, [0x23] = 0x88, 9841 [0x24] = 0xee, [0x25] = 0x99, 9842 [0x26] = 0xff, [0x27] = 0xaa, 9843 }, 9844 { {0x40, 0xaa55bb66 } }, 9845 }, 9846 { 9847 "LD_IND word unaligned (addr & 3 == 2)", 9848 .u.insns = { 9849 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9850 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 9851 BPF_STMT(BPF_RET | BPF_A, 0x0), 9852 }, 9853 CLASSIC, 9854 { 9855 [0x1c] = 0xaa, [0x1d] = 0x55, 9856 [0x1e] = 0xbb, [0x1f] = 0x66, 9857 [0x20] = 0xcc, [0x21] = 0x77, 9858 [0x22] = 0xdd, [0x23] = 0x88, 9859 [0x24] = 0xee, [0x25] = 0x99, 9860 [0x26] = 0xff, [0x27] = 0xaa, 9861 }, 9862 { {0x40, 0xbb66cc77 } }, 9863 }, 9864 { 9865 "LD_IND word unaligned (addr & 3 == 1)", 9866 .u.insns = { 9867 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9868 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3), 9869 BPF_STMT(BPF_RET | BPF_A, 0x0), 9870 }, 9871 CLASSIC, 9872 { 9873 [0x1c] = 0xaa, [0x1d] = 0x55, 9874 [0x1e] = 0xbb, [0x1f] = 0x66, 9875 [0x20] = 0xcc, [0x21] = 0x77, 9876 [0x22] = 0xdd, [0x23] = 0x88, 9877 [0x24] = 0xee, [0x25] = 0x99, 9878 [0x26] = 0xff, [0x27] = 0xaa, 9879 }, 9880 { {0x40, 0x55bb66cc } }, 9881 }, 9882 { 9883 "LD_IND word unaligned (addr & 3 == 3)", 9884 .u.insns = { 9885 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 9886 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1), 9887 BPF_STMT(BPF_RET | BPF_A, 0x0), 9888 }, 9889 CLASSIC, 9890 { 9891 [0x1c] = 0xaa, [0x1d] = 0x55, 9892 [0x1e] = 0xbb, [0x1f] = 0x66, 9893 [0x20] = 0xcc, [0x21] = 0x77, 9894 [0x22] = 0xdd, [0x23] = 0x88, 9895 [0x24] = 0xee, [0x25] = 0x99, 9896 [0x26] = 0xff, [0x27] = 0xaa, 9897 }, 9898 { {0x40, 0x66cc77dd } }, 9899 }, 9900 { 9901 "LD_IND word positive offset, all ff", 9902 .u.insns = { 9903 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 9904 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 9905 BPF_STMT(BPF_RET | BPF_A, 0x0), 9906 }, 9907 CLASSIC, 9908 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 9909 { {0x40, 0xffffffff } }, 9910 }, 9911 { 9912 "LD_IND word positive offset, out of bounds", 9913 .u.insns = { 9914 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9915 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 9916 BPF_STMT(BPF_RET | BPF_A, 0x0), 9917 }, 9918 CLASSIC, 9919 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9920 { {0x3f, 0 }, }, 9921 }, 9922 { 9923 "LD_IND word negative offset, out of bounds", 9924 .u.insns = { 9925 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 9926 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f), 9927 BPF_STMT(BPF_RET | BPF_A, 0x0), 9928 }, 9929 CLASSIC, 9930 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9931 { {0x3f, 0 } }, 9932 }, 9933 { 9934 "LD_ABS byte", 9935 .u.insns = { 9936 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20), 9937 BPF_STMT(BPF_RET | BPF_A, 0x0), 9938 }, 9939 CLASSIC, 9940 { 9941 [0x1c] = 0xaa, [0x1d] = 0x55, 9942 [0x1e] = 0xbb, [0x1f] = 0x66, 9943 [0x20] = 0xcc, [0x21] = 0x77, 9944 [0x22] = 0xdd, [0x23] = 0x88, 9945 [0x24] = 0xee, [0x25] = 0x99, 9946 [0x26] = 0xff, [0x27] = 0xaa, 9947 }, 9948 { {0x40, 0xcc } }, 9949 }, 9950 { 9951 "LD_ABS byte positive offset, all ff", 9952 .u.insns = { 9953 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 9954 BPF_STMT(BPF_RET | BPF_A, 0x0), 9955 }, 9956 CLASSIC, 9957 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 9958 { {0x40, 0xff } }, 9959 }, 9960 { 9961 "LD_ABS byte positive offset, out of bounds", 9962 .u.insns = { 9963 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 9964 BPF_STMT(BPF_RET | BPF_A, 0x0), 9965 }, 9966 CLASSIC, 9967 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9968 { {0x3f, 0 }, }, 9969 }, 9970 { 9971 "LD_ABS byte negative offset, out of bounds load", 9972 .u.insns = { 9973 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1), 9974 BPF_STMT(BPF_RET | BPF_A, 0x0), 9975 }, 9976 CLASSIC | FLAG_EXPECTED_FAIL, 9977 .expected_errcode = -EINVAL, 9978 }, 9979 { 9980 "LD_ABS byte negative offset, in bounds", 9981 .u.insns = { 9982 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 9983 BPF_STMT(BPF_RET | BPF_A, 0x0), 9984 }, 9985 CLASSIC, 9986 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9987 { {0x40, 0x82 }, }, 9988 }, 9989 { 9990 "LD_ABS byte negative offset, out of bounds", 9991 .u.insns = { 9992 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 9993 BPF_STMT(BPF_RET | BPF_A, 0x0), 9994 }, 9995 CLASSIC, 9996 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 9997 { {0x3f, 0 }, }, 9998 }, 9999 { 10000 "LD_ABS byte negative offset, multiple calls", 10001 .u.insns = { 10002 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c), 10003 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d), 10004 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e), 10005 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 10006 BPF_STMT(BPF_RET | BPF_A, 0x0), 10007 }, 10008 CLASSIC, 10009 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10010 { {0x40, 0x82 }, }, 10011 }, 10012 { 10013 "LD_ABS halfword", 10014 .u.insns = { 10015 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22), 10016 BPF_STMT(BPF_RET | BPF_A, 0x0), 10017 }, 10018 CLASSIC, 10019 { 10020 [0x1c] = 0xaa, [0x1d] = 0x55, 10021 [0x1e] = 0xbb, [0x1f] = 0x66, 10022 [0x20] = 0xcc, [0x21] = 0x77, 10023 [0x22] = 0xdd, [0x23] = 0x88, 10024 [0x24] = 0xee, [0x25] = 0x99, 10025 [0x26] = 0xff, [0x27] = 0xaa, 10026 }, 10027 { {0x40, 0xdd88 } }, 10028 }, 10029 { 10030 "LD_ABS halfword unaligned", 10031 .u.insns = { 10032 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25), 10033 BPF_STMT(BPF_RET | BPF_A, 0x0), 10034 }, 10035 CLASSIC, 10036 { 10037 [0x1c] = 0xaa, [0x1d] = 0x55, 10038 [0x1e] = 0xbb, [0x1f] = 0x66, 10039 [0x20] = 0xcc, [0x21] = 0x77, 10040 [0x22] = 0xdd, [0x23] = 0x88, 10041 [0x24] = 0xee, [0x25] = 0x99, 10042 [0x26] = 0xff, [0x27] = 0xaa, 10043 }, 10044 { {0x40, 0x99ff } }, 10045 }, 10046 { 10047 "LD_ABS halfword positive offset, all ff", 10048 .u.insns = { 10049 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e), 10050 BPF_STMT(BPF_RET | BPF_A, 0x0), 10051 }, 10052 CLASSIC, 10053 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 10054 { {0x40, 0xffff } }, 10055 }, 10056 { 10057 "LD_ABS halfword positive offset, out of bounds", 10058 .u.insns = { 10059 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 10060 BPF_STMT(BPF_RET | BPF_A, 0x0), 10061 }, 10062 CLASSIC, 10063 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10064 { {0x3f, 0 }, }, 10065 }, 10066 { 10067 "LD_ABS halfword negative offset, out of bounds load", 10068 .u.insns = { 10069 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1), 10070 BPF_STMT(BPF_RET | BPF_A, 0x0), 10071 }, 10072 CLASSIC | FLAG_EXPECTED_FAIL, 10073 .expected_errcode = -EINVAL, 10074 }, 10075 { 10076 "LD_ABS halfword negative offset, in bounds", 10077 .u.insns = { 10078 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 10079 BPF_STMT(BPF_RET | BPF_A, 0x0), 10080 }, 10081 CLASSIC, 10082 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10083 { {0x40, 0x1982 }, }, 10084 }, 10085 { 10086 "LD_ABS halfword negative offset, out of bounds", 10087 .u.insns = { 10088 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 10089 BPF_STMT(BPF_RET | BPF_A, 0x0), 10090 }, 10091 CLASSIC, 10092 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10093 { {0x3f, 0 }, }, 10094 }, 10095 { 10096 "LD_ABS word", 10097 .u.insns = { 10098 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c), 10099 BPF_STMT(BPF_RET | BPF_A, 0x0), 10100 }, 10101 CLASSIC, 10102 { 10103 [0x1c] = 0xaa, [0x1d] = 0x55, 10104 [0x1e] = 0xbb, [0x1f] = 0x66, 10105 [0x20] = 0xcc, [0x21] = 0x77, 10106 [0x22] = 0xdd, [0x23] = 0x88, 10107 [0x24] = 0xee, [0x25] = 0x99, 10108 [0x26] = 0xff, [0x27] = 0xaa, 10109 }, 10110 { {0x40, 0xaa55bb66 } }, 10111 }, 10112 { 10113 "LD_ABS word unaligned (addr & 3 == 2)", 10114 .u.insns = { 10115 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22), 10116 BPF_STMT(BPF_RET | BPF_A, 0x0), 10117 }, 10118 CLASSIC, 10119 { 10120 [0x1c] = 0xaa, [0x1d] = 0x55, 10121 [0x1e] = 0xbb, [0x1f] = 0x66, 10122 [0x20] = 0xcc, [0x21] = 0x77, 10123 [0x22] = 0xdd, [0x23] = 0x88, 10124 [0x24] = 0xee, [0x25] = 0x99, 10125 [0x26] = 0xff, [0x27] = 0xaa, 10126 }, 10127 { {0x40, 0xdd88ee99 } }, 10128 }, 10129 { 10130 "LD_ABS word unaligned (addr & 3 == 1)", 10131 .u.insns = { 10132 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21), 10133 BPF_STMT(BPF_RET | BPF_A, 0x0), 10134 }, 10135 CLASSIC, 10136 { 10137 [0x1c] = 0xaa, [0x1d] = 0x55, 10138 [0x1e] = 0xbb, [0x1f] = 0x66, 10139 [0x20] = 0xcc, [0x21] = 0x77, 10140 [0x22] = 0xdd, [0x23] = 0x88, 10141 [0x24] = 0xee, [0x25] = 0x99, 10142 [0x26] = 0xff, [0x27] = 0xaa, 10143 }, 10144 { {0x40, 0x77dd88ee } }, 10145 }, 10146 { 10147 "LD_ABS word unaligned (addr & 3 == 3)", 10148 .u.insns = { 10149 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23), 10150 BPF_STMT(BPF_RET | BPF_A, 0x0), 10151 }, 10152 CLASSIC, 10153 { 10154 [0x1c] = 0xaa, [0x1d] = 0x55, 10155 [0x1e] = 0xbb, [0x1f] = 0x66, 10156 [0x20] = 0xcc, [0x21] = 0x77, 10157 [0x22] = 0xdd, [0x23] = 0x88, 10158 [0x24] = 0xee, [0x25] = 0x99, 10159 [0x26] = 0xff, [0x27] = 0xaa, 10160 }, 10161 { {0x40, 0x88ee99ff } }, 10162 }, 10163 { 10164 "LD_ABS word positive offset, all ff", 10165 .u.insns = { 10166 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c), 10167 BPF_STMT(BPF_RET | BPF_A, 0x0), 10168 }, 10169 CLASSIC, 10170 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 10171 { {0x40, 0xffffffff } }, 10172 }, 10173 { 10174 "LD_ABS word positive offset, out of bounds", 10175 .u.insns = { 10176 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f), 10177 BPF_STMT(BPF_RET | BPF_A, 0x0), 10178 }, 10179 CLASSIC, 10180 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10181 { {0x3f, 0 }, }, 10182 }, 10183 { 10184 "LD_ABS word negative offset, out of bounds load", 10185 .u.insns = { 10186 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1), 10187 BPF_STMT(BPF_RET | BPF_A, 0x0), 10188 }, 10189 CLASSIC | FLAG_EXPECTED_FAIL, 10190 .expected_errcode = -EINVAL, 10191 }, 10192 { 10193 "LD_ABS word negative offset, in bounds", 10194 .u.insns = { 10195 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 10196 BPF_STMT(BPF_RET | BPF_A, 0x0), 10197 }, 10198 CLASSIC, 10199 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10200 { {0x40, 0x25051982 }, }, 10201 }, 10202 { 10203 "LD_ABS word negative offset, out of bounds", 10204 .u.insns = { 10205 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 10206 BPF_STMT(BPF_RET | BPF_A, 0x0), 10207 }, 10208 CLASSIC, 10209 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10210 { {0x3f, 0 }, }, 10211 }, 10212 { 10213 "LDX_MSH standalone, preserved A", 10214 .u.insns = { 10215 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10216 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 10217 BPF_STMT(BPF_RET | BPF_A, 0x0), 10218 }, 10219 CLASSIC, 10220 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10221 { {0x40, 0xffeebbaa }, }, 10222 }, 10223 { 10224 "LDX_MSH standalone, preserved A 2", 10225 .u.insns = { 10226 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63), 10227 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 10228 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d), 10229 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 10230 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f), 10231 BPF_STMT(BPF_RET | BPF_A, 0x0), 10232 }, 10233 CLASSIC, 10234 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10235 { {0x40, 0x175e9d63 }, }, 10236 }, 10237 { 10238 "LDX_MSH standalone, test result 1", 10239 .u.insns = { 10240 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10241 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 10242 BPF_STMT(BPF_MISC | BPF_TXA, 0), 10243 BPF_STMT(BPF_RET | BPF_A, 0x0), 10244 }, 10245 CLASSIC, 10246 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10247 { {0x40, 0x14 }, }, 10248 }, 10249 { 10250 "LDX_MSH standalone, test result 2", 10251 .u.insns = { 10252 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10253 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 10254 BPF_STMT(BPF_MISC | BPF_TXA, 0), 10255 BPF_STMT(BPF_RET | BPF_A, 0x0), 10256 }, 10257 CLASSIC, 10258 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10259 { {0x40, 0x24 }, }, 10260 }, 10261 { 10262 "LDX_MSH standalone, negative offset", 10263 .u.insns = { 10264 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10265 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1), 10266 BPF_STMT(BPF_MISC | BPF_TXA, 0), 10267 BPF_STMT(BPF_RET | BPF_A, 0x0), 10268 }, 10269 CLASSIC, 10270 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10271 { {0x40, 0 }, }, 10272 }, 10273 { 10274 "LDX_MSH standalone, negative offset 2", 10275 .u.insns = { 10276 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10277 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e), 10278 BPF_STMT(BPF_MISC | BPF_TXA, 0), 10279 BPF_STMT(BPF_RET | BPF_A, 0x0), 10280 }, 10281 CLASSIC, 10282 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10283 { {0x40, 0x24 }, }, 10284 }, 10285 { 10286 "LDX_MSH standalone, out of bounds", 10287 .u.insns = { 10288 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 10289 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40), 10290 BPF_STMT(BPF_MISC | BPF_TXA, 0), 10291 BPF_STMT(BPF_RET | BPF_A, 0x0), 10292 }, 10293 CLASSIC, 10294 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 10295 { {0x40, 0 }, }, 10296 }, 10297 /* 10298 * verify that the interpreter or JIT correctly sets A and X 10299 * to 0. 10300 */ 10301 { 10302 "ADD default X", 10303 .u.insns = { 10304 /* 10305 * A = 0x42 10306 * A = A + X 10307 * ret A 10308 */ 10309 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 10310 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 10311 BPF_STMT(BPF_RET | BPF_A, 0x0), 10312 }, 10313 CLASSIC | FLAG_NO_DATA, 10314 {}, 10315 { {0x1, 0x42 } }, 10316 }, 10317 { 10318 "ADD default A", 10319 .u.insns = { 10320 /* 10321 * A = A + 0x42 10322 * ret A 10323 */ 10324 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42), 10325 BPF_STMT(BPF_RET | BPF_A, 0x0), 10326 }, 10327 CLASSIC | FLAG_NO_DATA, 10328 {}, 10329 { {0x1, 0x42 } }, 10330 }, 10331 { 10332 "SUB default X", 10333 .u.insns = { 10334 /* 10335 * A = 0x66 10336 * A = A - X 10337 * ret A 10338 */ 10339 BPF_STMT(BPF_LD | BPF_IMM, 0x66), 10340 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 10341 BPF_STMT(BPF_RET | BPF_A, 0x0), 10342 }, 10343 CLASSIC | FLAG_NO_DATA, 10344 {}, 10345 { {0x1, 0x66 } }, 10346 }, 10347 { 10348 "SUB default A", 10349 .u.insns = { 10350 /* 10351 * A = A - -0x66 10352 * ret A 10353 */ 10354 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66), 10355 BPF_STMT(BPF_RET | BPF_A, 0x0), 10356 }, 10357 CLASSIC | FLAG_NO_DATA, 10358 {}, 10359 { {0x1, 0x66 } }, 10360 }, 10361 { 10362 "MUL default X", 10363 .u.insns = { 10364 /* 10365 * A = 0x42 10366 * A = A * X 10367 * ret A 10368 */ 10369 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 10370 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0), 10371 BPF_STMT(BPF_RET | BPF_A, 0x0), 10372 }, 10373 CLASSIC | FLAG_NO_DATA, 10374 {}, 10375 { {0x1, 0x0 } }, 10376 }, 10377 { 10378 "MUL default A", 10379 .u.insns = { 10380 /* 10381 * A = A * 0x66 10382 * ret A 10383 */ 10384 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66), 10385 BPF_STMT(BPF_RET | BPF_A, 0x0), 10386 }, 10387 CLASSIC | FLAG_NO_DATA, 10388 {}, 10389 { {0x1, 0x0 } }, 10390 }, 10391 { 10392 "DIV default X", 10393 .u.insns = { 10394 /* 10395 * A = 0x42 10396 * A = A / X ; this halt the filter execution if X is 0 10397 * ret 0x42 10398 */ 10399 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 10400 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 10401 BPF_STMT(BPF_RET | BPF_K, 0x42), 10402 }, 10403 CLASSIC | FLAG_NO_DATA, 10404 {}, 10405 { {0x1, 0x0 } }, 10406 }, 10407 { 10408 "DIV default A", 10409 .u.insns = { 10410 /* 10411 * A = A / 1 10412 * ret A 10413 */ 10414 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1), 10415 BPF_STMT(BPF_RET | BPF_A, 0x0), 10416 }, 10417 CLASSIC | FLAG_NO_DATA, 10418 {}, 10419 { {0x1, 0x0 } }, 10420 }, 10421 { 10422 "MOD default X", 10423 .u.insns = { 10424 /* 10425 * A = 0x42 10426 * A = A mod X ; this halt the filter execution if X is 0 10427 * ret 0x42 10428 */ 10429 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 10430 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 10431 BPF_STMT(BPF_RET | BPF_K, 0x42), 10432 }, 10433 CLASSIC | FLAG_NO_DATA, 10434 {}, 10435 { {0x1, 0x0 } }, 10436 }, 10437 { 10438 "MOD default A", 10439 .u.insns = { 10440 /* 10441 * A = A mod 1 10442 * ret A 10443 */ 10444 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1), 10445 BPF_STMT(BPF_RET | BPF_A, 0x0), 10446 }, 10447 CLASSIC | FLAG_NO_DATA, 10448 {}, 10449 { {0x1, 0x0 } }, 10450 }, 10451 { 10452 "JMP EQ default A", 10453 .u.insns = { 10454 /* 10455 * cmp A, 0x0, 0, 1 10456 * ret 0x42 10457 * ret 0x66 10458 */ 10459 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1), 10460 BPF_STMT(BPF_RET | BPF_K, 0x42), 10461 BPF_STMT(BPF_RET | BPF_K, 0x66), 10462 }, 10463 CLASSIC | FLAG_NO_DATA, 10464 {}, 10465 { {0x1, 0x42 } }, 10466 }, 10467 { 10468 "JMP EQ default X", 10469 .u.insns = { 10470 /* 10471 * A = 0x0 10472 * cmp A, X, 0, 1 10473 * ret 0x42 10474 * ret 0x66 10475 */ 10476 BPF_STMT(BPF_LD | BPF_IMM, 0x0), 10477 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1), 10478 BPF_STMT(BPF_RET | BPF_K, 0x42), 10479 BPF_STMT(BPF_RET | BPF_K, 0x66), 10480 }, 10481 CLASSIC | FLAG_NO_DATA, 10482 {}, 10483 { {0x1, 0x42 } }, 10484 }, 10485 /* Checking interpreter vs JIT wrt signed extended imms. */ 10486 { 10487 "JNE signed compare, test 1", 10488 .u.insns_int = { 10489 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 10490 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 10491 BPF_MOV64_REG(R2, R1), 10492 BPF_ALU64_REG(BPF_AND, R2, R3), 10493 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10494 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1), 10495 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10496 BPF_EXIT_INSN(), 10497 }, 10498 INTERNAL, 10499 { }, 10500 { { 0, 1 } }, 10501 }, 10502 { 10503 "JNE signed compare, test 2", 10504 .u.insns_int = { 10505 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 10506 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 10507 BPF_MOV64_REG(R2, R1), 10508 BPF_ALU64_REG(BPF_AND, R2, R3), 10509 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10510 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1), 10511 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10512 BPF_EXIT_INSN(), 10513 }, 10514 INTERNAL, 10515 { }, 10516 { { 0, 1 } }, 10517 }, 10518 { 10519 "JNE signed compare, test 3", 10520 .u.insns_int = { 10521 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 10522 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 10523 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000), 10524 BPF_MOV64_REG(R2, R1), 10525 BPF_ALU64_REG(BPF_AND, R2, R3), 10526 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10527 BPF_JMP_REG(BPF_JNE, R2, R4, 1), 10528 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10529 BPF_EXIT_INSN(), 10530 }, 10531 INTERNAL, 10532 { }, 10533 { { 0, 2 } }, 10534 }, 10535 { 10536 "JNE signed compare, test 4", 10537 .u.insns_int = { 10538 BPF_LD_IMM64(R1, -17104896), 10539 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10540 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1), 10541 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10542 BPF_EXIT_INSN(), 10543 }, 10544 INTERNAL, 10545 { }, 10546 { { 0, 2 } }, 10547 }, 10548 { 10549 "JNE signed compare, test 5", 10550 .u.insns_int = { 10551 BPF_LD_IMM64(R1, 0xfefb0000), 10552 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10553 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1), 10554 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10555 BPF_EXIT_INSN(), 10556 }, 10557 INTERNAL, 10558 { }, 10559 { { 0, 1 } }, 10560 }, 10561 { 10562 "JNE signed compare, test 6", 10563 .u.insns_int = { 10564 BPF_LD_IMM64(R1, 0x7efb0000), 10565 BPF_ALU32_IMM(BPF_MOV, R0, 1), 10566 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1), 10567 BPF_ALU32_IMM(BPF_MOV, R0, 2), 10568 BPF_EXIT_INSN(), 10569 }, 10570 INTERNAL, 10571 { }, 10572 { { 0, 2 } }, 10573 }, 10574 { 10575 "JNE signed compare, test 7", 10576 .u.insns = { 10577 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000), 10578 BPF_STMT(BPF_MISC | BPF_TAX, 0), 10579 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12), 10580 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0), 10581 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0), 10582 BPF_STMT(BPF_RET | BPF_K, 1), 10583 BPF_STMT(BPF_RET | BPF_K, 2), 10584 }, 10585 CLASSIC | FLAG_NO_DATA, 10586 {}, 10587 { { 0, 2 } }, 10588 }, 10589 /* Checking that ALU32 src is not zero extended in place */ 10590 #define BPF_ALU32_SRC_ZEXT(op) \ 10591 { \ 10592 "ALU32_" #op "_X: src preserved in zext", \ 10593 .u.insns_int = { \ 10594 BPF_LD_IMM64(R1, 0x0123456789acbdefULL),\ 10595 BPF_LD_IMM64(R2, 0xfedcba9876543210ULL),\ 10596 BPF_ALU64_REG(BPF_MOV, R0, R1), \ 10597 BPF_ALU32_REG(BPF_##op, R2, R1), \ 10598 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 10599 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10600 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 10601 BPF_ALU64_REG(BPF_OR, R0, R1), \ 10602 BPF_EXIT_INSN(), \ 10603 }, \ 10604 INTERNAL, \ 10605 { }, \ 10606 { { 0, 0 } }, \ 10607 } 10608 BPF_ALU32_SRC_ZEXT(MOV), 10609 BPF_ALU32_SRC_ZEXT(AND), 10610 BPF_ALU32_SRC_ZEXT(OR), 10611 BPF_ALU32_SRC_ZEXT(XOR), 10612 BPF_ALU32_SRC_ZEXT(ADD), 10613 BPF_ALU32_SRC_ZEXT(SUB), 10614 BPF_ALU32_SRC_ZEXT(MUL), 10615 BPF_ALU32_SRC_ZEXT(DIV), 10616 BPF_ALU32_SRC_ZEXT(MOD), 10617 #undef BPF_ALU32_SRC_ZEXT 10618 /* Checking that ATOMIC32 src is not zero extended in place */ 10619 #define BPF_ATOMIC32_SRC_ZEXT(op) \ 10620 { \ 10621 "ATOMIC_W_" #op ": src preserved in zext", \ 10622 .u.insns_int = { \ 10623 BPF_LD_IMM64(R0, 0x0123456789acbdefULL), \ 10624 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10625 BPF_ST_MEM(BPF_W, R10, -4, 0), \ 10626 BPF_ATOMIC_OP(BPF_W, BPF_##op, R10, R1, -4), \ 10627 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 10628 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10629 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 10630 BPF_ALU64_REG(BPF_OR, R0, R1), \ 10631 BPF_EXIT_INSN(), \ 10632 }, \ 10633 INTERNAL, \ 10634 { }, \ 10635 { { 0, 0 } }, \ 10636 .stack_depth = 8, \ 10637 } 10638 BPF_ATOMIC32_SRC_ZEXT(ADD), 10639 BPF_ATOMIC32_SRC_ZEXT(AND), 10640 BPF_ATOMIC32_SRC_ZEXT(OR), 10641 BPF_ATOMIC32_SRC_ZEXT(XOR), 10642 #undef BPF_ATOMIC32_SRC_ZEXT 10643 /* Checking that CMPXCHG32 src is not zero extended in place */ 10644 { 10645 "ATOMIC_W_CMPXCHG: src preserved in zext", 10646 .u.insns_int = { 10647 BPF_LD_IMM64(R1, 0x0123456789acbdefULL), 10648 BPF_ALU64_REG(BPF_MOV, R2, R1), 10649 BPF_ALU64_REG(BPF_MOV, R0, 0), 10650 BPF_ST_MEM(BPF_W, R10, -4, 0), 10651 BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R1, -4), 10652 BPF_ALU64_REG(BPF_SUB, R1, R2), 10653 BPF_ALU64_REG(BPF_MOV, R2, R1), 10654 BPF_ALU64_IMM(BPF_RSH, R2, 32), 10655 BPF_ALU64_REG(BPF_OR, R1, R2), 10656 BPF_ALU64_REG(BPF_MOV, R0, R1), 10657 BPF_EXIT_INSN(), 10658 }, 10659 INTERNAL, 10660 { }, 10661 { { 0, 0 } }, 10662 .stack_depth = 8, 10663 }, 10664 /* Checking that JMP32 immediate src is not zero extended in place */ 10665 #define BPF_JMP32_IMM_ZEXT(op) \ 10666 { \ 10667 "JMP32_" #op "_K: operand preserved in zext", \ 10668 .u.insns_int = { \ 10669 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\ 10670 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10671 BPF_JMP32_IMM(BPF_##op, R0, 1234, 1), \ 10672 BPF_JMP_A(0), /* Nop */ \ 10673 BPF_ALU64_REG(BPF_SUB, R0, R1), \ 10674 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10675 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 10676 BPF_ALU64_REG(BPF_OR, R0, R1), \ 10677 BPF_EXIT_INSN(), \ 10678 }, \ 10679 INTERNAL, \ 10680 { }, \ 10681 { { 0, 0 } }, \ 10682 } 10683 BPF_JMP32_IMM_ZEXT(JEQ), 10684 BPF_JMP32_IMM_ZEXT(JNE), 10685 BPF_JMP32_IMM_ZEXT(JSET), 10686 BPF_JMP32_IMM_ZEXT(JGT), 10687 BPF_JMP32_IMM_ZEXT(JGE), 10688 BPF_JMP32_IMM_ZEXT(JLT), 10689 BPF_JMP32_IMM_ZEXT(JLE), 10690 BPF_JMP32_IMM_ZEXT(JSGT), 10691 BPF_JMP32_IMM_ZEXT(JSGE), 10692 BPF_JMP32_IMM_ZEXT(JSGT), 10693 BPF_JMP32_IMM_ZEXT(JSLT), 10694 BPF_JMP32_IMM_ZEXT(JSLE), 10695 #undef BPF_JMP2_IMM_ZEXT 10696 /* Checking that JMP32 dst & src are not zero extended in place */ 10697 #define BPF_JMP32_REG_ZEXT(op) \ 10698 { \ 10699 "JMP32_" #op "_X: operands preserved in zext", \ 10700 .u.insns_int = { \ 10701 BPF_LD_IMM64(R0, 0x0123456789acbdefULL),\ 10702 BPF_LD_IMM64(R1, 0xfedcba9876543210ULL),\ 10703 BPF_ALU64_REG(BPF_MOV, R2, R0), \ 10704 BPF_ALU64_REG(BPF_MOV, R3, R1), \ 10705 BPF_JMP32_IMM(BPF_##op, R0, R1, 1), \ 10706 BPF_JMP_A(0), /* Nop */ \ 10707 BPF_ALU64_REG(BPF_SUB, R0, R2), \ 10708 BPF_ALU64_REG(BPF_SUB, R1, R3), \ 10709 BPF_ALU64_REG(BPF_OR, R0, R1), \ 10710 BPF_ALU64_REG(BPF_MOV, R1, R0), \ 10711 BPF_ALU64_IMM(BPF_RSH, R1, 32), \ 10712 BPF_ALU64_REG(BPF_OR, R0, R1), \ 10713 BPF_EXIT_INSN(), \ 10714 }, \ 10715 INTERNAL, \ 10716 { }, \ 10717 { { 0, 0 } }, \ 10718 } 10719 BPF_JMP32_REG_ZEXT(JEQ), 10720 BPF_JMP32_REG_ZEXT(JNE), 10721 BPF_JMP32_REG_ZEXT(JSET), 10722 BPF_JMP32_REG_ZEXT(JGT), 10723 BPF_JMP32_REG_ZEXT(JGE), 10724 BPF_JMP32_REG_ZEXT(JLT), 10725 BPF_JMP32_REG_ZEXT(JLE), 10726 BPF_JMP32_REG_ZEXT(JSGT), 10727 BPF_JMP32_REG_ZEXT(JSGE), 10728 BPF_JMP32_REG_ZEXT(JSGT), 10729 BPF_JMP32_REG_ZEXT(JSLT), 10730 BPF_JMP32_REG_ZEXT(JSLE), 10731 #undef BPF_JMP2_REG_ZEXT 10732 /* Exhaustive test of ALU64 shift operations */ 10733 { 10734 "ALU64_LSH_K: all shift values", 10735 { }, 10736 INTERNAL | FLAG_NO_DATA, 10737 { }, 10738 { { 0, 1 } }, 10739 .fill_helper = bpf_fill_alu_lsh_imm, 10740 }, 10741 { 10742 "ALU64_RSH_K: all shift values", 10743 { }, 10744 INTERNAL | FLAG_NO_DATA, 10745 { }, 10746 { { 0, 1 } }, 10747 .fill_helper = bpf_fill_alu_rsh_imm, 10748 }, 10749 { 10750 "ALU64_ARSH_K: all shift values", 10751 { }, 10752 INTERNAL | FLAG_NO_DATA, 10753 { }, 10754 { { 0, 1 } }, 10755 .fill_helper = bpf_fill_alu_arsh_imm, 10756 }, 10757 { 10758 "ALU64_LSH_X: all shift values", 10759 { }, 10760 INTERNAL | FLAG_NO_DATA, 10761 { }, 10762 { { 0, 1 } }, 10763 .fill_helper = bpf_fill_alu_lsh_reg, 10764 }, 10765 { 10766 "ALU64_RSH_X: all shift values", 10767 { }, 10768 INTERNAL | FLAG_NO_DATA, 10769 { }, 10770 { { 0, 1 } }, 10771 .fill_helper = bpf_fill_alu_rsh_reg, 10772 }, 10773 { 10774 "ALU64_ARSH_X: all shift values", 10775 { }, 10776 INTERNAL | FLAG_NO_DATA, 10777 { }, 10778 { { 0, 1 } }, 10779 .fill_helper = bpf_fill_alu_arsh_reg, 10780 }, 10781 /* Exhaustive test of ALU32 shift operations */ 10782 { 10783 "ALU32_LSH_K: all shift values", 10784 { }, 10785 INTERNAL | FLAG_NO_DATA, 10786 { }, 10787 { { 0, 1 } }, 10788 .fill_helper = bpf_fill_alu32_lsh_imm, 10789 }, 10790 { 10791 "ALU32_RSH_K: all shift values", 10792 { }, 10793 INTERNAL | FLAG_NO_DATA, 10794 { }, 10795 { { 0, 1 } }, 10796 .fill_helper = bpf_fill_alu32_rsh_imm, 10797 }, 10798 { 10799 "ALU32_ARSH_K: all shift values", 10800 { }, 10801 INTERNAL | FLAG_NO_DATA, 10802 { }, 10803 { { 0, 1 } }, 10804 .fill_helper = bpf_fill_alu32_arsh_imm, 10805 }, 10806 { 10807 "ALU32_LSH_X: all shift values", 10808 { }, 10809 INTERNAL | FLAG_NO_DATA, 10810 { }, 10811 { { 0, 1 } }, 10812 .fill_helper = bpf_fill_alu32_lsh_reg, 10813 }, 10814 { 10815 "ALU32_RSH_X: all shift values", 10816 { }, 10817 INTERNAL | FLAG_NO_DATA, 10818 { }, 10819 { { 0, 1 } }, 10820 .fill_helper = bpf_fill_alu32_rsh_reg, 10821 }, 10822 { 10823 "ALU32_ARSH_X: all shift values", 10824 { }, 10825 INTERNAL | FLAG_NO_DATA, 10826 { }, 10827 { { 0, 1 } }, 10828 .fill_helper = bpf_fill_alu32_arsh_reg, 10829 }, 10830 /* ALU64 immediate magnitudes */ 10831 { 10832 "ALU64_MOV_K: all immediate value magnitudes", 10833 { }, 10834 INTERNAL | FLAG_NO_DATA, 10835 { }, 10836 { { 0, 1 } }, 10837 .fill_helper = bpf_fill_alu64_mov_imm, 10838 .nr_testruns = NR_PATTERN_RUNS, 10839 }, 10840 { 10841 "ALU64_AND_K: all immediate value magnitudes", 10842 { }, 10843 INTERNAL | FLAG_NO_DATA, 10844 { }, 10845 { { 0, 1 } }, 10846 .fill_helper = bpf_fill_alu64_and_imm, 10847 .nr_testruns = NR_PATTERN_RUNS, 10848 }, 10849 { 10850 "ALU64_OR_K: all immediate value magnitudes", 10851 { }, 10852 INTERNAL | FLAG_NO_DATA, 10853 { }, 10854 { { 0, 1 } }, 10855 .fill_helper = bpf_fill_alu64_or_imm, 10856 .nr_testruns = NR_PATTERN_RUNS, 10857 }, 10858 { 10859 "ALU64_XOR_K: all immediate value magnitudes", 10860 { }, 10861 INTERNAL | FLAG_NO_DATA, 10862 { }, 10863 { { 0, 1 } }, 10864 .fill_helper = bpf_fill_alu64_xor_imm, 10865 .nr_testruns = NR_PATTERN_RUNS, 10866 }, 10867 { 10868 "ALU64_ADD_K: all immediate value magnitudes", 10869 { }, 10870 INTERNAL | FLAG_NO_DATA, 10871 { }, 10872 { { 0, 1 } }, 10873 .fill_helper = bpf_fill_alu64_add_imm, 10874 .nr_testruns = NR_PATTERN_RUNS, 10875 }, 10876 { 10877 "ALU64_SUB_K: all immediate value magnitudes", 10878 { }, 10879 INTERNAL | FLAG_NO_DATA, 10880 { }, 10881 { { 0, 1 } }, 10882 .fill_helper = bpf_fill_alu64_sub_imm, 10883 .nr_testruns = NR_PATTERN_RUNS, 10884 }, 10885 { 10886 "ALU64_MUL_K: all immediate value magnitudes", 10887 { }, 10888 INTERNAL | FLAG_NO_DATA, 10889 { }, 10890 { { 0, 1 } }, 10891 .fill_helper = bpf_fill_alu64_mul_imm, 10892 .nr_testruns = NR_PATTERN_RUNS, 10893 }, 10894 { 10895 "ALU64_DIV_K: all immediate value magnitudes", 10896 { }, 10897 INTERNAL | FLAG_NO_DATA, 10898 { }, 10899 { { 0, 1 } }, 10900 .fill_helper = bpf_fill_alu64_div_imm, 10901 .nr_testruns = NR_PATTERN_RUNS, 10902 }, 10903 { 10904 "ALU64_MOD_K: all immediate value magnitudes", 10905 { }, 10906 INTERNAL | FLAG_NO_DATA, 10907 { }, 10908 { { 0, 1 } }, 10909 .fill_helper = bpf_fill_alu64_mod_imm, 10910 .nr_testruns = NR_PATTERN_RUNS, 10911 }, 10912 /* ALU32 immediate magnitudes */ 10913 { 10914 "ALU32_MOV_K: all immediate value magnitudes", 10915 { }, 10916 INTERNAL | FLAG_NO_DATA, 10917 { }, 10918 { { 0, 1 } }, 10919 .fill_helper = bpf_fill_alu32_mov_imm, 10920 .nr_testruns = NR_PATTERN_RUNS, 10921 }, 10922 { 10923 "ALU32_AND_K: all immediate value magnitudes", 10924 { }, 10925 INTERNAL | FLAG_NO_DATA, 10926 { }, 10927 { { 0, 1 } }, 10928 .fill_helper = bpf_fill_alu32_and_imm, 10929 .nr_testruns = NR_PATTERN_RUNS, 10930 }, 10931 { 10932 "ALU32_OR_K: all immediate value magnitudes", 10933 { }, 10934 INTERNAL | FLAG_NO_DATA, 10935 { }, 10936 { { 0, 1 } }, 10937 .fill_helper = bpf_fill_alu32_or_imm, 10938 .nr_testruns = NR_PATTERN_RUNS, 10939 }, 10940 { 10941 "ALU32_XOR_K: all immediate value magnitudes", 10942 { }, 10943 INTERNAL | FLAG_NO_DATA, 10944 { }, 10945 { { 0, 1 } }, 10946 .fill_helper = bpf_fill_alu32_xor_imm, 10947 .nr_testruns = NR_PATTERN_RUNS, 10948 }, 10949 { 10950 "ALU32_ADD_K: all immediate value magnitudes", 10951 { }, 10952 INTERNAL | FLAG_NO_DATA, 10953 { }, 10954 { { 0, 1 } }, 10955 .fill_helper = bpf_fill_alu32_add_imm, 10956 .nr_testruns = NR_PATTERN_RUNS, 10957 }, 10958 { 10959 "ALU32_SUB_K: all immediate value magnitudes", 10960 { }, 10961 INTERNAL | FLAG_NO_DATA, 10962 { }, 10963 { { 0, 1 } }, 10964 .fill_helper = bpf_fill_alu32_sub_imm, 10965 .nr_testruns = NR_PATTERN_RUNS, 10966 }, 10967 { 10968 "ALU32_MUL_K: all immediate value magnitudes", 10969 { }, 10970 INTERNAL | FLAG_NO_DATA, 10971 { }, 10972 { { 0, 1 } }, 10973 .fill_helper = bpf_fill_alu32_mul_imm, 10974 .nr_testruns = NR_PATTERN_RUNS, 10975 }, 10976 { 10977 "ALU32_DIV_K: all immediate value magnitudes", 10978 { }, 10979 INTERNAL | FLAG_NO_DATA, 10980 { }, 10981 { { 0, 1 } }, 10982 .fill_helper = bpf_fill_alu32_div_imm, 10983 .nr_testruns = NR_PATTERN_RUNS, 10984 }, 10985 { 10986 "ALU32_MOD_K: all immediate value magnitudes", 10987 { }, 10988 INTERNAL | FLAG_NO_DATA, 10989 { }, 10990 { { 0, 1 } }, 10991 .fill_helper = bpf_fill_alu32_mod_imm, 10992 .nr_testruns = NR_PATTERN_RUNS, 10993 }, 10994 /* ALU64 register magnitudes */ 10995 { 10996 "ALU64_MOV_X: all register value magnitudes", 10997 { }, 10998 INTERNAL | FLAG_NO_DATA, 10999 { }, 11000 { { 0, 1 } }, 11001 .fill_helper = bpf_fill_alu64_mov_reg, 11002 .nr_testruns = NR_PATTERN_RUNS, 11003 }, 11004 { 11005 "ALU64_AND_X: all register value magnitudes", 11006 { }, 11007 INTERNAL | FLAG_NO_DATA, 11008 { }, 11009 { { 0, 1 } }, 11010 .fill_helper = bpf_fill_alu64_and_reg, 11011 .nr_testruns = NR_PATTERN_RUNS, 11012 }, 11013 { 11014 "ALU64_OR_X: all register value magnitudes", 11015 { }, 11016 INTERNAL | FLAG_NO_DATA, 11017 { }, 11018 { { 0, 1 } }, 11019 .fill_helper = bpf_fill_alu64_or_reg, 11020 .nr_testruns = NR_PATTERN_RUNS, 11021 }, 11022 { 11023 "ALU64_XOR_X: all register value magnitudes", 11024 { }, 11025 INTERNAL | FLAG_NO_DATA, 11026 { }, 11027 { { 0, 1 } }, 11028 .fill_helper = bpf_fill_alu64_xor_reg, 11029 .nr_testruns = NR_PATTERN_RUNS, 11030 }, 11031 { 11032 "ALU64_ADD_X: all register value magnitudes", 11033 { }, 11034 INTERNAL | FLAG_NO_DATA, 11035 { }, 11036 { { 0, 1 } }, 11037 .fill_helper = bpf_fill_alu64_add_reg, 11038 .nr_testruns = NR_PATTERN_RUNS, 11039 }, 11040 { 11041 "ALU64_SUB_X: all register value magnitudes", 11042 { }, 11043 INTERNAL | FLAG_NO_DATA, 11044 { }, 11045 { { 0, 1 } }, 11046 .fill_helper = bpf_fill_alu64_sub_reg, 11047 .nr_testruns = NR_PATTERN_RUNS, 11048 }, 11049 { 11050 "ALU64_MUL_X: all register value magnitudes", 11051 { }, 11052 INTERNAL | FLAG_NO_DATA, 11053 { }, 11054 { { 0, 1 } }, 11055 .fill_helper = bpf_fill_alu64_mul_reg, 11056 .nr_testruns = NR_PATTERN_RUNS, 11057 }, 11058 { 11059 "ALU64_DIV_X: all register value magnitudes", 11060 { }, 11061 INTERNAL | FLAG_NO_DATA, 11062 { }, 11063 { { 0, 1 } }, 11064 .fill_helper = bpf_fill_alu64_div_reg, 11065 .nr_testruns = NR_PATTERN_RUNS, 11066 }, 11067 { 11068 "ALU64_MOD_X: all register value magnitudes", 11069 { }, 11070 INTERNAL | FLAG_NO_DATA, 11071 { }, 11072 { { 0, 1 } }, 11073 .fill_helper = bpf_fill_alu64_mod_reg, 11074 .nr_testruns = NR_PATTERN_RUNS, 11075 }, 11076 /* ALU32 register magnitudes */ 11077 { 11078 "ALU32_MOV_X: all register value magnitudes", 11079 { }, 11080 INTERNAL | FLAG_NO_DATA, 11081 { }, 11082 { { 0, 1 } }, 11083 .fill_helper = bpf_fill_alu32_mov_reg, 11084 .nr_testruns = NR_PATTERN_RUNS, 11085 }, 11086 { 11087 "ALU32_AND_X: all register value magnitudes", 11088 { }, 11089 INTERNAL | FLAG_NO_DATA, 11090 { }, 11091 { { 0, 1 } }, 11092 .fill_helper = bpf_fill_alu32_and_reg, 11093 .nr_testruns = NR_PATTERN_RUNS, 11094 }, 11095 { 11096 "ALU32_OR_X: all register value magnitudes", 11097 { }, 11098 INTERNAL | FLAG_NO_DATA, 11099 { }, 11100 { { 0, 1 } }, 11101 .fill_helper = bpf_fill_alu32_or_reg, 11102 .nr_testruns = NR_PATTERN_RUNS, 11103 }, 11104 { 11105 "ALU32_XOR_X: all register value magnitudes", 11106 { }, 11107 INTERNAL | FLAG_NO_DATA, 11108 { }, 11109 { { 0, 1 } }, 11110 .fill_helper = bpf_fill_alu32_xor_reg, 11111 .nr_testruns = NR_PATTERN_RUNS, 11112 }, 11113 { 11114 "ALU32_ADD_X: all register value magnitudes", 11115 { }, 11116 INTERNAL | FLAG_NO_DATA, 11117 { }, 11118 { { 0, 1 } }, 11119 .fill_helper = bpf_fill_alu32_add_reg, 11120 .nr_testruns = NR_PATTERN_RUNS, 11121 }, 11122 { 11123 "ALU32_SUB_X: all register value magnitudes", 11124 { }, 11125 INTERNAL | FLAG_NO_DATA, 11126 { }, 11127 { { 0, 1 } }, 11128 .fill_helper = bpf_fill_alu32_sub_reg, 11129 .nr_testruns = NR_PATTERN_RUNS, 11130 }, 11131 { 11132 "ALU32_MUL_X: all register value magnitudes", 11133 { }, 11134 INTERNAL | FLAG_NO_DATA, 11135 { }, 11136 { { 0, 1 } }, 11137 .fill_helper = bpf_fill_alu32_mul_reg, 11138 .nr_testruns = NR_PATTERN_RUNS, 11139 }, 11140 { 11141 "ALU32_DIV_X: all register value magnitudes", 11142 { }, 11143 INTERNAL | FLAG_NO_DATA, 11144 { }, 11145 { { 0, 1 } }, 11146 .fill_helper = bpf_fill_alu32_div_reg, 11147 .nr_testruns = NR_PATTERN_RUNS, 11148 }, 11149 { 11150 "ALU32_MOD_X: all register value magnitudes", 11151 { }, 11152 INTERNAL | FLAG_NO_DATA, 11153 { }, 11154 { { 0, 1 } }, 11155 .fill_helper = bpf_fill_alu32_mod_reg, 11156 .nr_testruns = NR_PATTERN_RUNS, 11157 }, 11158 /* LD_IMM64 immediate magnitudes */ 11159 { 11160 "LD_IMM64: all immediate value magnitudes", 11161 { }, 11162 INTERNAL | FLAG_NO_DATA, 11163 { }, 11164 { { 0, 1 } }, 11165 .fill_helper = bpf_fill_ld_imm64, 11166 }, 11167 /* 64-bit ATOMIC magnitudes */ 11168 { 11169 "ATOMIC_DW_ADD: all operand magnitudes", 11170 { }, 11171 INTERNAL | FLAG_NO_DATA, 11172 { }, 11173 { { 0, 1 } }, 11174 .fill_helper = bpf_fill_atomic64_add, 11175 .stack_depth = 8, 11176 .nr_testruns = NR_PATTERN_RUNS, 11177 }, 11178 { 11179 "ATOMIC_DW_AND: all operand magnitudes", 11180 { }, 11181 INTERNAL | FLAG_NO_DATA, 11182 { }, 11183 { { 0, 1 } }, 11184 .fill_helper = bpf_fill_atomic64_and, 11185 .stack_depth = 8, 11186 .nr_testruns = NR_PATTERN_RUNS, 11187 }, 11188 { 11189 "ATOMIC_DW_OR: all operand magnitudes", 11190 { }, 11191 INTERNAL | FLAG_NO_DATA, 11192 { }, 11193 { { 0, 1 } }, 11194 .fill_helper = bpf_fill_atomic64_or, 11195 .stack_depth = 8, 11196 .nr_testruns = NR_PATTERN_RUNS, 11197 }, 11198 { 11199 "ATOMIC_DW_XOR: all operand magnitudes", 11200 { }, 11201 INTERNAL | FLAG_NO_DATA, 11202 { }, 11203 { { 0, 1 } }, 11204 .fill_helper = bpf_fill_atomic64_xor, 11205 .stack_depth = 8, 11206 .nr_testruns = NR_PATTERN_RUNS, 11207 }, 11208 { 11209 "ATOMIC_DW_ADD_FETCH: all operand magnitudes", 11210 { }, 11211 INTERNAL | FLAG_NO_DATA, 11212 { }, 11213 { { 0, 1 } }, 11214 .fill_helper = bpf_fill_atomic64_add_fetch, 11215 .stack_depth = 8, 11216 .nr_testruns = NR_PATTERN_RUNS, 11217 }, 11218 { 11219 "ATOMIC_DW_AND_FETCH: all operand magnitudes", 11220 { }, 11221 INTERNAL | FLAG_NO_DATA, 11222 { }, 11223 { { 0, 1 } }, 11224 .fill_helper = bpf_fill_atomic64_and_fetch, 11225 .stack_depth = 8, 11226 .nr_testruns = NR_PATTERN_RUNS, 11227 }, 11228 { 11229 "ATOMIC_DW_OR_FETCH: all operand magnitudes", 11230 { }, 11231 INTERNAL | FLAG_NO_DATA, 11232 { }, 11233 { { 0, 1 } }, 11234 .fill_helper = bpf_fill_atomic64_or_fetch, 11235 .stack_depth = 8, 11236 .nr_testruns = NR_PATTERN_RUNS, 11237 }, 11238 { 11239 "ATOMIC_DW_XOR_FETCH: all operand magnitudes", 11240 { }, 11241 INTERNAL | FLAG_NO_DATA, 11242 { }, 11243 { { 0, 1 } }, 11244 .fill_helper = bpf_fill_atomic64_xor_fetch, 11245 .stack_depth = 8, 11246 .nr_testruns = NR_PATTERN_RUNS, 11247 }, 11248 { 11249 "ATOMIC_DW_XCHG: all operand magnitudes", 11250 { }, 11251 INTERNAL | FLAG_NO_DATA, 11252 { }, 11253 { { 0, 1 } }, 11254 .fill_helper = bpf_fill_atomic64_xchg, 11255 .stack_depth = 8, 11256 .nr_testruns = NR_PATTERN_RUNS, 11257 }, 11258 { 11259 "ATOMIC_DW_CMPXCHG: all operand magnitudes", 11260 { }, 11261 INTERNAL | FLAG_NO_DATA, 11262 { }, 11263 { { 0, 1 } }, 11264 .fill_helper = bpf_fill_cmpxchg64, 11265 .stack_depth = 8, 11266 .nr_testruns = NR_PATTERN_RUNS, 11267 }, 11268 /* 64-bit atomic magnitudes */ 11269 { 11270 "ATOMIC_W_ADD: all operand magnitudes", 11271 { }, 11272 INTERNAL | FLAG_NO_DATA, 11273 { }, 11274 { { 0, 1 } }, 11275 .fill_helper = bpf_fill_atomic32_add, 11276 .stack_depth = 8, 11277 .nr_testruns = NR_PATTERN_RUNS, 11278 }, 11279 { 11280 "ATOMIC_W_AND: all operand magnitudes", 11281 { }, 11282 INTERNAL | FLAG_NO_DATA, 11283 { }, 11284 { { 0, 1 } }, 11285 .fill_helper = bpf_fill_atomic32_and, 11286 .stack_depth = 8, 11287 .nr_testruns = NR_PATTERN_RUNS, 11288 }, 11289 { 11290 "ATOMIC_W_OR: all operand magnitudes", 11291 { }, 11292 INTERNAL | FLAG_NO_DATA, 11293 { }, 11294 { { 0, 1 } }, 11295 .fill_helper = bpf_fill_atomic32_or, 11296 .stack_depth = 8, 11297 .nr_testruns = NR_PATTERN_RUNS, 11298 }, 11299 { 11300 "ATOMIC_W_XOR: all operand magnitudes", 11301 { }, 11302 INTERNAL | FLAG_NO_DATA, 11303 { }, 11304 { { 0, 1 } }, 11305 .fill_helper = bpf_fill_atomic32_xor, 11306 .stack_depth = 8, 11307 .nr_testruns = NR_PATTERN_RUNS, 11308 }, 11309 { 11310 "ATOMIC_W_ADD_FETCH: all operand magnitudes", 11311 { }, 11312 INTERNAL | FLAG_NO_DATA, 11313 { }, 11314 { { 0, 1 } }, 11315 .fill_helper = bpf_fill_atomic32_add_fetch, 11316 .stack_depth = 8, 11317 .nr_testruns = NR_PATTERN_RUNS, 11318 }, 11319 { 11320 "ATOMIC_W_AND_FETCH: all operand magnitudes", 11321 { }, 11322 INTERNAL | FLAG_NO_DATA, 11323 { }, 11324 { { 0, 1 } }, 11325 .fill_helper = bpf_fill_atomic32_and_fetch, 11326 .stack_depth = 8, 11327 .nr_testruns = NR_PATTERN_RUNS, 11328 }, 11329 { 11330 "ATOMIC_W_OR_FETCH: all operand magnitudes", 11331 { }, 11332 INTERNAL | FLAG_NO_DATA, 11333 { }, 11334 { { 0, 1 } }, 11335 .fill_helper = bpf_fill_atomic32_or_fetch, 11336 .stack_depth = 8, 11337 .nr_testruns = NR_PATTERN_RUNS, 11338 }, 11339 { 11340 "ATOMIC_W_XOR_FETCH: all operand magnitudes", 11341 { }, 11342 INTERNAL | FLAG_NO_DATA, 11343 { }, 11344 { { 0, 1 } }, 11345 .fill_helper = bpf_fill_atomic32_xor_fetch, 11346 .stack_depth = 8, 11347 .nr_testruns = NR_PATTERN_RUNS, 11348 }, 11349 { 11350 "ATOMIC_W_XCHG: all operand magnitudes", 11351 { }, 11352 INTERNAL | FLAG_NO_DATA, 11353 { }, 11354 { { 0, 1 } }, 11355 .fill_helper = bpf_fill_atomic32_xchg, 11356 .stack_depth = 8, 11357 .nr_testruns = NR_PATTERN_RUNS, 11358 }, 11359 { 11360 "ATOMIC_W_CMPXCHG: all operand magnitudes", 11361 { }, 11362 INTERNAL | FLAG_NO_DATA, 11363 { }, 11364 { { 0, 1 } }, 11365 .fill_helper = bpf_fill_cmpxchg32, 11366 .stack_depth = 8, 11367 .nr_testruns = NR_PATTERN_RUNS, 11368 }, 11369 /* JMP immediate magnitudes */ 11370 { 11371 "JMP_JSET_K: all immediate value magnitudes", 11372 { }, 11373 INTERNAL | FLAG_NO_DATA, 11374 { }, 11375 { { 0, 1 } }, 11376 .fill_helper = bpf_fill_jmp_jset_imm, 11377 .nr_testruns = NR_PATTERN_RUNS, 11378 }, 11379 { 11380 "JMP_JEQ_K: all immediate value magnitudes", 11381 { }, 11382 INTERNAL | FLAG_NO_DATA, 11383 { }, 11384 { { 0, 1 } }, 11385 .fill_helper = bpf_fill_jmp_jeq_imm, 11386 .nr_testruns = NR_PATTERN_RUNS, 11387 }, 11388 { 11389 "JMP_JNE_K: all immediate value magnitudes", 11390 { }, 11391 INTERNAL | FLAG_NO_DATA, 11392 { }, 11393 { { 0, 1 } }, 11394 .fill_helper = bpf_fill_jmp_jne_imm, 11395 .nr_testruns = NR_PATTERN_RUNS, 11396 }, 11397 { 11398 "JMP_JGT_K: all immediate value magnitudes", 11399 { }, 11400 INTERNAL | FLAG_NO_DATA, 11401 { }, 11402 { { 0, 1 } }, 11403 .fill_helper = bpf_fill_jmp_jgt_imm, 11404 .nr_testruns = NR_PATTERN_RUNS, 11405 }, 11406 { 11407 "JMP_JGE_K: all immediate value magnitudes", 11408 { }, 11409 INTERNAL | FLAG_NO_DATA, 11410 { }, 11411 { { 0, 1 } }, 11412 .fill_helper = bpf_fill_jmp_jge_imm, 11413 .nr_testruns = NR_PATTERN_RUNS, 11414 }, 11415 { 11416 "JMP_JLT_K: all immediate value magnitudes", 11417 { }, 11418 INTERNAL | FLAG_NO_DATA, 11419 { }, 11420 { { 0, 1 } }, 11421 .fill_helper = bpf_fill_jmp_jlt_imm, 11422 .nr_testruns = NR_PATTERN_RUNS, 11423 }, 11424 { 11425 "JMP_JLE_K: all immediate value magnitudes", 11426 { }, 11427 INTERNAL | FLAG_NO_DATA, 11428 { }, 11429 { { 0, 1 } }, 11430 .fill_helper = bpf_fill_jmp_jle_imm, 11431 .nr_testruns = NR_PATTERN_RUNS, 11432 }, 11433 { 11434 "JMP_JSGT_K: all immediate value magnitudes", 11435 { }, 11436 INTERNAL | FLAG_NO_DATA, 11437 { }, 11438 { { 0, 1 } }, 11439 .fill_helper = bpf_fill_jmp_jsgt_imm, 11440 .nr_testruns = NR_PATTERN_RUNS, 11441 }, 11442 { 11443 "JMP_JSGE_K: all immediate value magnitudes", 11444 { }, 11445 INTERNAL | FLAG_NO_DATA, 11446 { }, 11447 { { 0, 1 } }, 11448 .fill_helper = bpf_fill_jmp_jsge_imm, 11449 .nr_testruns = NR_PATTERN_RUNS, 11450 }, 11451 { 11452 "JMP_JSLT_K: all immediate value magnitudes", 11453 { }, 11454 INTERNAL | FLAG_NO_DATA, 11455 { }, 11456 { { 0, 1 } }, 11457 .fill_helper = bpf_fill_jmp_jslt_imm, 11458 .nr_testruns = NR_PATTERN_RUNS, 11459 }, 11460 { 11461 "JMP_JSLE_K: all immediate value magnitudes", 11462 { }, 11463 INTERNAL | FLAG_NO_DATA, 11464 { }, 11465 { { 0, 1 } }, 11466 .fill_helper = bpf_fill_jmp_jsle_imm, 11467 .nr_testruns = NR_PATTERN_RUNS, 11468 }, 11469 /* JMP register magnitudes */ 11470 { 11471 "JMP_JSET_X: all register value magnitudes", 11472 { }, 11473 INTERNAL | FLAG_NO_DATA, 11474 { }, 11475 { { 0, 1 } }, 11476 .fill_helper = bpf_fill_jmp_jset_reg, 11477 .nr_testruns = NR_PATTERN_RUNS, 11478 }, 11479 { 11480 "JMP_JEQ_X: all register value magnitudes", 11481 { }, 11482 INTERNAL | FLAG_NO_DATA, 11483 { }, 11484 { { 0, 1 } }, 11485 .fill_helper = bpf_fill_jmp_jeq_reg, 11486 .nr_testruns = NR_PATTERN_RUNS, 11487 }, 11488 { 11489 "JMP_JNE_X: all register value magnitudes", 11490 { }, 11491 INTERNAL | FLAG_NO_DATA, 11492 { }, 11493 { { 0, 1 } }, 11494 .fill_helper = bpf_fill_jmp_jne_reg, 11495 .nr_testruns = NR_PATTERN_RUNS, 11496 }, 11497 { 11498 "JMP_JGT_X: all register value magnitudes", 11499 { }, 11500 INTERNAL | FLAG_NO_DATA, 11501 { }, 11502 { { 0, 1 } }, 11503 .fill_helper = bpf_fill_jmp_jgt_reg, 11504 .nr_testruns = NR_PATTERN_RUNS, 11505 }, 11506 { 11507 "JMP_JGE_X: all register value magnitudes", 11508 { }, 11509 INTERNAL | FLAG_NO_DATA, 11510 { }, 11511 { { 0, 1 } }, 11512 .fill_helper = bpf_fill_jmp_jge_reg, 11513 .nr_testruns = NR_PATTERN_RUNS, 11514 }, 11515 { 11516 "JMP_JLT_X: all register value magnitudes", 11517 { }, 11518 INTERNAL | FLAG_NO_DATA, 11519 { }, 11520 { { 0, 1 } }, 11521 .fill_helper = bpf_fill_jmp_jlt_reg, 11522 .nr_testruns = NR_PATTERN_RUNS, 11523 }, 11524 { 11525 "JMP_JLE_X: all register value magnitudes", 11526 { }, 11527 INTERNAL | FLAG_NO_DATA, 11528 { }, 11529 { { 0, 1 } }, 11530 .fill_helper = bpf_fill_jmp_jle_reg, 11531 .nr_testruns = NR_PATTERN_RUNS, 11532 }, 11533 { 11534 "JMP_JSGT_X: all register value magnitudes", 11535 { }, 11536 INTERNAL | FLAG_NO_DATA, 11537 { }, 11538 { { 0, 1 } }, 11539 .fill_helper = bpf_fill_jmp_jsgt_reg, 11540 .nr_testruns = NR_PATTERN_RUNS, 11541 }, 11542 { 11543 "JMP_JSGE_X: all register value magnitudes", 11544 { }, 11545 INTERNAL | FLAG_NO_DATA, 11546 { }, 11547 { { 0, 1 } }, 11548 .fill_helper = bpf_fill_jmp_jsge_reg, 11549 .nr_testruns = NR_PATTERN_RUNS, 11550 }, 11551 { 11552 "JMP_JSLT_X: all register value magnitudes", 11553 { }, 11554 INTERNAL | FLAG_NO_DATA, 11555 { }, 11556 { { 0, 1 } }, 11557 .fill_helper = bpf_fill_jmp_jslt_reg, 11558 .nr_testruns = NR_PATTERN_RUNS, 11559 }, 11560 { 11561 "JMP_JSLE_X: all register value magnitudes", 11562 { }, 11563 INTERNAL | FLAG_NO_DATA, 11564 { }, 11565 { { 0, 1 } }, 11566 .fill_helper = bpf_fill_jmp_jsle_reg, 11567 .nr_testruns = NR_PATTERN_RUNS, 11568 }, 11569 /* JMP32 immediate magnitudes */ 11570 { 11571 "JMP32_JSET_K: all immediate value magnitudes", 11572 { }, 11573 INTERNAL | FLAG_NO_DATA, 11574 { }, 11575 { { 0, 1 } }, 11576 .fill_helper = bpf_fill_jmp32_jset_imm, 11577 .nr_testruns = NR_PATTERN_RUNS, 11578 }, 11579 { 11580 "JMP32_JEQ_K: all immediate value magnitudes", 11581 { }, 11582 INTERNAL | FLAG_NO_DATA, 11583 { }, 11584 { { 0, 1 } }, 11585 .fill_helper = bpf_fill_jmp32_jeq_imm, 11586 .nr_testruns = NR_PATTERN_RUNS, 11587 }, 11588 { 11589 "JMP32_JNE_K: all immediate value magnitudes", 11590 { }, 11591 INTERNAL | FLAG_NO_DATA, 11592 { }, 11593 { { 0, 1 } }, 11594 .fill_helper = bpf_fill_jmp32_jne_imm, 11595 .nr_testruns = NR_PATTERN_RUNS, 11596 }, 11597 { 11598 "JMP32_JGT_K: all immediate value magnitudes", 11599 { }, 11600 INTERNAL | FLAG_NO_DATA, 11601 { }, 11602 { { 0, 1 } }, 11603 .fill_helper = bpf_fill_jmp32_jgt_imm, 11604 .nr_testruns = NR_PATTERN_RUNS, 11605 }, 11606 { 11607 "JMP32_JGE_K: all immediate value magnitudes", 11608 { }, 11609 INTERNAL | FLAG_NO_DATA, 11610 { }, 11611 { { 0, 1 } }, 11612 .fill_helper = bpf_fill_jmp32_jge_imm, 11613 .nr_testruns = NR_PATTERN_RUNS, 11614 }, 11615 { 11616 "JMP32_JLT_K: all immediate value magnitudes", 11617 { }, 11618 INTERNAL | FLAG_NO_DATA, 11619 { }, 11620 { { 0, 1 } }, 11621 .fill_helper = bpf_fill_jmp32_jlt_imm, 11622 .nr_testruns = NR_PATTERN_RUNS, 11623 }, 11624 { 11625 "JMP32_JLE_K: all immediate value magnitudes", 11626 { }, 11627 INTERNAL | FLAG_NO_DATA, 11628 { }, 11629 { { 0, 1 } }, 11630 .fill_helper = bpf_fill_jmp32_jle_imm, 11631 .nr_testruns = NR_PATTERN_RUNS, 11632 }, 11633 { 11634 "JMP32_JSGT_K: all immediate value magnitudes", 11635 { }, 11636 INTERNAL | FLAG_NO_DATA, 11637 { }, 11638 { { 0, 1 } }, 11639 .fill_helper = bpf_fill_jmp32_jsgt_imm, 11640 .nr_testruns = NR_PATTERN_RUNS, 11641 }, 11642 { 11643 "JMP32_JSGE_K: all immediate value magnitudes", 11644 { }, 11645 INTERNAL | FLAG_NO_DATA, 11646 { }, 11647 { { 0, 1 } }, 11648 .fill_helper = bpf_fill_jmp32_jsge_imm, 11649 .nr_testruns = NR_PATTERN_RUNS, 11650 }, 11651 { 11652 "JMP32_JSLT_K: all immediate value magnitudes", 11653 { }, 11654 INTERNAL | FLAG_NO_DATA, 11655 { }, 11656 { { 0, 1 } }, 11657 .fill_helper = bpf_fill_jmp32_jslt_imm, 11658 .nr_testruns = NR_PATTERN_RUNS, 11659 }, 11660 { 11661 "JMP32_JSLE_K: all immediate value magnitudes", 11662 { }, 11663 INTERNAL | FLAG_NO_DATA, 11664 { }, 11665 { { 0, 1 } }, 11666 .fill_helper = bpf_fill_jmp32_jsle_imm, 11667 .nr_testruns = NR_PATTERN_RUNS, 11668 }, 11669 /* JMP32 register magnitudes */ 11670 { 11671 "JMP32_JSET_X: all register value magnitudes", 11672 { }, 11673 INTERNAL | FLAG_NO_DATA, 11674 { }, 11675 { { 0, 1 } }, 11676 .fill_helper = bpf_fill_jmp32_jset_reg, 11677 .nr_testruns = NR_PATTERN_RUNS, 11678 }, 11679 { 11680 "JMP32_JEQ_X: all register value magnitudes", 11681 { }, 11682 INTERNAL | FLAG_NO_DATA, 11683 { }, 11684 { { 0, 1 } }, 11685 .fill_helper = bpf_fill_jmp32_jeq_reg, 11686 .nr_testruns = NR_PATTERN_RUNS, 11687 }, 11688 { 11689 "JMP32_JNE_X: all register value magnitudes", 11690 { }, 11691 INTERNAL | FLAG_NO_DATA, 11692 { }, 11693 { { 0, 1 } }, 11694 .fill_helper = bpf_fill_jmp32_jne_reg, 11695 .nr_testruns = NR_PATTERN_RUNS, 11696 }, 11697 { 11698 "JMP32_JGT_X: all register value magnitudes", 11699 { }, 11700 INTERNAL | FLAG_NO_DATA, 11701 { }, 11702 { { 0, 1 } }, 11703 .fill_helper = bpf_fill_jmp32_jgt_reg, 11704 .nr_testruns = NR_PATTERN_RUNS, 11705 }, 11706 { 11707 "JMP32_JGE_X: all register value magnitudes", 11708 { }, 11709 INTERNAL | FLAG_NO_DATA, 11710 { }, 11711 { { 0, 1 } }, 11712 .fill_helper = bpf_fill_jmp32_jge_reg, 11713 .nr_testruns = NR_PATTERN_RUNS, 11714 }, 11715 { 11716 "JMP32_JLT_X: all register value magnitudes", 11717 { }, 11718 INTERNAL | FLAG_NO_DATA, 11719 { }, 11720 { { 0, 1 } }, 11721 .fill_helper = bpf_fill_jmp32_jlt_reg, 11722 .nr_testruns = NR_PATTERN_RUNS, 11723 }, 11724 { 11725 "JMP32_JLE_X: all register value magnitudes", 11726 { }, 11727 INTERNAL | FLAG_NO_DATA, 11728 { }, 11729 { { 0, 1 } }, 11730 .fill_helper = bpf_fill_jmp32_jle_reg, 11731 .nr_testruns = NR_PATTERN_RUNS, 11732 }, 11733 { 11734 "JMP32_JSGT_X: all register value magnitudes", 11735 { }, 11736 INTERNAL | FLAG_NO_DATA, 11737 { }, 11738 { { 0, 1 } }, 11739 .fill_helper = bpf_fill_jmp32_jsgt_reg, 11740 .nr_testruns = NR_PATTERN_RUNS, 11741 }, 11742 { 11743 "JMP32_JSGE_X: all register value magnitudes", 11744 { }, 11745 INTERNAL | FLAG_NO_DATA, 11746 { }, 11747 { { 0, 1 } }, 11748 .fill_helper = bpf_fill_jmp32_jsge_reg, 11749 .nr_testruns = NR_PATTERN_RUNS, 11750 }, 11751 { 11752 "JMP32_JSLT_X: all register value magnitudes", 11753 { }, 11754 INTERNAL | FLAG_NO_DATA, 11755 { }, 11756 { { 0, 1 } }, 11757 .fill_helper = bpf_fill_jmp32_jslt_reg, 11758 .nr_testruns = NR_PATTERN_RUNS, 11759 }, 11760 { 11761 "JMP32_JSLE_X: all register value magnitudes", 11762 { }, 11763 INTERNAL | FLAG_NO_DATA, 11764 { }, 11765 { { 0, 1 } }, 11766 .fill_helper = bpf_fill_jmp32_jsle_reg, 11767 .nr_testruns = NR_PATTERN_RUNS, 11768 }, 11769 /* Conditional jumps with constant decision */ 11770 { 11771 "JMP_JSET_K: imm = 0 -> never taken", 11772 .u.insns_int = { 11773 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11774 BPF_JMP_IMM(BPF_JSET, R1, 0, 1), 11775 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11776 BPF_EXIT_INSN(), 11777 }, 11778 INTERNAL | FLAG_NO_DATA, 11779 { }, 11780 { { 0, 0 } }, 11781 }, 11782 { 11783 "JMP_JLT_K: imm = 0 -> never taken", 11784 .u.insns_int = { 11785 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11786 BPF_JMP_IMM(BPF_JLT, R1, 0, 1), 11787 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11788 BPF_EXIT_INSN(), 11789 }, 11790 INTERNAL | FLAG_NO_DATA, 11791 { }, 11792 { { 0, 0 } }, 11793 }, 11794 { 11795 "JMP_JGE_K: imm = 0 -> always taken", 11796 .u.insns_int = { 11797 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11798 BPF_JMP_IMM(BPF_JGE, R1, 0, 1), 11799 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11800 BPF_EXIT_INSN(), 11801 }, 11802 INTERNAL | FLAG_NO_DATA, 11803 { }, 11804 { { 0, 1 } }, 11805 }, 11806 { 11807 "JMP_JGT_K: imm = 0xffffffff -> never taken", 11808 .u.insns_int = { 11809 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11810 BPF_JMP_IMM(BPF_JGT, R1, U32_MAX, 1), 11811 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11812 BPF_EXIT_INSN(), 11813 }, 11814 INTERNAL | FLAG_NO_DATA, 11815 { }, 11816 { { 0, 0 } }, 11817 }, 11818 { 11819 "JMP_JLE_K: imm = 0xffffffff -> always taken", 11820 .u.insns_int = { 11821 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11822 BPF_JMP_IMM(BPF_JLE, R1, U32_MAX, 1), 11823 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11824 BPF_EXIT_INSN(), 11825 }, 11826 INTERNAL | FLAG_NO_DATA, 11827 { }, 11828 { { 0, 1 } }, 11829 }, 11830 { 11831 "JMP32_JSGT_K: imm = 0x7fffffff -> never taken", 11832 .u.insns_int = { 11833 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11834 BPF_JMP32_IMM(BPF_JSGT, R1, S32_MAX, 1), 11835 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11836 BPF_EXIT_INSN(), 11837 }, 11838 INTERNAL | FLAG_NO_DATA, 11839 { }, 11840 { { 0, 0 } }, 11841 }, 11842 { 11843 "JMP32_JSGE_K: imm = -0x80000000 -> always taken", 11844 .u.insns_int = { 11845 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11846 BPF_JMP32_IMM(BPF_JSGE, R1, S32_MIN, 1), 11847 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11848 BPF_EXIT_INSN(), 11849 }, 11850 INTERNAL | FLAG_NO_DATA, 11851 { }, 11852 { { 0, 1 } }, 11853 }, 11854 { 11855 "JMP32_JSLT_K: imm = -0x80000000 -> never taken", 11856 .u.insns_int = { 11857 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11858 BPF_JMP32_IMM(BPF_JSLT, R1, S32_MIN, 1), 11859 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11860 BPF_EXIT_INSN(), 11861 }, 11862 INTERNAL | FLAG_NO_DATA, 11863 { }, 11864 { { 0, 0 } }, 11865 }, 11866 { 11867 "JMP32_JSLE_K: imm = 0x7fffffff -> always taken", 11868 .u.insns_int = { 11869 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11870 BPF_JMP32_IMM(BPF_JSLE, R1, S32_MAX, 1), 11871 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11872 BPF_EXIT_INSN(), 11873 }, 11874 INTERNAL | FLAG_NO_DATA, 11875 { }, 11876 { { 0, 1 } }, 11877 }, 11878 { 11879 "JMP_JEQ_X: dst = src -> always taken", 11880 .u.insns_int = { 11881 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11882 BPF_JMP_REG(BPF_JEQ, R1, R1, 1), 11883 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11884 BPF_EXIT_INSN(), 11885 }, 11886 INTERNAL | FLAG_NO_DATA, 11887 { }, 11888 { { 0, 1 } }, 11889 }, 11890 { 11891 "JMP_JGE_X: dst = src -> always taken", 11892 .u.insns_int = { 11893 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11894 BPF_JMP_REG(BPF_JGE, R1, R1, 1), 11895 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11896 BPF_EXIT_INSN(), 11897 }, 11898 INTERNAL | FLAG_NO_DATA, 11899 { }, 11900 { { 0, 1 } }, 11901 }, 11902 { 11903 "JMP_JLE_X: dst = src -> always taken", 11904 .u.insns_int = { 11905 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11906 BPF_JMP_REG(BPF_JLE, R1, R1, 1), 11907 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11908 BPF_EXIT_INSN(), 11909 }, 11910 INTERNAL | FLAG_NO_DATA, 11911 { }, 11912 { { 0, 1 } }, 11913 }, 11914 { 11915 "JMP_JSGE_X: dst = src -> always taken", 11916 .u.insns_int = { 11917 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11918 BPF_JMP_REG(BPF_JSGE, R1, R1, 1), 11919 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11920 BPF_EXIT_INSN(), 11921 }, 11922 INTERNAL | FLAG_NO_DATA, 11923 { }, 11924 { { 0, 1 } }, 11925 }, 11926 { 11927 "JMP_JSLE_X: dst = src -> always taken", 11928 .u.insns_int = { 11929 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11930 BPF_JMP_REG(BPF_JSLE, R1, R1, 1), 11931 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11932 BPF_EXIT_INSN(), 11933 }, 11934 INTERNAL | FLAG_NO_DATA, 11935 { }, 11936 { { 0, 1 } }, 11937 }, 11938 { 11939 "JMP_JNE_X: dst = src -> never taken", 11940 .u.insns_int = { 11941 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11942 BPF_JMP_REG(BPF_JNE, R1, R1, 1), 11943 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11944 BPF_EXIT_INSN(), 11945 }, 11946 INTERNAL | FLAG_NO_DATA, 11947 { }, 11948 { { 0, 0 } }, 11949 }, 11950 { 11951 "JMP_JGT_X: dst = src -> never taken", 11952 .u.insns_int = { 11953 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11954 BPF_JMP_REG(BPF_JGT, R1, R1, 1), 11955 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11956 BPF_EXIT_INSN(), 11957 }, 11958 INTERNAL | FLAG_NO_DATA, 11959 { }, 11960 { { 0, 0 } }, 11961 }, 11962 { 11963 "JMP_JLT_X: dst = src -> never taken", 11964 .u.insns_int = { 11965 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11966 BPF_JMP_REG(BPF_JLT, R1, R1, 1), 11967 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11968 BPF_EXIT_INSN(), 11969 }, 11970 INTERNAL | FLAG_NO_DATA, 11971 { }, 11972 { { 0, 0 } }, 11973 }, 11974 { 11975 "JMP_JSGT_X: dst = src -> never taken", 11976 .u.insns_int = { 11977 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11978 BPF_JMP_REG(BPF_JSGT, R1, R1, 1), 11979 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11980 BPF_EXIT_INSN(), 11981 }, 11982 INTERNAL | FLAG_NO_DATA, 11983 { }, 11984 { { 0, 0 } }, 11985 }, 11986 { 11987 "JMP_JSLT_X: dst = src -> never taken", 11988 .u.insns_int = { 11989 BPF_ALU64_IMM(BPF_MOV, R0, 1), 11990 BPF_JMP_REG(BPF_JSLT, R1, R1, 1), 11991 BPF_ALU64_IMM(BPF_MOV, R0, 0), 11992 BPF_EXIT_INSN(), 11993 }, 11994 INTERNAL | FLAG_NO_DATA, 11995 { }, 11996 { { 0, 0 } }, 11997 }, 11998 /* Short relative jumps */ 11999 { 12000 "Short relative jump: offset=0", 12001 .u.insns_int = { 12002 BPF_ALU64_IMM(BPF_MOV, R0, 0), 12003 BPF_JMP_IMM(BPF_JEQ, R0, 0, 0), 12004 BPF_EXIT_INSN(), 12005 BPF_ALU32_IMM(BPF_MOV, R0, -1), 12006 }, 12007 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 12008 { }, 12009 { { 0, 0 } }, 12010 }, 12011 { 12012 "Short relative jump: offset=1", 12013 .u.insns_int = { 12014 BPF_ALU64_IMM(BPF_MOV, R0, 0), 12015 BPF_JMP_IMM(BPF_JEQ, R0, 0, 1), 12016 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12017 BPF_EXIT_INSN(), 12018 BPF_ALU32_IMM(BPF_MOV, R0, -1), 12019 }, 12020 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 12021 { }, 12022 { { 0, 0 } }, 12023 }, 12024 { 12025 "Short relative jump: offset=2", 12026 .u.insns_int = { 12027 BPF_ALU64_IMM(BPF_MOV, R0, 0), 12028 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2), 12029 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12030 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12031 BPF_EXIT_INSN(), 12032 BPF_ALU32_IMM(BPF_MOV, R0, -1), 12033 }, 12034 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 12035 { }, 12036 { { 0, 0 } }, 12037 }, 12038 { 12039 "Short relative jump: offset=3", 12040 .u.insns_int = { 12041 BPF_ALU64_IMM(BPF_MOV, R0, 0), 12042 BPF_JMP_IMM(BPF_JEQ, R0, 0, 3), 12043 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12044 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12045 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12046 BPF_EXIT_INSN(), 12047 BPF_ALU32_IMM(BPF_MOV, R0, -1), 12048 }, 12049 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 12050 { }, 12051 { { 0, 0 } }, 12052 }, 12053 { 12054 "Short relative jump: offset=4", 12055 .u.insns_int = { 12056 BPF_ALU64_IMM(BPF_MOV, R0, 0), 12057 BPF_JMP_IMM(BPF_JEQ, R0, 0, 4), 12058 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12059 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12060 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12061 BPF_ALU32_IMM(BPF_ADD, R0, 1), 12062 BPF_EXIT_INSN(), 12063 BPF_ALU32_IMM(BPF_MOV, R0, -1), 12064 }, 12065 INTERNAL | FLAG_NO_DATA | FLAG_VERIFIER_ZEXT, 12066 { }, 12067 { { 0, 0 } }, 12068 }, 12069 /* Conditional branch conversions */ 12070 { 12071 "Long conditional jump: taken at runtime", 12072 { }, 12073 INTERNAL | FLAG_NO_DATA, 12074 { }, 12075 { { 0, 1 } }, 12076 .fill_helper = bpf_fill_max_jmp_taken, 12077 }, 12078 { 12079 "Long conditional jump: not taken at runtime", 12080 { }, 12081 INTERNAL | FLAG_NO_DATA, 12082 { }, 12083 { { 0, 2 } }, 12084 .fill_helper = bpf_fill_max_jmp_not_taken, 12085 }, 12086 { 12087 "Long conditional jump: always taken, known at JIT time", 12088 { }, 12089 INTERNAL | FLAG_NO_DATA, 12090 { }, 12091 { { 0, 1 } }, 12092 .fill_helper = bpf_fill_max_jmp_always_taken, 12093 }, 12094 { 12095 "Long conditional jump: never taken, known at JIT time", 12096 { }, 12097 INTERNAL | FLAG_NO_DATA, 12098 { }, 12099 { { 0, 2 } }, 12100 .fill_helper = bpf_fill_max_jmp_never_taken, 12101 }, 12102 /* Staggered jump sequences, immediate */ 12103 { 12104 "Staggered jumps: JMP_JA", 12105 { }, 12106 INTERNAL | FLAG_NO_DATA, 12107 { }, 12108 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12109 .fill_helper = bpf_fill_staggered_ja, 12110 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12111 }, 12112 { 12113 "Staggered jumps: JMP_JEQ_K", 12114 { }, 12115 INTERNAL | FLAG_NO_DATA, 12116 { }, 12117 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12118 .fill_helper = bpf_fill_staggered_jeq_imm, 12119 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12120 }, 12121 { 12122 "Staggered jumps: JMP_JNE_K", 12123 { }, 12124 INTERNAL | FLAG_NO_DATA, 12125 { }, 12126 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12127 .fill_helper = bpf_fill_staggered_jne_imm, 12128 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12129 }, 12130 { 12131 "Staggered jumps: JMP_JSET_K", 12132 { }, 12133 INTERNAL | FLAG_NO_DATA, 12134 { }, 12135 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12136 .fill_helper = bpf_fill_staggered_jset_imm, 12137 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12138 }, 12139 { 12140 "Staggered jumps: JMP_JGT_K", 12141 { }, 12142 INTERNAL | FLAG_NO_DATA, 12143 { }, 12144 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12145 .fill_helper = bpf_fill_staggered_jgt_imm, 12146 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12147 }, 12148 { 12149 "Staggered jumps: JMP_JGE_K", 12150 { }, 12151 INTERNAL | FLAG_NO_DATA, 12152 { }, 12153 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12154 .fill_helper = bpf_fill_staggered_jge_imm, 12155 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12156 }, 12157 { 12158 "Staggered jumps: JMP_JLT_K", 12159 { }, 12160 INTERNAL | FLAG_NO_DATA, 12161 { }, 12162 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12163 .fill_helper = bpf_fill_staggered_jlt_imm, 12164 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12165 }, 12166 { 12167 "Staggered jumps: JMP_JLE_K", 12168 { }, 12169 INTERNAL | FLAG_NO_DATA, 12170 { }, 12171 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12172 .fill_helper = bpf_fill_staggered_jle_imm, 12173 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12174 }, 12175 { 12176 "Staggered jumps: JMP_JSGT_K", 12177 { }, 12178 INTERNAL | FLAG_NO_DATA, 12179 { }, 12180 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12181 .fill_helper = bpf_fill_staggered_jsgt_imm, 12182 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12183 }, 12184 { 12185 "Staggered jumps: JMP_JSGE_K", 12186 { }, 12187 INTERNAL | FLAG_NO_DATA, 12188 { }, 12189 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12190 .fill_helper = bpf_fill_staggered_jsge_imm, 12191 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12192 }, 12193 { 12194 "Staggered jumps: JMP_JSLT_K", 12195 { }, 12196 INTERNAL | FLAG_NO_DATA, 12197 { }, 12198 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12199 .fill_helper = bpf_fill_staggered_jslt_imm, 12200 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12201 }, 12202 { 12203 "Staggered jumps: JMP_JSLE_K", 12204 { }, 12205 INTERNAL | FLAG_NO_DATA, 12206 { }, 12207 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12208 .fill_helper = bpf_fill_staggered_jsle_imm, 12209 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12210 }, 12211 /* Staggered jump sequences, register */ 12212 { 12213 "Staggered jumps: JMP_JEQ_X", 12214 { }, 12215 INTERNAL | FLAG_NO_DATA, 12216 { }, 12217 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12218 .fill_helper = bpf_fill_staggered_jeq_reg, 12219 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12220 }, 12221 { 12222 "Staggered jumps: JMP_JNE_X", 12223 { }, 12224 INTERNAL | FLAG_NO_DATA, 12225 { }, 12226 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12227 .fill_helper = bpf_fill_staggered_jne_reg, 12228 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12229 }, 12230 { 12231 "Staggered jumps: JMP_JSET_X", 12232 { }, 12233 INTERNAL | FLAG_NO_DATA, 12234 { }, 12235 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12236 .fill_helper = bpf_fill_staggered_jset_reg, 12237 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12238 }, 12239 { 12240 "Staggered jumps: JMP_JGT_X", 12241 { }, 12242 INTERNAL | FLAG_NO_DATA, 12243 { }, 12244 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12245 .fill_helper = bpf_fill_staggered_jgt_reg, 12246 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12247 }, 12248 { 12249 "Staggered jumps: JMP_JGE_X", 12250 { }, 12251 INTERNAL | FLAG_NO_DATA, 12252 { }, 12253 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12254 .fill_helper = bpf_fill_staggered_jge_reg, 12255 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12256 }, 12257 { 12258 "Staggered jumps: JMP_JLT_X", 12259 { }, 12260 INTERNAL | FLAG_NO_DATA, 12261 { }, 12262 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12263 .fill_helper = bpf_fill_staggered_jlt_reg, 12264 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12265 }, 12266 { 12267 "Staggered jumps: JMP_JLE_X", 12268 { }, 12269 INTERNAL | FLAG_NO_DATA, 12270 { }, 12271 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12272 .fill_helper = bpf_fill_staggered_jle_reg, 12273 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12274 }, 12275 { 12276 "Staggered jumps: JMP_JSGT_X", 12277 { }, 12278 INTERNAL | FLAG_NO_DATA, 12279 { }, 12280 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12281 .fill_helper = bpf_fill_staggered_jsgt_reg, 12282 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12283 }, 12284 { 12285 "Staggered jumps: JMP_JSGE_X", 12286 { }, 12287 INTERNAL | FLAG_NO_DATA, 12288 { }, 12289 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12290 .fill_helper = bpf_fill_staggered_jsge_reg, 12291 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12292 }, 12293 { 12294 "Staggered jumps: JMP_JSLT_X", 12295 { }, 12296 INTERNAL | FLAG_NO_DATA, 12297 { }, 12298 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12299 .fill_helper = bpf_fill_staggered_jslt_reg, 12300 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12301 }, 12302 { 12303 "Staggered jumps: JMP_JSLE_X", 12304 { }, 12305 INTERNAL | FLAG_NO_DATA, 12306 { }, 12307 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12308 .fill_helper = bpf_fill_staggered_jsle_reg, 12309 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12310 }, 12311 /* Staggered jump sequences, JMP32 immediate */ 12312 { 12313 "Staggered jumps: JMP32_JEQ_K", 12314 { }, 12315 INTERNAL | FLAG_NO_DATA, 12316 { }, 12317 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12318 .fill_helper = bpf_fill_staggered_jeq32_imm, 12319 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12320 }, 12321 { 12322 "Staggered jumps: JMP32_JNE_K", 12323 { }, 12324 INTERNAL | FLAG_NO_DATA, 12325 { }, 12326 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12327 .fill_helper = bpf_fill_staggered_jne32_imm, 12328 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12329 }, 12330 { 12331 "Staggered jumps: JMP32_JSET_K", 12332 { }, 12333 INTERNAL | FLAG_NO_DATA, 12334 { }, 12335 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12336 .fill_helper = bpf_fill_staggered_jset32_imm, 12337 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12338 }, 12339 { 12340 "Staggered jumps: JMP32_JGT_K", 12341 { }, 12342 INTERNAL | FLAG_NO_DATA, 12343 { }, 12344 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12345 .fill_helper = bpf_fill_staggered_jgt32_imm, 12346 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12347 }, 12348 { 12349 "Staggered jumps: JMP32_JGE_K", 12350 { }, 12351 INTERNAL | FLAG_NO_DATA, 12352 { }, 12353 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12354 .fill_helper = bpf_fill_staggered_jge32_imm, 12355 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12356 }, 12357 { 12358 "Staggered jumps: JMP32_JLT_K", 12359 { }, 12360 INTERNAL | FLAG_NO_DATA, 12361 { }, 12362 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12363 .fill_helper = bpf_fill_staggered_jlt32_imm, 12364 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12365 }, 12366 { 12367 "Staggered jumps: JMP32_JLE_K", 12368 { }, 12369 INTERNAL | FLAG_NO_DATA, 12370 { }, 12371 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12372 .fill_helper = bpf_fill_staggered_jle32_imm, 12373 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12374 }, 12375 { 12376 "Staggered jumps: JMP32_JSGT_K", 12377 { }, 12378 INTERNAL | FLAG_NO_DATA, 12379 { }, 12380 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12381 .fill_helper = bpf_fill_staggered_jsgt32_imm, 12382 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12383 }, 12384 { 12385 "Staggered jumps: JMP32_JSGE_K", 12386 { }, 12387 INTERNAL | FLAG_NO_DATA, 12388 { }, 12389 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12390 .fill_helper = bpf_fill_staggered_jsge32_imm, 12391 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12392 }, 12393 { 12394 "Staggered jumps: JMP32_JSLT_K", 12395 { }, 12396 INTERNAL | FLAG_NO_DATA, 12397 { }, 12398 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12399 .fill_helper = bpf_fill_staggered_jslt32_imm, 12400 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12401 }, 12402 { 12403 "Staggered jumps: JMP32_JSLE_K", 12404 { }, 12405 INTERNAL | FLAG_NO_DATA, 12406 { }, 12407 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12408 .fill_helper = bpf_fill_staggered_jsle32_imm, 12409 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12410 }, 12411 /* Staggered jump sequences, JMP32 register */ 12412 { 12413 "Staggered jumps: JMP32_JEQ_X", 12414 { }, 12415 INTERNAL | FLAG_NO_DATA, 12416 { }, 12417 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12418 .fill_helper = bpf_fill_staggered_jeq32_reg, 12419 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12420 }, 12421 { 12422 "Staggered jumps: JMP32_JNE_X", 12423 { }, 12424 INTERNAL | FLAG_NO_DATA, 12425 { }, 12426 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12427 .fill_helper = bpf_fill_staggered_jne32_reg, 12428 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12429 }, 12430 { 12431 "Staggered jumps: JMP32_JSET_X", 12432 { }, 12433 INTERNAL | FLAG_NO_DATA, 12434 { }, 12435 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12436 .fill_helper = bpf_fill_staggered_jset32_reg, 12437 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12438 }, 12439 { 12440 "Staggered jumps: JMP32_JGT_X", 12441 { }, 12442 INTERNAL | FLAG_NO_DATA, 12443 { }, 12444 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12445 .fill_helper = bpf_fill_staggered_jgt32_reg, 12446 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12447 }, 12448 { 12449 "Staggered jumps: JMP32_JGE_X", 12450 { }, 12451 INTERNAL | FLAG_NO_DATA, 12452 { }, 12453 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12454 .fill_helper = bpf_fill_staggered_jge32_reg, 12455 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12456 }, 12457 { 12458 "Staggered jumps: JMP32_JLT_X", 12459 { }, 12460 INTERNAL | FLAG_NO_DATA, 12461 { }, 12462 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12463 .fill_helper = bpf_fill_staggered_jlt32_reg, 12464 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12465 }, 12466 { 12467 "Staggered jumps: JMP32_JLE_X", 12468 { }, 12469 INTERNAL | FLAG_NO_DATA, 12470 { }, 12471 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12472 .fill_helper = bpf_fill_staggered_jle32_reg, 12473 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12474 }, 12475 { 12476 "Staggered jumps: JMP32_JSGT_X", 12477 { }, 12478 INTERNAL | FLAG_NO_DATA, 12479 { }, 12480 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12481 .fill_helper = bpf_fill_staggered_jsgt32_reg, 12482 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12483 }, 12484 { 12485 "Staggered jumps: JMP32_JSGE_X", 12486 { }, 12487 INTERNAL | FLAG_NO_DATA, 12488 { }, 12489 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12490 .fill_helper = bpf_fill_staggered_jsge32_reg, 12491 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12492 }, 12493 { 12494 "Staggered jumps: JMP32_JSLT_X", 12495 { }, 12496 INTERNAL | FLAG_NO_DATA, 12497 { }, 12498 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12499 .fill_helper = bpf_fill_staggered_jslt32_reg, 12500 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12501 }, 12502 { 12503 "Staggered jumps: JMP32_JSLE_X", 12504 { }, 12505 INTERNAL | FLAG_NO_DATA, 12506 { }, 12507 { { 0, MAX_STAGGERED_JMP_SIZE + 1 } }, 12508 .fill_helper = bpf_fill_staggered_jsle32_reg, 12509 .nr_testruns = NR_STAGGERED_JMP_RUNS, 12510 }, 12511 }; 12512 12513 static struct net_device dev; 12514 12515 static struct sk_buff *populate_skb(char *buf, int size) 12516 { 12517 struct sk_buff *skb; 12518 12519 if (size >= MAX_DATA) 12520 return NULL; 12521 12522 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 12523 if (!skb) 12524 return NULL; 12525 12526 __skb_put_data(skb, buf, size); 12527 12528 /* Initialize a fake skb with test pattern. */ 12529 skb_reset_mac_header(skb); 12530 skb->protocol = htons(ETH_P_IP); 12531 skb->pkt_type = SKB_TYPE; 12532 skb->mark = SKB_MARK; 12533 skb->hash = SKB_HASH; 12534 skb->queue_mapping = SKB_QUEUE_MAP; 12535 skb->vlan_tci = SKB_VLAN_TCI; 12536 skb->vlan_present = SKB_VLAN_PRESENT; 12537 skb->vlan_proto = htons(ETH_P_IP); 12538 dev_net_set(&dev, &init_net); 12539 skb->dev = &dev; 12540 skb->dev->ifindex = SKB_DEV_IFINDEX; 12541 skb->dev->type = SKB_DEV_TYPE; 12542 skb_set_network_header(skb, min(size, ETH_HLEN)); 12543 12544 return skb; 12545 } 12546 12547 static void *generate_test_data(struct bpf_test *test, int sub) 12548 { 12549 struct sk_buff *skb; 12550 struct page *page; 12551 12552 if (test->aux & FLAG_NO_DATA) 12553 return NULL; 12554 12555 /* Test case expects an skb, so populate one. Various 12556 * subtests generate skbs of different sizes based on 12557 * the same data. 12558 */ 12559 skb = populate_skb(test->data, test->test[sub].data_size); 12560 if (!skb) 12561 return NULL; 12562 12563 if (test->aux & FLAG_SKB_FRAG) { 12564 /* 12565 * when the test requires a fragmented skb, add a 12566 * single fragment to the skb, filled with 12567 * test->frag_data. 12568 */ 12569 void *ptr; 12570 12571 page = alloc_page(GFP_KERNEL); 12572 12573 if (!page) 12574 goto err_kfree_skb; 12575 12576 ptr = kmap(page); 12577 if (!ptr) 12578 goto err_free_page; 12579 memcpy(ptr, test->frag_data, MAX_DATA); 12580 kunmap(page); 12581 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA); 12582 } 12583 12584 return skb; 12585 12586 err_free_page: 12587 __free_page(page); 12588 err_kfree_skb: 12589 kfree_skb(skb); 12590 return NULL; 12591 } 12592 12593 static void release_test_data(const struct bpf_test *test, void *data) 12594 { 12595 if (test->aux & FLAG_NO_DATA) 12596 return; 12597 12598 kfree_skb(data); 12599 } 12600 12601 static int filter_length(int which) 12602 { 12603 struct sock_filter *fp; 12604 int len; 12605 12606 if (tests[which].fill_helper) 12607 return tests[which].u.ptr.len; 12608 12609 fp = tests[which].u.insns; 12610 for (len = MAX_INSNS - 1; len > 0; --len) 12611 if (fp[len].code != 0 || fp[len].k != 0) 12612 break; 12613 12614 return len + 1; 12615 } 12616 12617 static void *filter_pointer(int which) 12618 { 12619 if (tests[which].fill_helper) 12620 return tests[which].u.ptr.insns; 12621 else 12622 return tests[which].u.insns; 12623 } 12624 12625 static struct bpf_prog *generate_filter(int which, int *err) 12626 { 12627 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 12628 unsigned int flen = filter_length(which); 12629 void *fptr = filter_pointer(which); 12630 struct sock_fprog_kern fprog; 12631 struct bpf_prog *fp; 12632 12633 switch (test_type) { 12634 case CLASSIC: 12635 fprog.filter = fptr; 12636 fprog.len = flen; 12637 12638 *err = bpf_prog_create(&fp, &fprog); 12639 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 12640 if (*err == tests[which].expected_errcode) { 12641 pr_cont("PASS\n"); 12642 /* Verifier rejected filter as expected. */ 12643 *err = 0; 12644 return NULL; 12645 } else { 12646 pr_cont("UNEXPECTED_PASS\n"); 12647 /* Verifier didn't reject the test that's 12648 * bad enough, just return! 12649 */ 12650 *err = -EINVAL; 12651 return NULL; 12652 } 12653 } 12654 if (*err) { 12655 pr_cont("FAIL to prog_create err=%d len=%d\n", 12656 *err, fprog.len); 12657 return NULL; 12658 } 12659 break; 12660 12661 case INTERNAL: 12662 fp = bpf_prog_alloc(bpf_prog_size(flen), 0); 12663 if (fp == NULL) { 12664 pr_cont("UNEXPECTED_FAIL no memory left\n"); 12665 *err = -ENOMEM; 12666 return NULL; 12667 } 12668 12669 fp->len = flen; 12670 /* Type doesn't really matter here as long as it's not unspec. */ 12671 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 12672 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn)); 12673 fp->aux->stack_depth = tests[which].stack_depth; 12674 fp->aux->verifier_zext = !!(tests[which].aux & 12675 FLAG_VERIFIER_ZEXT); 12676 12677 /* We cannot error here as we don't need type compatibility 12678 * checks. 12679 */ 12680 fp = bpf_prog_select_runtime(fp, err); 12681 if (*err) { 12682 pr_cont("FAIL to select_runtime err=%d\n", *err); 12683 return NULL; 12684 } 12685 break; 12686 } 12687 12688 *err = 0; 12689 return fp; 12690 } 12691 12692 static void release_filter(struct bpf_prog *fp, int which) 12693 { 12694 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 12695 12696 switch (test_type) { 12697 case CLASSIC: 12698 bpf_prog_destroy(fp); 12699 break; 12700 case INTERNAL: 12701 bpf_prog_free(fp); 12702 break; 12703 } 12704 } 12705 12706 static int __run_one(const struct bpf_prog *fp, const void *data, 12707 int runs, u64 *duration) 12708 { 12709 u64 start, finish; 12710 int ret = 0, i; 12711 12712 migrate_disable(); 12713 start = ktime_get_ns(); 12714 12715 for (i = 0; i < runs; i++) 12716 ret = bpf_prog_run(fp, data); 12717 12718 finish = ktime_get_ns(); 12719 migrate_enable(); 12720 12721 *duration = finish - start; 12722 do_div(*duration, runs); 12723 12724 return ret; 12725 } 12726 12727 static int run_one(const struct bpf_prog *fp, struct bpf_test *test) 12728 { 12729 int err_cnt = 0, i, runs = MAX_TESTRUNS; 12730 12731 if (test->nr_testruns) 12732 runs = min(test->nr_testruns, MAX_TESTRUNS); 12733 12734 for (i = 0; i < MAX_SUBTESTS; i++) { 12735 void *data; 12736 u64 duration; 12737 u32 ret; 12738 12739 /* 12740 * NOTE: Several sub-tests may be present, in which case 12741 * a zero {data_size, result} tuple indicates the end of 12742 * the sub-test array. The first test is always run, 12743 * even if both data_size and result happen to be zero. 12744 */ 12745 if (i > 0 && 12746 test->test[i].data_size == 0 && 12747 test->test[i].result == 0) 12748 break; 12749 12750 data = generate_test_data(test, i); 12751 if (!data && !(test->aux & FLAG_NO_DATA)) { 12752 pr_cont("data generation failed "); 12753 err_cnt++; 12754 break; 12755 } 12756 ret = __run_one(fp, data, runs, &duration); 12757 release_test_data(test, data); 12758 12759 if (ret == test->test[i].result) { 12760 pr_cont("%lld ", duration); 12761 } else { 12762 pr_cont("ret %d != %d ", ret, 12763 test->test[i].result); 12764 err_cnt++; 12765 } 12766 } 12767 12768 return err_cnt; 12769 } 12770 12771 static char test_name[64]; 12772 module_param_string(test_name, test_name, sizeof(test_name), 0); 12773 12774 static int test_id = -1; 12775 module_param(test_id, int, 0); 12776 12777 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 }; 12778 module_param_array(test_range, int, NULL, 0); 12779 12780 static __init int find_test_index(const char *test_name) 12781 { 12782 int i; 12783 12784 for (i = 0; i < ARRAY_SIZE(tests); i++) { 12785 if (!strcmp(tests[i].descr, test_name)) 12786 return i; 12787 } 12788 return -1; 12789 } 12790 12791 static __init int prepare_bpf_tests(void) 12792 { 12793 if (test_id >= 0) { 12794 /* 12795 * if a test_id was specified, use test_range to 12796 * cover only that test. 12797 */ 12798 if (test_id >= ARRAY_SIZE(tests)) { 12799 pr_err("test_bpf: invalid test_id specified.\n"); 12800 return -EINVAL; 12801 } 12802 12803 test_range[0] = test_id; 12804 test_range[1] = test_id; 12805 } else if (*test_name) { 12806 /* 12807 * if a test_name was specified, find it and setup 12808 * test_range to cover only that test. 12809 */ 12810 int idx = find_test_index(test_name); 12811 12812 if (idx < 0) { 12813 pr_err("test_bpf: no test named '%s' found.\n", 12814 test_name); 12815 return -EINVAL; 12816 } 12817 test_range[0] = idx; 12818 test_range[1] = idx; 12819 } else { 12820 /* 12821 * check that the supplied test_range is valid. 12822 */ 12823 if (test_range[0] >= ARRAY_SIZE(tests) || 12824 test_range[1] >= ARRAY_SIZE(tests) || 12825 test_range[0] < 0 || test_range[1] < 0) { 12826 pr_err("test_bpf: test_range is out of bound.\n"); 12827 return -EINVAL; 12828 } 12829 12830 if (test_range[1] < test_range[0]) { 12831 pr_err("test_bpf: test_range is ending before it starts.\n"); 12832 return -EINVAL; 12833 } 12834 } 12835 12836 return 0; 12837 } 12838 12839 static __init void destroy_bpf_tests(void) 12840 { 12841 } 12842 12843 static bool exclude_test(int test_id) 12844 { 12845 return test_id < test_range[0] || test_id > test_range[1]; 12846 } 12847 12848 static __init struct sk_buff *build_test_skb(void) 12849 { 12850 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN; 12851 struct sk_buff *skb[2]; 12852 struct page *page[2]; 12853 int i, data_size = 8; 12854 12855 for (i = 0; i < 2; i++) { 12856 page[i] = alloc_page(GFP_KERNEL); 12857 if (!page[i]) { 12858 if (i == 0) 12859 goto err_page0; 12860 else 12861 goto err_page1; 12862 } 12863 12864 /* this will set skb[i]->head_frag */ 12865 skb[i] = dev_alloc_skb(headroom + data_size); 12866 if (!skb[i]) { 12867 if (i == 0) 12868 goto err_skb0; 12869 else 12870 goto err_skb1; 12871 } 12872 12873 skb_reserve(skb[i], headroom); 12874 skb_put(skb[i], data_size); 12875 skb[i]->protocol = htons(ETH_P_IP); 12876 skb_reset_network_header(skb[i]); 12877 skb_set_mac_header(skb[i], -ETH_HLEN); 12878 12879 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64); 12880 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1 12881 } 12882 12883 /* setup shinfo */ 12884 skb_shinfo(skb[0])->gso_size = 1448; 12885 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4; 12886 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY; 12887 skb_shinfo(skb[0])->gso_segs = 0; 12888 skb_shinfo(skb[0])->frag_list = skb[1]; 12889 skb_shinfo(skb[0])->hwtstamps.hwtstamp = 1000; 12890 12891 /* adjust skb[0]'s len */ 12892 skb[0]->len += skb[1]->len; 12893 skb[0]->data_len += skb[1]->data_len; 12894 skb[0]->truesize += skb[1]->truesize; 12895 12896 return skb[0]; 12897 12898 err_skb1: 12899 __free_page(page[1]); 12900 err_page1: 12901 kfree_skb(skb[0]); 12902 err_skb0: 12903 __free_page(page[0]); 12904 err_page0: 12905 return NULL; 12906 } 12907 12908 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void) 12909 { 12910 unsigned int alloc_size = 2000; 12911 unsigned int headroom = 102, doffset = 72, data_size = 1308; 12912 struct sk_buff *skb[2]; 12913 int i; 12914 12915 /* skbs linked in a frag_list, both with linear data, with head_frag=0 12916 * (data allocated by kmalloc), both have tcp data of 1308 bytes 12917 * (total payload is 2616 bytes). 12918 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom. 12919 */ 12920 for (i = 0; i < 2; i++) { 12921 skb[i] = alloc_skb(alloc_size, GFP_KERNEL); 12922 if (!skb[i]) { 12923 if (i == 0) 12924 goto err_skb0; 12925 else 12926 goto err_skb1; 12927 } 12928 12929 skb[i]->protocol = htons(ETH_P_IPV6); 12930 skb_reserve(skb[i], headroom); 12931 skb_put(skb[i], doffset + data_size); 12932 skb_reset_network_header(skb[i]); 12933 if (i == 0) 12934 skb_reset_mac_header(skb[i]); 12935 else 12936 skb_set_mac_header(skb[i], -ETH_HLEN); 12937 __skb_pull(skb[i], doffset); 12938 } 12939 12940 /* setup shinfo. 12941 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a 12942 * reduced gso_size. 12943 */ 12944 skb_shinfo(skb[0])->gso_size = 1288; 12945 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY; 12946 skb_shinfo(skb[0])->gso_segs = 0; 12947 skb_shinfo(skb[0])->frag_list = skb[1]; 12948 12949 /* adjust skb[0]'s len */ 12950 skb[0]->len += skb[1]->len; 12951 skb[0]->data_len += skb[1]->len; 12952 skb[0]->truesize += skb[1]->truesize; 12953 12954 return skb[0]; 12955 12956 err_skb1: 12957 kfree_skb(skb[0]); 12958 err_skb0: 12959 return NULL; 12960 } 12961 12962 struct skb_segment_test { 12963 const char *descr; 12964 struct sk_buff *(*build_skb)(void); 12965 netdev_features_t features; 12966 }; 12967 12968 static struct skb_segment_test skb_segment_tests[] __initconst = { 12969 { 12970 .descr = "gso_with_rx_frags", 12971 .build_skb = build_test_skb, 12972 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM | 12973 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM 12974 }, 12975 { 12976 .descr = "gso_linear_no_head_frag", 12977 .build_skb = build_test_skb_linear_no_head_frag, 12978 .features = NETIF_F_SG | NETIF_F_FRAGLIST | 12979 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO | 12980 NETIF_F_LLTX_BIT | NETIF_F_GRO | 12981 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM | 12982 NETIF_F_HW_VLAN_STAG_TX_BIT 12983 } 12984 }; 12985 12986 static __init int test_skb_segment_single(const struct skb_segment_test *test) 12987 { 12988 struct sk_buff *skb, *segs; 12989 int ret = -1; 12990 12991 skb = test->build_skb(); 12992 if (!skb) { 12993 pr_info("%s: failed to build_test_skb", __func__); 12994 goto done; 12995 } 12996 12997 segs = skb_segment(skb, test->features); 12998 if (!IS_ERR(segs)) { 12999 kfree_skb_list(segs); 13000 ret = 0; 13001 } 13002 kfree_skb(skb); 13003 done: 13004 return ret; 13005 } 13006 13007 static __init int test_skb_segment(void) 13008 { 13009 int i, err_cnt = 0, pass_cnt = 0; 13010 13011 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) { 13012 const struct skb_segment_test *test = &skb_segment_tests[i]; 13013 13014 pr_info("#%d %s ", i, test->descr); 13015 13016 if (test_skb_segment_single(test)) { 13017 pr_cont("FAIL\n"); 13018 err_cnt++; 13019 } else { 13020 pr_cont("PASS\n"); 13021 pass_cnt++; 13022 } 13023 } 13024 13025 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__, 13026 pass_cnt, err_cnt); 13027 return err_cnt ? -EINVAL : 0; 13028 } 13029 13030 static __init int test_bpf(void) 13031 { 13032 int i, err_cnt = 0, pass_cnt = 0; 13033 int jit_cnt = 0, run_cnt = 0; 13034 13035 for (i = 0; i < ARRAY_SIZE(tests); i++) { 13036 struct bpf_prog *fp; 13037 int err; 13038 13039 cond_resched(); 13040 if (exclude_test(i)) 13041 continue; 13042 13043 pr_info("#%d %s ", i, tests[i].descr); 13044 13045 if (tests[i].fill_helper && 13046 tests[i].fill_helper(&tests[i]) < 0) { 13047 pr_cont("FAIL to prog_fill\n"); 13048 continue; 13049 } 13050 13051 fp = generate_filter(i, &err); 13052 13053 if (tests[i].fill_helper) { 13054 kfree(tests[i].u.ptr.insns); 13055 tests[i].u.ptr.insns = NULL; 13056 } 13057 13058 if (fp == NULL) { 13059 if (err == 0) { 13060 pass_cnt++; 13061 continue; 13062 } 13063 err_cnt++; 13064 continue; 13065 } 13066 13067 pr_cont("jited:%u ", fp->jited); 13068 13069 run_cnt++; 13070 if (fp->jited) 13071 jit_cnt++; 13072 13073 err = run_one(fp, &tests[i]); 13074 release_filter(fp, i); 13075 13076 if (err) { 13077 pr_cont("FAIL (%d times)\n", err); 13078 err_cnt++; 13079 } else { 13080 pr_cont("PASS\n"); 13081 pass_cnt++; 13082 } 13083 } 13084 13085 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 13086 pass_cnt, err_cnt, jit_cnt, run_cnt); 13087 13088 return err_cnt ? -EINVAL : 0; 13089 } 13090 13091 struct tail_call_test { 13092 const char *descr; 13093 struct bpf_insn insns[MAX_INSNS]; 13094 int flags; 13095 int result; 13096 int stack_depth; 13097 }; 13098 13099 /* Flags that can be passed to tail call test cases */ 13100 #define FLAG_NEED_STATE BIT(0) 13101 #define FLAG_RESULT_IN_STATE BIT(1) 13102 13103 /* 13104 * Magic marker used in test snippets for tail calls below. 13105 * BPF_LD/MOV to R2 and R2 with this immediate value is replaced 13106 * with the proper values by the test runner. 13107 */ 13108 #define TAIL_CALL_MARKER 0x7a11ca11 13109 13110 /* Special offset to indicate a NULL call target */ 13111 #define TAIL_CALL_NULL 0x7fff 13112 13113 /* Special offset to indicate an out-of-range index */ 13114 #define TAIL_CALL_INVALID 0x7ffe 13115 13116 #define TAIL_CALL(offset) \ 13117 BPF_LD_IMM64(R2, TAIL_CALL_MARKER), \ 13118 BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \ 13119 offset, TAIL_CALL_MARKER), \ 13120 BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0) 13121 13122 /* 13123 * A test function to be called from a BPF program, clobbering a lot of 13124 * CPU registers in the process. A JITed BPF program calling this function 13125 * must save and restore any caller-saved registers it uses for internal 13126 * state, for example the current tail call count. 13127 */ 13128 BPF_CALL_1(bpf_test_func, u64, arg) 13129 { 13130 char buf[64]; 13131 long a = 0; 13132 long b = 1; 13133 long c = 2; 13134 long d = 3; 13135 long e = 4; 13136 long f = 5; 13137 long g = 6; 13138 long h = 7; 13139 13140 return snprintf(buf, sizeof(buf), 13141 "%ld %lu %lx %ld %lu %lx %ld %lu %x", 13142 a, b, c, d, e, f, g, h, (int)arg); 13143 } 13144 #define BPF_FUNC_test_func __BPF_FUNC_MAX_ID 13145 13146 /* 13147 * Tail call tests. Each test case may call any other test in the table, 13148 * including itself, specified as a relative index offset from the calling 13149 * test. The index TAIL_CALL_NULL can be used to specify a NULL target 13150 * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID 13151 * results in a target index that is out of range. 13152 */ 13153 static struct tail_call_test tail_call_tests[] = { 13154 { 13155 "Tail call leaf", 13156 .insns = { 13157 BPF_ALU64_REG(BPF_MOV, R0, R1), 13158 BPF_ALU64_IMM(BPF_ADD, R0, 1), 13159 BPF_EXIT_INSN(), 13160 }, 13161 .result = 1, 13162 }, 13163 { 13164 "Tail call 2", 13165 .insns = { 13166 BPF_ALU64_IMM(BPF_ADD, R1, 2), 13167 TAIL_CALL(-1), 13168 BPF_ALU64_IMM(BPF_MOV, R0, -1), 13169 BPF_EXIT_INSN(), 13170 }, 13171 .result = 3, 13172 }, 13173 { 13174 "Tail call 3", 13175 .insns = { 13176 BPF_ALU64_IMM(BPF_ADD, R1, 3), 13177 TAIL_CALL(-1), 13178 BPF_ALU64_IMM(BPF_MOV, R0, -1), 13179 BPF_EXIT_INSN(), 13180 }, 13181 .result = 6, 13182 }, 13183 { 13184 "Tail call 4", 13185 .insns = { 13186 BPF_ALU64_IMM(BPF_ADD, R1, 4), 13187 TAIL_CALL(-1), 13188 BPF_ALU64_IMM(BPF_MOV, R0, -1), 13189 BPF_EXIT_INSN(), 13190 }, 13191 .result = 10, 13192 }, 13193 { 13194 "Tail call error path, max count reached", 13195 .insns = { 13196 BPF_LDX_MEM(BPF_W, R2, R1, 0), 13197 BPF_ALU64_IMM(BPF_ADD, R2, 1), 13198 BPF_STX_MEM(BPF_W, R1, R2, 0), 13199 TAIL_CALL(0), 13200 BPF_EXIT_INSN(), 13201 }, 13202 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 13203 .result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS, 13204 }, 13205 { 13206 "Tail call count preserved across function calls", 13207 .insns = { 13208 BPF_LDX_MEM(BPF_W, R2, R1, 0), 13209 BPF_ALU64_IMM(BPF_ADD, R2, 1), 13210 BPF_STX_MEM(BPF_W, R1, R2, 0), 13211 BPF_STX_MEM(BPF_DW, R10, R1, -8), 13212 BPF_CALL_REL(BPF_FUNC_get_numa_node_id), 13213 BPF_CALL_REL(BPF_FUNC_ktime_get_ns), 13214 BPF_CALL_REL(BPF_FUNC_ktime_get_boot_ns), 13215 BPF_CALL_REL(BPF_FUNC_ktime_get_coarse_ns), 13216 BPF_CALL_REL(BPF_FUNC_jiffies64), 13217 BPF_CALL_REL(BPF_FUNC_test_func), 13218 BPF_LDX_MEM(BPF_DW, R1, R10, -8), 13219 BPF_ALU32_REG(BPF_MOV, R0, R1), 13220 TAIL_CALL(0), 13221 BPF_EXIT_INSN(), 13222 }, 13223 .stack_depth = 8, 13224 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 13225 .result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS, 13226 }, 13227 { 13228 "Tail call error path, NULL target", 13229 .insns = { 13230 BPF_LDX_MEM(BPF_W, R2, R1, 0), 13231 BPF_ALU64_IMM(BPF_ADD, R2, 1), 13232 BPF_STX_MEM(BPF_W, R1, R2, 0), 13233 TAIL_CALL(TAIL_CALL_NULL), 13234 BPF_EXIT_INSN(), 13235 }, 13236 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 13237 .result = MAX_TESTRUNS, 13238 }, 13239 { 13240 "Tail call error path, index out of range", 13241 .insns = { 13242 BPF_LDX_MEM(BPF_W, R2, R1, 0), 13243 BPF_ALU64_IMM(BPF_ADD, R2, 1), 13244 BPF_STX_MEM(BPF_W, R1, R2, 0), 13245 TAIL_CALL(TAIL_CALL_INVALID), 13246 BPF_EXIT_INSN(), 13247 }, 13248 .flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE, 13249 .result = MAX_TESTRUNS, 13250 }, 13251 }; 13252 13253 static void __init destroy_tail_call_tests(struct bpf_array *progs) 13254 { 13255 int i; 13256 13257 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) 13258 if (progs->ptrs[i]) 13259 bpf_prog_free(progs->ptrs[i]); 13260 kfree(progs); 13261 } 13262 13263 static __init int prepare_tail_call_tests(struct bpf_array **pprogs) 13264 { 13265 int ntests = ARRAY_SIZE(tail_call_tests); 13266 struct bpf_array *progs; 13267 int which, err; 13268 13269 /* Allocate the table of programs to be used for tall calls */ 13270 progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]), 13271 GFP_KERNEL); 13272 if (!progs) 13273 goto out_nomem; 13274 13275 /* Create all eBPF programs and populate the table */ 13276 for (which = 0; which < ntests; which++) { 13277 struct tail_call_test *test = &tail_call_tests[which]; 13278 struct bpf_prog *fp; 13279 int len, i; 13280 13281 /* Compute the number of program instructions */ 13282 for (len = 0; len < MAX_INSNS; len++) { 13283 struct bpf_insn *insn = &test->insns[len]; 13284 13285 if (len < MAX_INSNS - 1 && 13286 insn->code == (BPF_LD | BPF_DW | BPF_IMM)) 13287 len++; 13288 if (insn->code == 0) 13289 break; 13290 } 13291 13292 /* Allocate and initialize the program */ 13293 fp = bpf_prog_alloc(bpf_prog_size(len), 0); 13294 if (!fp) 13295 goto out_nomem; 13296 13297 fp->len = len; 13298 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 13299 fp->aux->stack_depth = test->stack_depth; 13300 memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn)); 13301 13302 /* Relocate runtime tail call offsets and addresses */ 13303 for (i = 0; i < len; i++) { 13304 struct bpf_insn *insn = &fp->insnsi[i]; 13305 long addr = 0; 13306 13307 switch (insn->code) { 13308 case BPF_LD | BPF_DW | BPF_IMM: 13309 if (insn->imm != TAIL_CALL_MARKER) 13310 break; 13311 insn[0].imm = (u32)(long)progs; 13312 insn[1].imm = ((u64)(long)progs) >> 32; 13313 break; 13314 13315 case BPF_ALU | BPF_MOV | BPF_K: 13316 if (insn->imm != TAIL_CALL_MARKER) 13317 break; 13318 if (insn->off == TAIL_CALL_NULL) 13319 insn->imm = ntests; 13320 else if (insn->off == TAIL_CALL_INVALID) 13321 insn->imm = ntests + 1; 13322 else 13323 insn->imm = which + insn->off; 13324 insn->off = 0; 13325 break; 13326 13327 case BPF_JMP | BPF_CALL: 13328 if (insn->src_reg != BPF_PSEUDO_CALL) 13329 break; 13330 switch (insn->imm) { 13331 case BPF_FUNC_get_numa_node_id: 13332 addr = (long)&numa_node_id; 13333 break; 13334 case BPF_FUNC_ktime_get_ns: 13335 addr = (long)&ktime_get_ns; 13336 break; 13337 case BPF_FUNC_ktime_get_boot_ns: 13338 addr = (long)&ktime_get_boot_fast_ns; 13339 break; 13340 case BPF_FUNC_ktime_get_coarse_ns: 13341 addr = (long)&ktime_get_coarse_ns; 13342 break; 13343 case BPF_FUNC_jiffies64: 13344 addr = (long)&get_jiffies_64; 13345 break; 13346 case BPF_FUNC_test_func: 13347 addr = (long)&bpf_test_func; 13348 break; 13349 default: 13350 err = -EFAULT; 13351 goto out_err; 13352 } 13353 *insn = BPF_EMIT_CALL(addr); 13354 if ((long)__bpf_call_base + insn->imm != addr) 13355 *insn = BPF_JMP_A(0); /* Skip: NOP */ 13356 break; 13357 } 13358 } 13359 13360 fp = bpf_prog_select_runtime(fp, &err); 13361 if (err) 13362 goto out_err; 13363 13364 progs->ptrs[which] = fp; 13365 } 13366 13367 /* The last entry contains a NULL program pointer */ 13368 progs->map.max_entries = ntests + 1; 13369 *pprogs = progs; 13370 return 0; 13371 13372 out_nomem: 13373 err = -ENOMEM; 13374 13375 out_err: 13376 if (progs) 13377 destroy_tail_call_tests(progs); 13378 return err; 13379 } 13380 13381 static __init int test_tail_calls(struct bpf_array *progs) 13382 { 13383 int i, err_cnt = 0, pass_cnt = 0; 13384 int jit_cnt = 0, run_cnt = 0; 13385 13386 for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) { 13387 struct tail_call_test *test = &tail_call_tests[i]; 13388 struct bpf_prog *fp = progs->ptrs[i]; 13389 int *data = NULL; 13390 int state = 0; 13391 u64 duration; 13392 int ret; 13393 13394 cond_resched(); 13395 13396 pr_info("#%d %s ", i, test->descr); 13397 if (!fp) { 13398 err_cnt++; 13399 continue; 13400 } 13401 pr_cont("jited:%u ", fp->jited); 13402 13403 run_cnt++; 13404 if (fp->jited) 13405 jit_cnt++; 13406 13407 if (test->flags & FLAG_NEED_STATE) 13408 data = &state; 13409 ret = __run_one(fp, data, MAX_TESTRUNS, &duration); 13410 if (test->flags & FLAG_RESULT_IN_STATE) 13411 ret = state; 13412 if (ret == test->result) { 13413 pr_cont("%lld PASS", duration); 13414 pass_cnt++; 13415 } else { 13416 pr_cont("ret %d != %d FAIL", ret, test->result); 13417 err_cnt++; 13418 } 13419 } 13420 13421 pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 13422 __func__, pass_cnt, err_cnt, jit_cnt, run_cnt); 13423 13424 return err_cnt ? -EINVAL : 0; 13425 } 13426 13427 static int __init test_bpf_init(void) 13428 { 13429 struct bpf_array *progs = NULL; 13430 int ret; 13431 13432 ret = prepare_bpf_tests(); 13433 if (ret < 0) 13434 return ret; 13435 13436 ret = test_bpf(); 13437 destroy_bpf_tests(); 13438 if (ret) 13439 return ret; 13440 13441 ret = prepare_tail_call_tests(&progs); 13442 if (ret) 13443 return ret; 13444 ret = test_tail_calls(progs); 13445 destroy_tail_call_tests(progs); 13446 if (ret) 13447 return ret; 13448 13449 return test_skb_segment(); 13450 } 13451 13452 static void __exit test_bpf_exit(void) 13453 { 13454 } 13455 13456 module_init(test_bpf_init); 13457 module_exit(test_bpf_exit); 13458 13459 MODULE_LICENSE("GPL"); 13460