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