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 CLASSIC, 5286 { }, 5287 { 5288 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }, 5289 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) } 5290 }, 5291 .fill_helper = bpf_fill_maxinsns6, 5292 }, 5293 { /* Mainly checking JIT here. */ 5294 "BPF_MAXINSNS: Call heavy transformations", 5295 { }, 5296 CLASSIC | FLAG_NO_DATA, 5297 { }, 5298 { { 1, 0 }, { 10, 0 } }, 5299 .fill_helper = bpf_fill_maxinsns7, 5300 }, 5301 { /* Mainly checking JIT here. */ 5302 "BPF_MAXINSNS: Jump heavy test", 5303 { }, 5304 CLASSIC | FLAG_NO_DATA, 5305 { }, 5306 { { 0, 0xffffffff } }, 5307 .fill_helper = bpf_fill_maxinsns8, 5308 }, 5309 { /* Mainly checking JIT here. */ 5310 "BPF_MAXINSNS: Very long jump backwards", 5311 { }, 5312 INTERNAL | FLAG_NO_DATA, 5313 { }, 5314 { { 0, 0xcbababab } }, 5315 .fill_helper = bpf_fill_maxinsns9, 5316 }, 5317 { /* Mainly checking JIT here. */ 5318 "BPF_MAXINSNS: Edge hopping nuthouse", 5319 { }, 5320 INTERNAL | FLAG_NO_DATA, 5321 { }, 5322 { { 0, 0xabababac } }, 5323 .fill_helper = bpf_fill_maxinsns10, 5324 }, 5325 { 5326 "BPF_MAXINSNS: Jump, gap, jump, ...", 5327 { }, 5328 #if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_X86) 5329 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 5330 #else 5331 CLASSIC | FLAG_NO_DATA, 5332 #endif 5333 { }, 5334 { { 0, 0xababcbac } }, 5335 .fill_helper = bpf_fill_maxinsns11, 5336 .expected_errcode = -ENOTSUPP, 5337 }, 5338 { 5339 "BPF_MAXINSNS: jump over MSH", 5340 { }, 5341 CLASSIC | FLAG_EXPECTED_FAIL, 5342 { 0xfa, 0xfb, 0xfc, 0xfd, }, 5343 { { 4, 0xabababab } }, 5344 .fill_helper = bpf_fill_maxinsns12, 5345 .expected_errcode = -EINVAL, 5346 }, 5347 { 5348 "BPF_MAXINSNS: exec all MSH", 5349 { }, 5350 CLASSIC, 5351 { 0xfa, 0xfb, 0xfc, 0xfd, }, 5352 { { 4, 0xababab83 } }, 5353 .fill_helper = bpf_fill_maxinsns13, 5354 }, 5355 { 5356 "BPF_MAXINSNS: ld_abs+get_processor_id", 5357 { }, 5358 CLASSIC, 5359 { }, 5360 { { 1, 0xbee } }, 5361 .fill_helper = bpf_fill_ld_abs_get_processor_id, 5362 }, 5363 /* 5364 * LD_IND / LD_ABS on fragmented SKBs 5365 */ 5366 { 5367 "LD_IND byte frag", 5368 .u.insns = { 5369 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 5370 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0), 5371 BPF_STMT(BPF_RET | BPF_A, 0x0), 5372 }, 5373 CLASSIC | FLAG_SKB_FRAG, 5374 { }, 5375 { {0x40, 0x42} }, 5376 .frag_data = { 5377 0x42, 0x00, 0x00, 0x00, 5378 0x43, 0x44, 0x00, 0x00, 5379 0x21, 0x07, 0x19, 0x83, 5380 }, 5381 }, 5382 { 5383 "LD_IND halfword frag", 5384 .u.insns = { 5385 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 5386 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4), 5387 BPF_STMT(BPF_RET | BPF_A, 0x0), 5388 }, 5389 CLASSIC | FLAG_SKB_FRAG, 5390 { }, 5391 { {0x40, 0x4344} }, 5392 .frag_data = { 5393 0x42, 0x00, 0x00, 0x00, 5394 0x43, 0x44, 0x00, 0x00, 5395 0x21, 0x07, 0x19, 0x83, 5396 }, 5397 }, 5398 { 5399 "LD_IND word frag", 5400 .u.insns = { 5401 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 5402 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8), 5403 BPF_STMT(BPF_RET | BPF_A, 0x0), 5404 }, 5405 CLASSIC | FLAG_SKB_FRAG, 5406 { }, 5407 { {0x40, 0x21071983} }, 5408 .frag_data = { 5409 0x42, 0x00, 0x00, 0x00, 5410 0x43, 0x44, 0x00, 0x00, 5411 0x21, 0x07, 0x19, 0x83, 5412 }, 5413 }, 5414 { 5415 "LD_IND halfword mixed head/frag", 5416 .u.insns = { 5417 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 5418 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 5419 BPF_STMT(BPF_RET | BPF_A, 0x0), 5420 }, 5421 CLASSIC | FLAG_SKB_FRAG, 5422 { [0x3e] = 0x25, [0x3f] = 0x05, }, 5423 { {0x40, 0x0519} }, 5424 .frag_data = { 0x19, 0x82 }, 5425 }, 5426 { 5427 "LD_IND word mixed head/frag", 5428 .u.insns = { 5429 BPF_STMT(BPF_LDX | BPF_IMM, 0x40), 5430 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 5431 BPF_STMT(BPF_RET | BPF_A, 0x0), 5432 }, 5433 CLASSIC | FLAG_SKB_FRAG, 5434 { [0x3e] = 0x25, [0x3f] = 0x05, }, 5435 { {0x40, 0x25051982} }, 5436 .frag_data = { 0x19, 0x82 }, 5437 }, 5438 { 5439 "LD_ABS byte frag", 5440 .u.insns = { 5441 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40), 5442 BPF_STMT(BPF_RET | BPF_A, 0x0), 5443 }, 5444 CLASSIC | FLAG_SKB_FRAG, 5445 { }, 5446 { {0x40, 0x42} }, 5447 .frag_data = { 5448 0x42, 0x00, 0x00, 0x00, 5449 0x43, 0x44, 0x00, 0x00, 5450 0x21, 0x07, 0x19, 0x83, 5451 }, 5452 }, 5453 { 5454 "LD_ABS halfword frag", 5455 .u.insns = { 5456 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44), 5457 BPF_STMT(BPF_RET | BPF_A, 0x0), 5458 }, 5459 CLASSIC | FLAG_SKB_FRAG, 5460 { }, 5461 { {0x40, 0x4344} }, 5462 .frag_data = { 5463 0x42, 0x00, 0x00, 0x00, 5464 0x43, 0x44, 0x00, 0x00, 5465 0x21, 0x07, 0x19, 0x83, 5466 }, 5467 }, 5468 { 5469 "LD_ABS word frag", 5470 .u.insns = { 5471 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48), 5472 BPF_STMT(BPF_RET | BPF_A, 0x0), 5473 }, 5474 CLASSIC | FLAG_SKB_FRAG, 5475 { }, 5476 { {0x40, 0x21071983} }, 5477 .frag_data = { 5478 0x42, 0x00, 0x00, 0x00, 5479 0x43, 0x44, 0x00, 0x00, 5480 0x21, 0x07, 0x19, 0x83, 5481 }, 5482 }, 5483 { 5484 "LD_ABS halfword mixed head/frag", 5485 .u.insns = { 5486 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 5487 BPF_STMT(BPF_RET | BPF_A, 0x0), 5488 }, 5489 CLASSIC | FLAG_SKB_FRAG, 5490 { [0x3e] = 0x25, [0x3f] = 0x05, }, 5491 { {0x40, 0x0519} }, 5492 .frag_data = { 0x19, 0x82 }, 5493 }, 5494 { 5495 "LD_ABS word mixed head/frag", 5496 .u.insns = { 5497 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e), 5498 BPF_STMT(BPF_RET | BPF_A, 0x0), 5499 }, 5500 CLASSIC | FLAG_SKB_FRAG, 5501 { [0x3e] = 0x25, [0x3f] = 0x05, }, 5502 { {0x40, 0x25051982} }, 5503 .frag_data = { 0x19, 0x82 }, 5504 }, 5505 /* 5506 * LD_IND / LD_ABS on non fragmented SKBs 5507 */ 5508 { 5509 /* 5510 * this tests that the JIT/interpreter correctly resets X 5511 * before using it in an LD_IND instruction. 5512 */ 5513 "LD_IND byte default X", 5514 .u.insns = { 5515 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 5516 BPF_STMT(BPF_RET | BPF_A, 0x0), 5517 }, 5518 CLASSIC, 5519 { [0x1] = 0x42 }, 5520 { {0x40, 0x42 } }, 5521 }, 5522 { 5523 "LD_IND byte positive offset", 5524 .u.insns = { 5525 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5526 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 5527 BPF_STMT(BPF_RET | BPF_A, 0x0), 5528 }, 5529 CLASSIC, 5530 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5531 { {0x40, 0x82 } }, 5532 }, 5533 { 5534 "LD_IND byte negative offset", 5535 .u.insns = { 5536 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5537 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1), 5538 BPF_STMT(BPF_RET | BPF_A, 0x0), 5539 }, 5540 CLASSIC, 5541 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5542 { {0x40, 0x05 } }, 5543 }, 5544 { 5545 "LD_IND byte positive offset, all ff", 5546 .u.insns = { 5547 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5548 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 5549 BPF_STMT(BPF_RET | BPF_A, 0x0), 5550 }, 5551 CLASSIC, 5552 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 5553 { {0x40, 0xff } }, 5554 }, 5555 { 5556 "LD_IND byte positive offset, out of bounds", 5557 .u.insns = { 5558 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5559 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1), 5560 BPF_STMT(BPF_RET | BPF_A, 0x0), 5561 }, 5562 CLASSIC, 5563 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5564 { {0x3f, 0 }, }, 5565 }, 5566 { 5567 "LD_IND byte negative offset, out of bounds", 5568 .u.insns = { 5569 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5570 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f), 5571 BPF_STMT(BPF_RET | BPF_A, 0x0), 5572 }, 5573 CLASSIC, 5574 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5575 { {0x3f, 0 } }, 5576 }, 5577 { 5578 "LD_IND byte negative offset, multiple calls", 5579 .u.insns = { 5580 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 5581 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1), 5582 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2), 5583 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3), 5584 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4), 5585 BPF_STMT(BPF_RET | BPF_A, 0x0), 5586 }, 5587 CLASSIC, 5588 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5589 { {0x40, 0x82 }, }, 5590 }, 5591 { 5592 "LD_IND halfword positive offset", 5593 .u.insns = { 5594 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5595 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2), 5596 BPF_STMT(BPF_RET | BPF_A, 0x0), 5597 }, 5598 CLASSIC, 5599 { 5600 [0x1c] = 0xaa, [0x1d] = 0x55, 5601 [0x1e] = 0xbb, [0x1f] = 0x66, 5602 [0x20] = 0xcc, [0x21] = 0x77, 5603 [0x22] = 0xdd, [0x23] = 0x88, 5604 }, 5605 { {0x40, 0xdd88 } }, 5606 }, 5607 { 5608 "LD_IND halfword negative offset", 5609 .u.insns = { 5610 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5611 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2), 5612 BPF_STMT(BPF_RET | BPF_A, 0x0), 5613 }, 5614 CLASSIC, 5615 { 5616 [0x1c] = 0xaa, [0x1d] = 0x55, 5617 [0x1e] = 0xbb, [0x1f] = 0x66, 5618 [0x20] = 0xcc, [0x21] = 0x77, 5619 [0x22] = 0xdd, [0x23] = 0x88, 5620 }, 5621 { {0x40, 0xbb66 } }, 5622 }, 5623 { 5624 "LD_IND halfword unaligned", 5625 .u.insns = { 5626 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5627 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1), 5628 BPF_STMT(BPF_RET | BPF_A, 0x0), 5629 }, 5630 CLASSIC, 5631 { 5632 [0x1c] = 0xaa, [0x1d] = 0x55, 5633 [0x1e] = 0xbb, [0x1f] = 0x66, 5634 [0x20] = 0xcc, [0x21] = 0x77, 5635 [0x22] = 0xdd, [0x23] = 0x88, 5636 }, 5637 { {0x40, 0x66cc } }, 5638 }, 5639 { 5640 "LD_IND halfword positive offset, all ff", 5641 .u.insns = { 5642 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d), 5643 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 5644 BPF_STMT(BPF_RET | BPF_A, 0x0), 5645 }, 5646 CLASSIC, 5647 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 5648 { {0x40, 0xffff } }, 5649 }, 5650 { 5651 "LD_IND halfword positive offset, out of bounds", 5652 .u.insns = { 5653 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5654 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1), 5655 BPF_STMT(BPF_RET | BPF_A, 0x0), 5656 }, 5657 CLASSIC, 5658 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5659 { {0x3f, 0 }, }, 5660 }, 5661 { 5662 "LD_IND halfword negative offset, out of bounds", 5663 .u.insns = { 5664 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5665 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f), 5666 BPF_STMT(BPF_RET | BPF_A, 0x0), 5667 }, 5668 CLASSIC, 5669 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5670 { {0x3f, 0 } }, 5671 }, 5672 { 5673 "LD_IND word positive offset", 5674 .u.insns = { 5675 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5676 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4), 5677 BPF_STMT(BPF_RET | BPF_A, 0x0), 5678 }, 5679 CLASSIC, 5680 { 5681 [0x1c] = 0xaa, [0x1d] = 0x55, 5682 [0x1e] = 0xbb, [0x1f] = 0x66, 5683 [0x20] = 0xcc, [0x21] = 0x77, 5684 [0x22] = 0xdd, [0x23] = 0x88, 5685 [0x24] = 0xee, [0x25] = 0x99, 5686 [0x26] = 0xff, [0x27] = 0xaa, 5687 }, 5688 { {0x40, 0xee99ffaa } }, 5689 }, 5690 { 5691 "LD_IND word negative offset", 5692 .u.insns = { 5693 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5694 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4), 5695 BPF_STMT(BPF_RET | BPF_A, 0x0), 5696 }, 5697 CLASSIC, 5698 { 5699 [0x1c] = 0xaa, [0x1d] = 0x55, 5700 [0x1e] = 0xbb, [0x1f] = 0x66, 5701 [0x20] = 0xcc, [0x21] = 0x77, 5702 [0x22] = 0xdd, [0x23] = 0x88, 5703 [0x24] = 0xee, [0x25] = 0x99, 5704 [0x26] = 0xff, [0x27] = 0xaa, 5705 }, 5706 { {0x40, 0xaa55bb66 } }, 5707 }, 5708 { 5709 "LD_IND word unaligned (addr & 3 == 2)", 5710 .u.insns = { 5711 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5712 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2), 5713 BPF_STMT(BPF_RET | BPF_A, 0x0), 5714 }, 5715 CLASSIC, 5716 { 5717 [0x1c] = 0xaa, [0x1d] = 0x55, 5718 [0x1e] = 0xbb, [0x1f] = 0x66, 5719 [0x20] = 0xcc, [0x21] = 0x77, 5720 [0x22] = 0xdd, [0x23] = 0x88, 5721 [0x24] = 0xee, [0x25] = 0x99, 5722 [0x26] = 0xff, [0x27] = 0xaa, 5723 }, 5724 { {0x40, 0xbb66cc77 } }, 5725 }, 5726 { 5727 "LD_IND word unaligned (addr & 3 == 1)", 5728 .u.insns = { 5729 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5730 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3), 5731 BPF_STMT(BPF_RET | BPF_A, 0x0), 5732 }, 5733 CLASSIC, 5734 { 5735 [0x1c] = 0xaa, [0x1d] = 0x55, 5736 [0x1e] = 0xbb, [0x1f] = 0x66, 5737 [0x20] = 0xcc, [0x21] = 0x77, 5738 [0x22] = 0xdd, [0x23] = 0x88, 5739 [0x24] = 0xee, [0x25] = 0x99, 5740 [0x26] = 0xff, [0x27] = 0xaa, 5741 }, 5742 { {0x40, 0x55bb66cc } }, 5743 }, 5744 { 5745 "LD_IND word unaligned (addr & 3 == 3)", 5746 .u.insns = { 5747 BPF_STMT(BPF_LDX | BPF_IMM, 0x20), 5748 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1), 5749 BPF_STMT(BPF_RET | BPF_A, 0x0), 5750 }, 5751 CLASSIC, 5752 { 5753 [0x1c] = 0xaa, [0x1d] = 0x55, 5754 [0x1e] = 0xbb, [0x1f] = 0x66, 5755 [0x20] = 0xcc, [0x21] = 0x77, 5756 [0x22] = 0xdd, [0x23] = 0x88, 5757 [0x24] = 0xee, [0x25] = 0x99, 5758 [0x26] = 0xff, [0x27] = 0xaa, 5759 }, 5760 { {0x40, 0x66cc77dd } }, 5761 }, 5762 { 5763 "LD_IND word positive offset, all ff", 5764 .u.insns = { 5765 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b), 5766 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 5767 BPF_STMT(BPF_RET | BPF_A, 0x0), 5768 }, 5769 CLASSIC, 5770 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 5771 { {0x40, 0xffffffff } }, 5772 }, 5773 { 5774 "LD_IND word positive offset, out of bounds", 5775 .u.insns = { 5776 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5777 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1), 5778 BPF_STMT(BPF_RET | BPF_A, 0x0), 5779 }, 5780 CLASSIC, 5781 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5782 { {0x3f, 0 }, }, 5783 }, 5784 { 5785 "LD_IND word negative offset, out of bounds", 5786 .u.insns = { 5787 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e), 5788 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f), 5789 BPF_STMT(BPF_RET | BPF_A, 0x0), 5790 }, 5791 CLASSIC, 5792 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5793 { {0x3f, 0 } }, 5794 }, 5795 { 5796 "LD_ABS byte", 5797 .u.insns = { 5798 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20), 5799 BPF_STMT(BPF_RET | BPF_A, 0x0), 5800 }, 5801 CLASSIC, 5802 { 5803 [0x1c] = 0xaa, [0x1d] = 0x55, 5804 [0x1e] = 0xbb, [0x1f] = 0x66, 5805 [0x20] = 0xcc, [0x21] = 0x77, 5806 [0x22] = 0xdd, [0x23] = 0x88, 5807 [0x24] = 0xee, [0x25] = 0x99, 5808 [0x26] = 0xff, [0x27] = 0xaa, 5809 }, 5810 { {0x40, 0xcc } }, 5811 }, 5812 { 5813 "LD_ABS byte positive offset, all ff", 5814 .u.insns = { 5815 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 5816 BPF_STMT(BPF_RET | BPF_A, 0x0), 5817 }, 5818 CLASSIC, 5819 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 5820 { {0x40, 0xff } }, 5821 }, 5822 { 5823 "LD_ABS byte positive offset, out of bounds", 5824 .u.insns = { 5825 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f), 5826 BPF_STMT(BPF_RET | BPF_A, 0x0), 5827 }, 5828 CLASSIC, 5829 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5830 { {0x3f, 0 }, }, 5831 }, 5832 { 5833 "LD_ABS byte negative offset, out of bounds load", 5834 .u.insns = { 5835 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1), 5836 BPF_STMT(BPF_RET | BPF_A, 0x0), 5837 }, 5838 CLASSIC | FLAG_EXPECTED_FAIL, 5839 .expected_errcode = -EINVAL, 5840 }, 5841 { 5842 "LD_ABS byte negative offset, in bounds", 5843 .u.insns = { 5844 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 5845 BPF_STMT(BPF_RET | BPF_A, 0x0), 5846 }, 5847 CLASSIC, 5848 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5849 { {0x40, 0x82 }, }, 5850 }, 5851 { 5852 "LD_ABS byte negative offset, out of bounds", 5853 .u.insns = { 5854 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 5855 BPF_STMT(BPF_RET | BPF_A, 0x0), 5856 }, 5857 CLASSIC, 5858 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5859 { {0x3f, 0 }, }, 5860 }, 5861 { 5862 "LD_ABS byte negative offset, multiple calls", 5863 .u.insns = { 5864 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c), 5865 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d), 5866 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e), 5867 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f), 5868 BPF_STMT(BPF_RET | BPF_A, 0x0), 5869 }, 5870 CLASSIC, 5871 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5872 { {0x40, 0x82 }, }, 5873 }, 5874 { 5875 "LD_ABS halfword", 5876 .u.insns = { 5877 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22), 5878 BPF_STMT(BPF_RET | BPF_A, 0x0), 5879 }, 5880 CLASSIC, 5881 { 5882 [0x1c] = 0xaa, [0x1d] = 0x55, 5883 [0x1e] = 0xbb, [0x1f] = 0x66, 5884 [0x20] = 0xcc, [0x21] = 0x77, 5885 [0x22] = 0xdd, [0x23] = 0x88, 5886 [0x24] = 0xee, [0x25] = 0x99, 5887 [0x26] = 0xff, [0x27] = 0xaa, 5888 }, 5889 { {0x40, 0xdd88 } }, 5890 }, 5891 { 5892 "LD_ABS halfword unaligned", 5893 .u.insns = { 5894 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25), 5895 BPF_STMT(BPF_RET | BPF_A, 0x0), 5896 }, 5897 CLASSIC, 5898 { 5899 [0x1c] = 0xaa, [0x1d] = 0x55, 5900 [0x1e] = 0xbb, [0x1f] = 0x66, 5901 [0x20] = 0xcc, [0x21] = 0x77, 5902 [0x22] = 0xdd, [0x23] = 0x88, 5903 [0x24] = 0xee, [0x25] = 0x99, 5904 [0x26] = 0xff, [0x27] = 0xaa, 5905 }, 5906 { {0x40, 0x99ff } }, 5907 }, 5908 { 5909 "LD_ABS halfword positive offset, all ff", 5910 .u.insns = { 5911 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e), 5912 BPF_STMT(BPF_RET | BPF_A, 0x0), 5913 }, 5914 CLASSIC, 5915 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 5916 { {0x40, 0xffff } }, 5917 }, 5918 { 5919 "LD_ABS halfword positive offset, out of bounds", 5920 .u.insns = { 5921 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f), 5922 BPF_STMT(BPF_RET | BPF_A, 0x0), 5923 }, 5924 CLASSIC, 5925 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5926 { {0x3f, 0 }, }, 5927 }, 5928 { 5929 "LD_ABS halfword negative offset, out of bounds load", 5930 .u.insns = { 5931 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1), 5932 BPF_STMT(BPF_RET | BPF_A, 0x0), 5933 }, 5934 CLASSIC | FLAG_EXPECTED_FAIL, 5935 .expected_errcode = -EINVAL, 5936 }, 5937 { 5938 "LD_ABS halfword negative offset, in bounds", 5939 .u.insns = { 5940 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 5941 BPF_STMT(BPF_RET | BPF_A, 0x0), 5942 }, 5943 CLASSIC, 5944 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5945 { {0x40, 0x1982 }, }, 5946 }, 5947 { 5948 "LD_ABS halfword negative offset, out of bounds", 5949 .u.insns = { 5950 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e), 5951 BPF_STMT(BPF_RET | BPF_A, 0x0), 5952 }, 5953 CLASSIC, 5954 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 5955 { {0x3f, 0 }, }, 5956 }, 5957 { 5958 "LD_ABS word", 5959 .u.insns = { 5960 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c), 5961 BPF_STMT(BPF_RET | BPF_A, 0x0), 5962 }, 5963 CLASSIC, 5964 { 5965 [0x1c] = 0xaa, [0x1d] = 0x55, 5966 [0x1e] = 0xbb, [0x1f] = 0x66, 5967 [0x20] = 0xcc, [0x21] = 0x77, 5968 [0x22] = 0xdd, [0x23] = 0x88, 5969 [0x24] = 0xee, [0x25] = 0x99, 5970 [0x26] = 0xff, [0x27] = 0xaa, 5971 }, 5972 { {0x40, 0xaa55bb66 } }, 5973 }, 5974 { 5975 "LD_ABS word unaligned (addr & 3 == 2)", 5976 .u.insns = { 5977 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22), 5978 BPF_STMT(BPF_RET | BPF_A, 0x0), 5979 }, 5980 CLASSIC, 5981 { 5982 [0x1c] = 0xaa, [0x1d] = 0x55, 5983 [0x1e] = 0xbb, [0x1f] = 0x66, 5984 [0x20] = 0xcc, [0x21] = 0x77, 5985 [0x22] = 0xdd, [0x23] = 0x88, 5986 [0x24] = 0xee, [0x25] = 0x99, 5987 [0x26] = 0xff, [0x27] = 0xaa, 5988 }, 5989 { {0x40, 0xdd88ee99 } }, 5990 }, 5991 { 5992 "LD_ABS word unaligned (addr & 3 == 1)", 5993 .u.insns = { 5994 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21), 5995 BPF_STMT(BPF_RET | BPF_A, 0x0), 5996 }, 5997 CLASSIC, 5998 { 5999 [0x1c] = 0xaa, [0x1d] = 0x55, 6000 [0x1e] = 0xbb, [0x1f] = 0x66, 6001 [0x20] = 0xcc, [0x21] = 0x77, 6002 [0x22] = 0xdd, [0x23] = 0x88, 6003 [0x24] = 0xee, [0x25] = 0x99, 6004 [0x26] = 0xff, [0x27] = 0xaa, 6005 }, 6006 { {0x40, 0x77dd88ee } }, 6007 }, 6008 { 6009 "LD_ABS word unaligned (addr & 3 == 3)", 6010 .u.insns = { 6011 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23), 6012 BPF_STMT(BPF_RET | BPF_A, 0x0), 6013 }, 6014 CLASSIC, 6015 { 6016 [0x1c] = 0xaa, [0x1d] = 0x55, 6017 [0x1e] = 0xbb, [0x1f] = 0x66, 6018 [0x20] = 0xcc, [0x21] = 0x77, 6019 [0x22] = 0xdd, [0x23] = 0x88, 6020 [0x24] = 0xee, [0x25] = 0x99, 6021 [0x26] = 0xff, [0x27] = 0xaa, 6022 }, 6023 { {0x40, 0x88ee99ff } }, 6024 }, 6025 { 6026 "LD_ABS word positive offset, all ff", 6027 .u.insns = { 6028 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c), 6029 BPF_STMT(BPF_RET | BPF_A, 0x0), 6030 }, 6031 CLASSIC, 6032 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff }, 6033 { {0x40, 0xffffffff } }, 6034 }, 6035 { 6036 "LD_ABS word positive offset, out of bounds", 6037 .u.insns = { 6038 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f), 6039 BPF_STMT(BPF_RET | BPF_A, 0x0), 6040 }, 6041 CLASSIC, 6042 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6043 { {0x3f, 0 }, }, 6044 }, 6045 { 6046 "LD_ABS word negative offset, out of bounds load", 6047 .u.insns = { 6048 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1), 6049 BPF_STMT(BPF_RET | BPF_A, 0x0), 6050 }, 6051 CLASSIC | FLAG_EXPECTED_FAIL, 6052 .expected_errcode = -EINVAL, 6053 }, 6054 { 6055 "LD_ABS word negative offset, in bounds", 6056 .u.insns = { 6057 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 6058 BPF_STMT(BPF_RET | BPF_A, 0x0), 6059 }, 6060 CLASSIC, 6061 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6062 { {0x40, 0x25051982 }, }, 6063 }, 6064 { 6065 "LD_ABS word negative offset, out of bounds", 6066 .u.insns = { 6067 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c), 6068 BPF_STMT(BPF_RET | BPF_A, 0x0), 6069 }, 6070 CLASSIC, 6071 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6072 { {0x3f, 0 }, }, 6073 }, 6074 { 6075 "LDX_MSH standalone, preserved A", 6076 .u.insns = { 6077 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6078 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 6079 BPF_STMT(BPF_RET | BPF_A, 0x0), 6080 }, 6081 CLASSIC, 6082 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6083 { {0x40, 0xffeebbaa }, }, 6084 }, 6085 { 6086 "LDX_MSH standalone, preserved A 2", 6087 .u.insns = { 6088 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63), 6089 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 6090 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d), 6091 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 6092 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f), 6093 BPF_STMT(BPF_RET | BPF_A, 0x0), 6094 }, 6095 CLASSIC, 6096 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6097 { {0x40, 0x175e9d63 }, }, 6098 }, 6099 { 6100 "LDX_MSH standalone, test result 1", 6101 .u.insns = { 6102 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6103 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c), 6104 BPF_STMT(BPF_MISC | BPF_TXA, 0), 6105 BPF_STMT(BPF_RET | BPF_A, 0x0), 6106 }, 6107 CLASSIC, 6108 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6109 { {0x40, 0x14 }, }, 6110 }, 6111 { 6112 "LDX_MSH standalone, test result 2", 6113 .u.insns = { 6114 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6115 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e), 6116 BPF_STMT(BPF_MISC | BPF_TXA, 0), 6117 BPF_STMT(BPF_RET | BPF_A, 0x0), 6118 }, 6119 CLASSIC, 6120 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6121 { {0x40, 0x24 }, }, 6122 }, 6123 { 6124 "LDX_MSH standalone, negative offset", 6125 .u.insns = { 6126 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6127 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1), 6128 BPF_STMT(BPF_MISC | BPF_TXA, 0), 6129 BPF_STMT(BPF_RET | BPF_A, 0x0), 6130 }, 6131 CLASSIC, 6132 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6133 { {0x40, 0 }, }, 6134 }, 6135 { 6136 "LDX_MSH standalone, negative offset 2", 6137 .u.insns = { 6138 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6139 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e), 6140 BPF_STMT(BPF_MISC | BPF_TXA, 0), 6141 BPF_STMT(BPF_RET | BPF_A, 0x0), 6142 }, 6143 CLASSIC, 6144 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6145 { {0x40, 0x24 }, }, 6146 }, 6147 { 6148 "LDX_MSH standalone, out of bounds", 6149 .u.insns = { 6150 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa), 6151 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40), 6152 BPF_STMT(BPF_MISC | BPF_TXA, 0), 6153 BPF_STMT(BPF_RET | BPF_A, 0x0), 6154 }, 6155 CLASSIC, 6156 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 }, 6157 { {0x40, 0 }, }, 6158 }, 6159 /* 6160 * verify that the interpreter or JIT correctly sets A and X 6161 * to 0. 6162 */ 6163 { 6164 "ADD default X", 6165 .u.insns = { 6166 /* 6167 * A = 0x42 6168 * A = A + X 6169 * ret A 6170 */ 6171 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 6172 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 6173 BPF_STMT(BPF_RET | BPF_A, 0x0), 6174 }, 6175 CLASSIC | FLAG_NO_DATA, 6176 {}, 6177 { {0x1, 0x42 } }, 6178 }, 6179 { 6180 "ADD default A", 6181 .u.insns = { 6182 /* 6183 * A = A + 0x42 6184 * ret A 6185 */ 6186 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42), 6187 BPF_STMT(BPF_RET | BPF_A, 0x0), 6188 }, 6189 CLASSIC | FLAG_NO_DATA, 6190 {}, 6191 { {0x1, 0x42 } }, 6192 }, 6193 { 6194 "SUB default X", 6195 .u.insns = { 6196 /* 6197 * A = 0x66 6198 * A = A - X 6199 * ret A 6200 */ 6201 BPF_STMT(BPF_LD | BPF_IMM, 0x66), 6202 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 6203 BPF_STMT(BPF_RET | BPF_A, 0x0), 6204 }, 6205 CLASSIC | FLAG_NO_DATA, 6206 {}, 6207 { {0x1, 0x66 } }, 6208 }, 6209 { 6210 "SUB default A", 6211 .u.insns = { 6212 /* 6213 * A = A - -0x66 6214 * ret A 6215 */ 6216 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66), 6217 BPF_STMT(BPF_RET | BPF_A, 0x0), 6218 }, 6219 CLASSIC | FLAG_NO_DATA, 6220 {}, 6221 { {0x1, 0x66 } }, 6222 }, 6223 { 6224 "MUL default X", 6225 .u.insns = { 6226 /* 6227 * A = 0x42 6228 * A = A * X 6229 * ret A 6230 */ 6231 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 6232 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0), 6233 BPF_STMT(BPF_RET | BPF_A, 0x0), 6234 }, 6235 CLASSIC | FLAG_NO_DATA, 6236 {}, 6237 { {0x1, 0x0 } }, 6238 }, 6239 { 6240 "MUL default A", 6241 .u.insns = { 6242 /* 6243 * A = A * 0x66 6244 * ret A 6245 */ 6246 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66), 6247 BPF_STMT(BPF_RET | BPF_A, 0x0), 6248 }, 6249 CLASSIC | FLAG_NO_DATA, 6250 {}, 6251 { {0x1, 0x0 } }, 6252 }, 6253 { 6254 "DIV default X", 6255 .u.insns = { 6256 /* 6257 * A = 0x42 6258 * A = A / X ; this halt the filter execution if X is 0 6259 * ret 0x42 6260 */ 6261 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 6262 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 6263 BPF_STMT(BPF_RET | BPF_K, 0x42), 6264 }, 6265 CLASSIC | FLAG_NO_DATA, 6266 {}, 6267 { {0x1, 0x0 } }, 6268 }, 6269 { 6270 "DIV default A", 6271 .u.insns = { 6272 /* 6273 * A = A / 1 6274 * ret A 6275 */ 6276 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1), 6277 BPF_STMT(BPF_RET | BPF_A, 0x0), 6278 }, 6279 CLASSIC | FLAG_NO_DATA, 6280 {}, 6281 { {0x1, 0x0 } }, 6282 }, 6283 { 6284 "MOD default X", 6285 .u.insns = { 6286 /* 6287 * A = 0x42 6288 * A = A mod X ; this halt the filter execution if X is 0 6289 * ret 0x42 6290 */ 6291 BPF_STMT(BPF_LD | BPF_IMM, 0x42), 6292 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 6293 BPF_STMT(BPF_RET | BPF_K, 0x42), 6294 }, 6295 CLASSIC | FLAG_NO_DATA, 6296 {}, 6297 { {0x1, 0x0 } }, 6298 }, 6299 { 6300 "MOD default A", 6301 .u.insns = { 6302 /* 6303 * A = A mod 1 6304 * ret A 6305 */ 6306 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1), 6307 BPF_STMT(BPF_RET | BPF_A, 0x0), 6308 }, 6309 CLASSIC | FLAG_NO_DATA, 6310 {}, 6311 { {0x1, 0x0 } }, 6312 }, 6313 { 6314 "JMP EQ default A", 6315 .u.insns = { 6316 /* 6317 * cmp A, 0x0, 0, 1 6318 * ret 0x42 6319 * ret 0x66 6320 */ 6321 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1), 6322 BPF_STMT(BPF_RET | BPF_K, 0x42), 6323 BPF_STMT(BPF_RET | BPF_K, 0x66), 6324 }, 6325 CLASSIC | FLAG_NO_DATA, 6326 {}, 6327 { {0x1, 0x42 } }, 6328 }, 6329 { 6330 "JMP EQ default X", 6331 .u.insns = { 6332 /* 6333 * A = 0x0 6334 * cmp A, X, 0, 1 6335 * ret 0x42 6336 * ret 0x66 6337 */ 6338 BPF_STMT(BPF_LD | BPF_IMM, 0x0), 6339 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1), 6340 BPF_STMT(BPF_RET | BPF_K, 0x42), 6341 BPF_STMT(BPF_RET | BPF_K, 0x66), 6342 }, 6343 CLASSIC | FLAG_NO_DATA, 6344 {}, 6345 { {0x1, 0x42 } }, 6346 }, 6347 /* Checking interpreter vs JIT wrt signed extended imms. */ 6348 { 6349 "JNE signed compare, test 1", 6350 .u.insns_int = { 6351 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 6352 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 6353 BPF_MOV64_REG(R2, R1), 6354 BPF_ALU64_REG(BPF_AND, R2, R3), 6355 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6356 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1), 6357 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6358 BPF_EXIT_INSN(), 6359 }, 6360 INTERNAL, 6361 { }, 6362 { { 0, 1 } }, 6363 }, 6364 { 6365 "JNE signed compare, test 2", 6366 .u.insns_int = { 6367 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 6368 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 6369 BPF_MOV64_REG(R2, R1), 6370 BPF_ALU64_REG(BPF_AND, R2, R3), 6371 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6372 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1), 6373 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6374 BPF_EXIT_INSN(), 6375 }, 6376 INTERNAL, 6377 { }, 6378 { { 0, 1 } }, 6379 }, 6380 { 6381 "JNE signed compare, test 3", 6382 .u.insns_int = { 6383 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12), 6384 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000), 6385 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000), 6386 BPF_MOV64_REG(R2, R1), 6387 BPF_ALU64_REG(BPF_AND, R2, R3), 6388 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6389 BPF_JMP_REG(BPF_JNE, R2, R4, 1), 6390 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6391 BPF_EXIT_INSN(), 6392 }, 6393 INTERNAL, 6394 { }, 6395 { { 0, 2 } }, 6396 }, 6397 { 6398 "JNE signed compare, test 4", 6399 .u.insns_int = { 6400 BPF_LD_IMM64(R1, -17104896), 6401 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6402 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1), 6403 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6404 BPF_EXIT_INSN(), 6405 }, 6406 INTERNAL, 6407 { }, 6408 { { 0, 2 } }, 6409 }, 6410 { 6411 "JNE signed compare, test 5", 6412 .u.insns_int = { 6413 BPF_LD_IMM64(R1, 0xfefb0000), 6414 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6415 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1), 6416 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6417 BPF_EXIT_INSN(), 6418 }, 6419 INTERNAL, 6420 { }, 6421 { { 0, 1 } }, 6422 }, 6423 { 6424 "JNE signed compare, test 6", 6425 .u.insns_int = { 6426 BPF_LD_IMM64(R1, 0x7efb0000), 6427 BPF_ALU32_IMM(BPF_MOV, R0, 1), 6428 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1), 6429 BPF_ALU32_IMM(BPF_MOV, R0, 2), 6430 BPF_EXIT_INSN(), 6431 }, 6432 INTERNAL, 6433 { }, 6434 { { 0, 2 } }, 6435 }, 6436 { 6437 "JNE signed compare, test 7", 6438 .u.insns = { 6439 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000), 6440 BPF_STMT(BPF_MISC | BPF_TAX, 0), 6441 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12), 6442 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0), 6443 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0), 6444 BPF_STMT(BPF_RET | BPF_K, 1), 6445 BPF_STMT(BPF_RET | BPF_K, 2), 6446 }, 6447 CLASSIC | FLAG_NO_DATA, 6448 {}, 6449 { { 0, 2 } }, 6450 }, 6451 }; 6452 6453 static struct net_device dev; 6454 6455 static struct sk_buff *populate_skb(char *buf, int size) 6456 { 6457 struct sk_buff *skb; 6458 6459 if (size >= MAX_DATA) 6460 return NULL; 6461 6462 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 6463 if (!skb) 6464 return NULL; 6465 6466 __skb_put_data(skb, buf, size); 6467 6468 /* Initialize a fake skb with test pattern. */ 6469 skb_reset_mac_header(skb); 6470 skb->protocol = htons(ETH_P_IP); 6471 skb->pkt_type = SKB_TYPE; 6472 skb->mark = SKB_MARK; 6473 skb->hash = SKB_HASH; 6474 skb->queue_mapping = SKB_QUEUE_MAP; 6475 skb->vlan_tci = SKB_VLAN_TCI; 6476 skb->vlan_proto = htons(ETH_P_IP); 6477 skb->dev = &dev; 6478 skb->dev->ifindex = SKB_DEV_IFINDEX; 6479 skb->dev->type = SKB_DEV_TYPE; 6480 skb_set_network_header(skb, min(size, ETH_HLEN)); 6481 6482 return skb; 6483 } 6484 6485 static void *generate_test_data(struct bpf_test *test, int sub) 6486 { 6487 struct sk_buff *skb; 6488 struct page *page; 6489 6490 if (test->aux & FLAG_NO_DATA) 6491 return NULL; 6492 6493 /* Test case expects an skb, so populate one. Various 6494 * subtests generate skbs of different sizes based on 6495 * the same data. 6496 */ 6497 skb = populate_skb(test->data, test->test[sub].data_size); 6498 if (!skb) 6499 return NULL; 6500 6501 if (test->aux & FLAG_SKB_FRAG) { 6502 /* 6503 * when the test requires a fragmented skb, add a 6504 * single fragment to the skb, filled with 6505 * test->frag_data. 6506 */ 6507 void *ptr; 6508 6509 page = alloc_page(GFP_KERNEL); 6510 6511 if (!page) 6512 goto err_kfree_skb; 6513 6514 ptr = kmap(page); 6515 if (!ptr) 6516 goto err_free_page; 6517 memcpy(ptr, test->frag_data, MAX_DATA); 6518 kunmap(page); 6519 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA); 6520 } 6521 6522 return skb; 6523 6524 err_free_page: 6525 __free_page(page); 6526 err_kfree_skb: 6527 kfree_skb(skb); 6528 return NULL; 6529 } 6530 6531 static void release_test_data(const struct bpf_test *test, void *data) 6532 { 6533 if (test->aux & FLAG_NO_DATA) 6534 return; 6535 6536 kfree_skb(data); 6537 } 6538 6539 static int filter_length(int which) 6540 { 6541 struct sock_filter *fp; 6542 int len; 6543 6544 if (tests[which].fill_helper) 6545 return tests[which].u.ptr.len; 6546 6547 fp = tests[which].u.insns; 6548 for (len = MAX_INSNS - 1; len > 0; --len) 6549 if (fp[len].code != 0 || fp[len].k != 0) 6550 break; 6551 6552 return len + 1; 6553 } 6554 6555 static void *filter_pointer(int which) 6556 { 6557 if (tests[which].fill_helper) 6558 return tests[which].u.ptr.insns; 6559 else 6560 return tests[which].u.insns; 6561 } 6562 6563 static struct bpf_prog *generate_filter(int which, int *err) 6564 { 6565 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 6566 unsigned int flen = filter_length(which); 6567 void *fptr = filter_pointer(which); 6568 struct sock_fprog_kern fprog; 6569 struct bpf_prog *fp; 6570 6571 switch (test_type) { 6572 case CLASSIC: 6573 fprog.filter = fptr; 6574 fprog.len = flen; 6575 6576 *err = bpf_prog_create(&fp, &fprog); 6577 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 6578 if (*err == tests[which].expected_errcode) { 6579 pr_cont("PASS\n"); 6580 /* Verifier rejected filter as expected. */ 6581 *err = 0; 6582 return NULL; 6583 } else { 6584 pr_cont("UNEXPECTED_PASS\n"); 6585 /* Verifier didn't reject the test that's 6586 * bad enough, just return! 6587 */ 6588 *err = -EINVAL; 6589 return NULL; 6590 } 6591 } 6592 if (*err) { 6593 pr_cont("FAIL to prog_create err=%d len=%d\n", 6594 *err, fprog.len); 6595 return NULL; 6596 } 6597 break; 6598 6599 case INTERNAL: 6600 fp = bpf_prog_alloc(bpf_prog_size(flen), 0); 6601 if (fp == NULL) { 6602 pr_cont("UNEXPECTED_FAIL no memory left\n"); 6603 *err = -ENOMEM; 6604 return NULL; 6605 } 6606 6607 fp->len = flen; 6608 /* Type doesn't really matter here as long as it's not unspec. */ 6609 fp->type = BPF_PROG_TYPE_SOCKET_FILTER; 6610 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn)); 6611 fp->aux->stack_depth = tests[which].stack_depth; 6612 6613 /* We cannot error here as we don't need type compatibility 6614 * checks. 6615 */ 6616 fp = bpf_prog_select_runtime(fp, err); 6617 if (*err) { 6618 pr_cont("FAIL to select_runtime err=%d\n", *err); 6619 return NULL; 6620 } 6621 break; 6622 } 6623 6624 *err = 0; 6625 return fp; 6626 } 6627 6628 static void release_filter(struct bpf_prog *fp, int which) 6629 { 6630 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 6631 6632 switch (test_type) { 6633 case CLASSIC: 6634 bpf_prog_destroy(fp); 6635 break; 6636 case INTERNAL: 6637 bpf_prog_free(fp); 6638 break; 6639 } 6640 } 6641 6642 static int __run_one(const struct bpf_prog *fp, const void *data, 6643 int runs, u64 *duration) 6644 { 6645 u64 start, finish; 6646 int ret = 0, i; 6647 6648 start = ktime_get_ns(); 6649 6650 for (i = 0; i < runs; i++) 6651 ret = BPF_PROG_RUN(fp, data); 6652 6653 finish = ktime_get_ns(); 6654 6655 *duration = finish - start; 6656 do_div(*duration, runs); 6657 6658 return ret; 6659 } 6660 6661 static int run_one(const struct bpf_prog *fp, struct bpf_test *test) 6662 { 6663 int err_cnt = 0, i, runs = MAX_TESTRUNS; 6664 6665 for (i = 0; i < MAX_SUBTESTS; i++) { 6666 void *data; 6667 u64 duration; 6668 u32 ret; 6669 6670 if (test->test[i].data_size == 0 && 6671 test->test[i].result == 0) 6672 break; 6673 6674 data = generate_test_data(test, i); 6675 if (!data && !(test->aux & FLAG_NO_DATA)) { 6676 pr_cont("data generation failed "); 6677 err_cnt++; 6678 break; 6679 } 6680 ret = __run_one(fp, data, runs, &duration); 6681 release_test_data(test, data); 6682 6683 if (ret == test->test[i].result) { 6684 pr_cont("%lld ", duration); 6685 } else { 6686 pr_cont("ret %d != %d ", ret, 6687 test->test[i].result); 6688 err_cnt++; 6689 } 6690 } 6691 6692 return err_cnt; 6693 } 6694 6695 static char test_name[64]; 6696 module_param_string(test_name, test_name, sizeof(test_name), 0); 6697 6698 static int test_id = -1; 6699 module_param(test_id, int, 0); 6700 6701 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 }; 6702 module_param_array(test_range, int, NULL, 0); 6703 6704 static __init int find_test_index(const char *test_name) 6705 { 6706 int i; 6707 6708 for (i = 0; i < ARRAY_SIZE(tests); i++) { 6709 if (!strcmp(tests[i].descr, test_name)) 6710 return i; 6711 } 6712 return -1; 6713 } 6714 6715 static __init int prepare_bpf_tests(void) 6716 { 6717 int i; 6718 6719 if (test_id >= 0) { 6720 /* 6721 * if a test_id was specified, use test_range to 6722 * cover only that test. 6723 */ 6724 if (test_id >= ARRAY_SIZE(tests)) { 6725 pr_err("test_bpf: invalid test_id specified.\n"); 6726 return -EINVAL; 6727 } 6728 6729 test_range[0] = test_id; 6730 test_range[1] = test_id; 6731 } else if (*test_name) { 6732 /* 6733 * if a test_name was specified, find it and setup 6734 * test_range to cover only that test. 6735 */ 6736 int idx = find_test_index(test_name); 6737 6738 if (idx < 0) { 6739 pr_err("test_bpf: no test named '%s' found.\n", 6740 test_name); 6741 return -EINVAL; 6742 } 6743 test_range[0] = idx; 6744 test_range[1] = idx; 6745 } else { 6746 /* 6747 * check that the supplied test_range is valid. 6748 */ 6749 if (test_range[0] >= ARRAY_SIZE(tests) || 6750 test_range[1] >= ARRAY_SIZE(tests) || 6751 test_range[0] < 0 || test_range[1] < 0) { 6752 pr_err("test_bpf: test_range is out of bound.\n"); 6753 return -EINVAL; 6754 } 6755 6756 if (test_range[1] < test_range[0]) { 6757 pr_err("test_bpf: test_range is ending before it starts.\n"); 6758 return -EINVAL; 6759 } 6760 } 6761 6762 for (i = 0; i < ARRAY_SIZE(tests); i++) { 6763 if (tests[i].fill_helper && 6764 tests[i].fill_helper(&tests[i]) < 0) 6765 return -ENOMEM; 6766 } 6767 6768 return 0; 6769 } 6770 6771 static __init void destroy_bpf_tests(void) 6772 { 6773 int i; 6774 6775 for (i = 0; i < ARRAY_SIZE(tests); i++) { 6776 if (tests[i].fill_helper) 6777 kfree(tests[i].u.ptr.insns); 6778 } 6779 } 6780 6781 static bool exclude_test(int test_id) 6782 { 6783 return test_id < test_range[0] || test_id > test_range[1]; 6784 } 6785 6786 static __init struct sk_buff *build_test_skb(void) 6787 { 6788 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN; 6789 struct sk_buff *skb[2]; 6790 struct page *page[2]; 6791 int i, data_size = 8; 6792 6793 for (i = 0; i < 2; i++) { 6794 page[i] = alloc_page(GFP_KERNEL); 6795 if (!page[i]) { 6796 if (i == 0) 6797 goto err_page0; 6798 else 6799 goto err_page1; 6800 } 6801 6802 /* this will set skb[i]->head_frag */ 6803 skb[i] = dev_alloc_skb(headroom + data_size); 6804 if (!skb[i]) { 6805 if (i == 0) 6806 goto err_skb0; 6807 else 6808 goto err_skb1; 6809 } 6810 6811 skb_reserve(skb[i], headroom); 6812 skb_put(skb[i], data_size); 6813 skb[i]->protocol = htons(ETH_P_IP); 6814 skb_reset_network_header(skb[i]); 6815 skb_set_mac_header(skb[i], -ETH_HLEN); 6816 6817 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64); 6818 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1 6819 } 6820 6821 /* setup shinfo */ 6822 skb_shinfo(skb[0])->gso_size = 1448; 6823 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4; 6824 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY; 6825 skb_shinfo(skb[0])->gso_segs = 0; 6826 skb_shinfo(skb[0])->frag_list = skb[1]; 6827 6828 /* adjust skb[0]'s len */ 6829 skb[0]->len += skb[1]->len; 6830 skb[0]->data_len += skb[1]->data_len; 6831 skb[0]->truesize += skb[1]->truesize; 6832 6833 return skb[0]; 6834 6835 err_skb1: 6836 __free_page(page[1]); 6837 err_page1: 6838 kfree_skb(skb[0]); 6839 err_skb0: 6840 __free_page(page[0]); 6841 err_page0: 6842 return NULL; 6843 } 6844 6845 static __init int test_skb_segment(void) 6846 { 6847 netdev_features_t features; 6848 struct sk_buff *skb, *segs; 6849 int ret = -1; 6850 6851 features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM | 6852 NETIF_F_IPV6_CSUM; 6853 features |= NETIF_F_RXCSUM; 6854 skb = build_test_skb(); 6855 if (!skb) { 6856 pr_info("%s: failed to build_test_skb", __func__); 6857 goto done; 6858 } 6859 6860 segs = skb_segment(skb, features); 6861 if (!IS_ERR(segs)) { 6862 kfree_skb_list(segs); 6863 ret = 0; 6864 pr_info("%s: success in skb_segment!", __func__); 6865 } else { 6866 pr_info("%s: failed in skb_segment!", __func__); 6867 } 6868 kfree_skb(skb); 6869 done: 6870 return ret; 6871 } 6872 6873 static __init int test_bpf(void) 6874 { 6875 int i, err_cnt = 0, pass_cnt = 0; 6876 int jit_cnt = 0, run_cnt = 0; 6877 6878 for (i = 0; i < ARRAY_SIZE(tests); i++) { 6879 struct bpf_prog *fp; 6880 int err; 6881 6882 cond_resched(); 6883 if (exclude_test(i)) 6884 continue; 6885 6886 pr_info("#%d %s ", i, tests[i].descr); 6887 6888 fp = generate_filter(i, &err); 6889 if (fp == NULL) { 6890 if (err == 0) { 6891 pass_cnt++; 6892 continue; 6893 } 6894 err_cnt++; 6895 continue; 6896 } 6897 6898 pr_cont("jited:%u ", fp->jited); 6899 6900 run_cnt++; 6901 if (fp->jited) 6902 jit_cnt++; 6903 6904 err = run_one(fp, &tests[i]); 6905 release_filter(fp, i); 6906 6907 if (err) { 6908 pr_cont("FAIL (%d times)\n", err); 6909 err_cnt++; 6910 } else { 6911 pr_cont("PASS\n"); 6912 pass_cnt++; 6913 } 6914 } 6915 6916 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 6917 pass_cnt, err_cnt, jit_cnt, run_cnt); 6918 6919 return err_cnt ? -EINVAL : 0; 6920 } 6921 6922 static int __init test_bpf_init(void) 6923 { 6924 int ret; 6925 6926 ret = prepare_bpf_tests(); 6927 if (ret < 0) 6928 return ret; 6929 6930 ret = test_bpf(); 6931 destroy_bpf_tests(); 6932 if (ret) 6933 return ret; 6934 6935 return test_skb_segment(); 6936 } 6937 6938 static void __exit test_bpf_exit(void) 6939 { 6940 } 6941 6942 module_init(test_bpf_init); 6943 module_exit(test_bpf_exit); 6944 6945 MODULE_LICENSE("GPL"); 6946