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