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