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