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