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