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/skbuff.h> 22 #include <linux/netdevice.h> 23 #include <linux/if_vlan.h> 24 #include <linux/random.h> 25 26 /* General test specific settings */ 27 #define MAX_SUBTESTS 3 28 #define MAX_TESTRUNS 10000 29 #define MAX_DATA 128 30 #define MAX_INSNS 512 31 #define MAX_K 0xffffFFFF 32 33 /* Few constants used to init test 'skb' */ 34 #define SKB_TYPE 3 35 #define SKB_MARK 0x1234aaaa 36 #define SKB_HASH 0x1234aaab 37 #define SKB_QUEUE_MAP 123 38 #define SKB_VLAN_TCI 0xffff 39 #define SKB_DEV_IFINDEX 577 40 #define SKB_DEV_TYPE 588 41 42 /* Redefine REGs to make tests less verbose */ 43 #define R0 BPF_REG_0 44 #define R1 BPF_REG_1 45 #define R2 BPF_REG_2 46 #define R3 BPF_REG_3 47 #define R4 BPF_REG_4 48 #define R5 BPF_REG_5 49 #define R6 BPF_REG_6 50 #define R7 BPF_REG_7 51 #define R8 BPF_REG_8 52 #define R9 BPF_REG_9 53 #define R10 BPF_REG_10 54 55 /* Flags that can be passed to test cases */ 56 #define FLAG_NO_DATA BIT(0) 57 #define FLAG_EXPECTED_FAIL BIT(1) 58 59 enum { 60 CLASSIC = BIT(6), /* Old BPF instructions only. */ 61 INTERNAL = BIT(7), /* Extended instruction set. */ 62 }; 63 64 #define TEST_TYPE_MASK (CLASSIC | INTERNAL) 65 66 struct bpf_test { 67 const char *descr; 68 union { 69 struct sock_filter insns[MAX_INSNS]; 70 struct bpf_insn insns_int[MAX_INSNS]; 71 struct { 72 void *insns; 73 unsigned int len; 74 } ptr; 75 } u; 76 __u8 aux; 77 __u8 data[MAX_DATA]; 78 struct { 79 int data_size; 80 __u32 result; 81 } test[MAX_SUBTESTS]; 82 int (*fill_helper)(struct bpf_test *self); 83 }; 84 85 /* Large test cases need separate allocation and fill handler. */ 86 87 static int bpf_fill_maxinsns1(struct bpf_test *self) 88 { 89 unsigned int len = BPF_MAXINSNS; 90 struct sock_filter *insn; 91 __u32 k = ~0; 92 int i; 93 94 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 95 if (!insn) 96 return -ENOMEM; 97 98 for (i = 0; i < len; i++, k--) 99 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k); 100 101 self->u.ptr.insns = insn; 102 self->u.ptr.len = len; 103 104 return 0; 105 } 106 107 static int bpf_fill_maxinsns2(struct bpf_test *self) 108 { 109 unsigned int len = BPF_MAXINSNS; 110 struct sock_filter *insn; 111 int i; 112 113 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 114 if (!insn) 115 return -ENOMEM; 116 117 for (i = 0; i < len; i++) 118 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 119 120 self->u.ptr.insns = insn; 121 self->u.ptr.len = len; 122 123 return 0; 124 } 125 126 static int bpf_fill_maxinsns3(struct bpf_test *self) 127 { 128 unsigned int len = BPF_MAXINSNS; 129 struct sock_filter *insn; 130 struct rnd_state rnd; 131 int i; 132 133 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 134 if (!insn) 135 return -ENOMEM; 136 137 prandom_seed_state(&rnd, 3141592653589793238ULL); 138 139 for (i = 0; i < len - 1; i++) { 140 __u32 k = prandom_u32_state(&rnd); 141 142 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k); 143 } 144 145 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 146 147 self->u.ptr.insns = insn; 148 self->u.ptr.len = len; 149 150 return 0; 151 } 152 153 static int bpf_fill_maxinsns4(struct bpf_test *self) 154 { 155 unsigned int len = BPF_MAXINSNS + 1; 156 struct sock_filter *insn; 157 int i; 158 159 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 160 if (!insn) 161 return -ENOMEM; 162 163 for (i = 0; i < len; i++) 164 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 165 166 self->u.ptr.insns = insn; 167 self->u.ptr.len = len; 168 169 return 0; 170 } 171 172 static int bpf_fill_maxinsns5(struct bpf_test *self) 173 { 174 unsigned int len = BPF_MAXINSNS; 175 struct sock_filter *insn; 176 int i; 177 178 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 179 if (!insn) 180 return -ENOMEM; 181 182 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0); 183 184 for (i = 1; i < len - 1; i++) 185 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe); 186 187 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab); 188 189 self->u.ptr.insns = insn; 190 self->u.ptr.len = len; 191 192 return 0; 193 } 194 195 static int bpf_fill_maxinsns6(struct bpf_test *self) 196 { 197 unsigned int len = BPF_MAXINSNS; 198 struct sock_filter *insn; 199 int i; 200 201 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 202 if (!insn) 203 return -ENOMEM; 204 205 for (i = 0; i < len - 1; i++) 206 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 207 SKF_AD_VLAN_TAG_PRESENT); 208 209 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 210 211 self->u.ptr.insns = insn; 212 self->u.ptr.len = len; 213 214 return 0; 215 } 216 217 static int bpf_fill_maxinsns7(struct bpf_test *self) 218 { 219 unsigned int len = BPF_MAXINSNS; 220 struct sock_filter *insn; 221 int i; 222 223 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 224 if (!insn) 225 return -ENOMEM; 226 227 for (i = 0; i < len - 4; i++) 228 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 229 SKF_AD_CPU); 230 231 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0); 232 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF + 233 SKF_AD_CPU); 234 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0); 235 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 236 237 self->u.ptr.insns = insn; 238 self->u.ptr.len = len; 239 240 return 0; 241 } 242 243 static int bpf_fill_maxinsns8(struct bpf_test *self) 244 { 245 unsigned int len = BPF_MAXINSNS; 246 struct sock_filter *insn; 247 int i, jmp_off = len - 3; 248 249 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL); 250 if (!insn) 251 return -ENOMEM; 252 253 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff); 254 255 for (i = 1; i < len - 1; i++) 256 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0); 257 258 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0); 259 260 self->u.ptr.insns = insn; 261 self->u.ptr.len = len; 262 263 return 0; 264 } 265 266 static struct bpf_test tests[] = { 267 { 268 "TAX", 269 .u.insns = { 270 BPF_STMT(BPF_LD | BPF_IMM, 1), 271 BPF_STMT(BPF_MISC | BPF_TAX, 0), 272 BPF_STMT(BPF_LD | BPF_IMM, 2), 273 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 274 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */ 275 BPF_STMT(BPF_MISC | BPF_TAX, 0), 276 BPF_STMT(BPF_LD | BPF_LEN, 0), 277 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 278 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */ 279 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1), 280 BPF_STMT(BPF_RET | BPF_A, 0) 281 }, 282 CLASSIC, 283 { 10, 20, 30, 40, 50 }, 284 { { 2, 10 }, { 3, 20 }, { 4, 30 } }, 285 }, 286 { 287 "TXA", 288 .u.insns = { 289 BPF_STMT(BPF_LDX | BPF_LEN, 0), 290 BPF_STMT(BPF_MISC | BPF_TXA, 0), 291 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 292 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */ 293 }, 294 CLASSIC, 295 { 10, 20, 30, 40, 50 }, 296 { { 1, 2 }, { 3, 6 }, { 4, 8 } }, 297 }, 298 { 299 "ADD_SUB_MUL_K", 300 .u.insns = { 301 BPF_STMT(BPF_LD | BPF_IMM, 1), 302 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2), 303 BPF_STMT(BPF_LDX | BPF_IMM, 3), 304 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 305 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff), 306 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3), 307 BPF_STMT(BPF_RET | BPF_A, 0) 308 }, 309 CLASSIC | FLAG_NO_DATA, 310 { }, 311 { { 0, 0xfffffffd } } 312 }, 313 { 314 "DIV_MOD_KX", 315 .u.insns = { 316 BPF_STMT(BPF_LD | BPF_IMM, 8), 317 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2), 318 BPF_STMT(BPF_MISC | BPF_TAX, 0), 319 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 320 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0), 321 BPF_STMT(BPF_MISC | BPF_TAX, 0), 322 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 323 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000), 324 BPF_STMT(BPF_MISC | BPF_TAX, 0), 325 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 326 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0), 327 BPF_STMT(BPF_MISC | BPF_TAX, 0), 328 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff), 329 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000), 330 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 331 BPF_STMT(BPF_RET | BPF_A, 0) 332 }, 333 CLASSIC | FLAG_NO_DATA, 334 { }, 335 { { 0, 0x20000000 } } 336 }, 337 { 338 "AND_OR_LSH_K", 339 .u.insns = { 340 BPF_STMT(BPF_LD | BPF_IMM, 0xff), 341 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 342 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27), 343 BPF_STMT(BPF_MISC | BPF_TAX, 0), 344 BPF_STMT(BPF_LD | BPF_IMM, 0xf), 345 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0), 346 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 347 BPF_STMT(BPF_RET | BPF_A, 0) 348 }, 349 CLASSIC | FLAG_NO_DATA, 350 { }, 351 { { 0, 0x800000ff }, { 1, 0x800000ff } }, 352 }, 353 { 354 "LD_IMM_0", 355 .u.insns = { 356 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */ 357 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), 358 BPF_STMT(BPF_RET | BPF_K, 0), 359 BPF_STMT(BPF_RET | BPF_K, 1), 360 }, 361 CLASSIC, 362 { }, 363 { { 1, 1 } }, 364 }, 365 { 366 "LD_IND", 367 .u.insns = { 368 BPF_STMT(BPF_LDX | BPF_LEN, 0), 369 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K), 370 BPF_STMT(BPF_RET | BPF_K, 1) 371 }, 372 CLASSIC, 373 { }, 374 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 375 }, 376 { 377 "LD_ABS", 378 .u.insns = { 379 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000), 380 BPF_STMT(BPF_RET | BPF_K, 1) 381 }, 382 CLASSIC, 383 { }, 384 { { 1, 0 }, { 10, 0 }, { 60, 0 } }, 385 }, 386 { 387 "LD_ABS_LL", 388 .u.insns = { 389 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF), 390 BPF_STMT(BPF_MISC | BPF_TAX, 0), 391 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1), 392 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 393 BPF_STMT(BPF_RET | BPF_A, 0) 394 }, 395 CLASSIC, 396 { 1, 2, 3 }, 397 { { 1, 0 }, { 2, 3 } }, 398 }, 399 { 400 "LD_IND_LL", 401 .u.insns = { 402 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1), 403 BPF_STMT(BPF_LDX | BPF_LEN, 0), 404 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 405 BPF_STMT(BPF_MISC | BPF_TAX, 0), 406 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 407 BPF_STMT(BPF_RET | BPF_A, 0) 408 }, 409 CLASSIC, 410 { 1, 2, 3, 0xff }, 411 { { 1, 1 }, { 3, 3 }, { 4, 0xff } }, 412 }, 413 { 414 "LD_ABS_NET", 415 .u.insns = { 416 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF), 417 BPF_STMT(BPF_MISC | BPF_TAX, 0), 418 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1), 419 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 420 BPF_STMT(BPF_RET | BPF_A, 0) 421 }, 422 CLASSIC, 423 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 424 { { 15, 0 }, { 16, 3 } }, 425 }, 426 { 427 "LD_IND_NET", 428 .u.insns = { 429 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15), 430 BPF_STMT(BPF_LDX | BPF_LEN, 0), 431 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 432 BPF_STMT(BPF_MISC | BPF_TAX, 0), 433 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0), 434 BPF_STMT(BPF_RET | BPF_A, 0) 435 }, 436 CLASSIC, 437 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 }, 438 { { 14, 0 }, { 15, 1 }, { 17, 3 } }, 439 }, 440 { 441 "LD_PKTTYPE", 442 .u.insns = { 443 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 444 SKF_AD_OFF + SKF_AD_PKTTYPE), 445 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 446 BPF_STMT(BPF_RET | BPF_K, 1), 447 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 448 SKF_AD_OFF + SKF_AD_PKTTYPE), 449 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 450 BPF_STMT(BPF_RET | BPF_K, 1), 451 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 452 SKF_AD_OFF + SKF_AD_PKTTYPE), 453 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0), 454 BPF_STMT(BPF_RET | BPF_K, 1), 455 BPF_STMT(BPF_RET | BPF_A, 0) 456 }, 457 CLASSIC, 458 { }, 459 { { 1, 3 }, { 10, 3 } }, 460 }, 461 { 462 "LD_MARK", 463 .u.insns = { 464 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 465 SKF_AD_OFF + SKF_AD_MARK), 466 BPF_STMT(BPF_RET | BPF_A, 0) 467 }, 468 CLASSIC, 469 { }, 470 { { 1, SKB_MARK}, { 10, SKB_MARK} }, 471 }, 472 { 473 "LD_RXHASH", 474 .u.insns = { 475 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 476 SKF_AD_OFF + SKF_AD_RXHASH), 477 BPF_STMT(BPF_RET | BPF_A, 0) 478 }, 479 CLASSIC, 480 { }, 481 { { 1, SKB_HASH}, { 10, SKB_HASH} }, 482 }, 483 { 484 "LD_QUEUE", 485 .u.insns = { 486 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 487 SKF_AD_OFF + SKF_AD_QUEUE), 488 BPF_STMT(BPF_RET | BPF_A, 0) 489 }, 490 CLASSIC, 491 { }, 492 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } }, 493 }, 494 { 495 "LD_PROTOCOL", 496 .u.insns = { 497 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1), 498 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0), 499 BPF_STMT(BPF_RET | BPF_K, 0), 500 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 501 SKF_AD_OFF + SKF_AD_PROTOCOL), 502 BPF_STMT(BPF_MISC | BPF_TAX, 0), 503 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 504 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0), 505 BPF_STMT(BPF_RET | BPF_K, 0), 506 BPF_STMT(BPF_MISC | BPF_TXA, 0), 507 BPF_STMT(BPF_RET | BPF_A, 0) 508 }, 509 CLASSIC, 510 { 10, 20, 30 }, 511 { { 10, ETH_P_IP }, { 100, ETH_P_IP } }, 512 }, 513 { 514 "LD_VLAN_TAG", 515 .u.insns = { 516 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 517 SKF_AD_OFF + SKF_AD_VLAN_TAG), 518 BPF_STMT(BPF_RET | BPF_A, 0) 519 }, 520 CLASSIC, 521 { }, 522 { 523 { 1, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT }, 524 { 10, SKB_VLAN_TCI & ~VLAN_TAG_PRESENT } 525 }, 526 }, 527 { 528 "LD_VLAN_TAG_PRESENT", 529 .u.insns = { 530 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 531 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), 532 BPF_STMT(BPF_RET | BPF_A, 0) 533 }, 534 CLASSIC, 535 { }, 536 { 537 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }, 538 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) } 539 }, 540 }, 541 { 542 "LD_IFINDEX", 543 .u.insns = { 544 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 545 SKF_AD_OFF + SKF_AD_IFINDEX), 546 BPF_STMT(BPF_RET | BPF_A, 0) 547 }, 548 CLASSIC, 549 { }, 550 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } }, 551 }, 552 { 553 "LD_HATYPE", 554 .u.insns = { 555 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 556 SKF_AD_OFF + SKF_AD_HATYPE), 557 BPF_STMT(BPF_RET | BPF_A, 0) 558 }, 559 CLASSIC, 560 { }, 561 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } }, 562 }, 563 { 564 "LD_CPU", 565 .u.insns = { 566 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 567 SKF_AD_OFF + SKF_AD_CPU), 568 BPF_STMT(BPF_MISC | BPF_TAX, 0), 569 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 570 SKF_AD_OFF + SKF_AD_CPU), 571 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 572 BPF_STMT(BPF_RET | BPF_A, 0) 573 }, 574 CLASSIC, 575 { }, 576 { { 1, 0 }, { 10, 0 } }, 577 }, 578 { 579 "LD_NLATTR", 580 .u.insns = { 581 BPF_STMT(BPF_LDX | BPF_IMM, 2), 582 BPF_STMT(BPF_MISC | BPF_TXA, 0), 583 BPF_STMT(BPF_LDX | BPF_IMM, 3), 584 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 585 SKF_AD_OFF + SKF_AD_NLATTR), 586 BPF_STMT(BPF_RET | BPF_A, 0) 587 }, 588 CLASSIC, 589 #ifdef __BIG_ENDIAN 590 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 }, 591 #else 592 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 }, 593 #endif 594 { { 4, 0 }, { 20, 6 } }, 595 }, 596 { 597 "LD_NLATTR_NEST", 598 .u.insns = { 599 BPF_STMT(BPF_LD | BPF_IMM, 2), 600 BPF_STMT(BPF_LDX | BPF_IMM, 3), 601 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 602 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 603 BPF_STMT(BPF_LD | BPF_IMM, 2), 604 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 605 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 606 BPF_STMT(BPF_LD | BPF_IMM, 2), 607 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 608 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 609 BPF_STMT(BPF_LD | BPF_IMM, 2), 610 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 611 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 612 BPF_STMT(BPF_LD | BPF_IMM, 2), 613 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 614 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 615 BPF_STMT(BPF_LD | BPF_IMM, 2), 616 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 617 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 618 BPF_STMT(BPF_LD | BPF_IMM, 2), 619 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 620 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 621 BPF_STMT(BPF_LD | BPF_IMM, 2), 622 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 623 SKF_AD_OFF + SKF_AD_NLATTR_NEST), 624 BPF_STMT(BPF_RET | BPF_A, 0) 625 }, 626 CLASSIC, 627 #ifdef __BIG_ENDIAN 628 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 }, 629 #else 630 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 }, 631 #endif 632 { { 4, 0 }, { 20, 10 } }, 633 }, 634 { 635 "LD_PAYLOAD_OFF", 636 .u.insns = { 637 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 638 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 639 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 640 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 641 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 642 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 643 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 644 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 645 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 646 SKF_AD_OFF + SKF_AD_PAY_OFFSET), 647 BPF_STMT(BPF_RET | BPF_A, 0) 648 }, 649 CLASSIC, 650 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800), 651 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request, 652 * id 9737, seq 1, length 64 653 */ 654 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 656 0x08, 0x00, 657 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40, 658 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 }, 659 { { 30, 0 }, { 100, 42 } }, 660 }, 661 { 662 "LD_ANC_XOR", 663 .u.insns = { 664 BPF_STMT(BPF_LD | BPF_IMM, 10), 665 BPF_STMT(BPF_LDX | BPF_IMM, 300), 666 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 667 SKF_AD_OFF + SKF_AD_ALU_XOR_X), 668 BPF_STMT(BPF_RET | BPF_A, 0) 669 }, 670 CLASSIC, 671 { }, 672 { { 4, 10 ^ 300 }, { 20, 10 ^ 300 } }, 673 }, 674 { 675 "SPILL_FILL", 676 .u.insns = { 677 BPF_STMT(BPF_LDX | BPF_LEN, 0), 678 BPF_STMT(BPF_LD | BPF_IMM, 2), 679 BPF_STMT(BPF_ALU | BPF_RSH, 1), 680 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 681 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */ 682 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000), 683 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */ 684 BPF_STMT(BPF_STX, 15), /* M3 = len */ 685 BPF_STMT(BPF_LDX | BPF_MEM, 1), 686 BPF_STMT(BPF_LD | BPF_MEM, 2), 687 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 688 BPF_STMT(BPF_LDX | BPF_MEM, 15), 689 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0), 690 BPF_STMT(BPF_RET | BPF_A, 0) 691 }, 692 CLASSIC, 693 { }, 694 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } } 695 }, 696 { 697 "JEQ", 698 .u.insns = { 699 BPF_STMT(BPF_LDX | BPF_LEN, 0), 700 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 701 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1), 702 BPF_STMT(BPF_RET | BPF_K, 1), 703 BPF_STMT(BPF_RET | BPF_K, MAX_K) 704 }, 705 CLASSIC, 706 { 3, 3, 3, 3, 3 }, 707 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } }, 708 }, 709 { 710 "JGT", 711 .u.insns = { 712 BPF_STMT(BPF_LDX | BPF_LEN, 0), 713 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2), 714 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1), 715 BPF_STMT(BPF_RET | BPF_K, 1), 716 BPF_STMT(BPF_RET | BPF_K, MAX_K) 717 }, 718 CLASSIC, 719 { 4, 4, 4, 3, 3 }, 720 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } }, 721 }, 722 { 723 "JGE", 724 .u.insns = { 725 BPF_STMT(BPF_LDX | BPF_LEN, 0), 726 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K), 727 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0), 728 BPF_STMT(BPF_RET | BPF_K, 10), 729 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0), 730 BPF_STMT(BPF_RET | BPF_K, 20), 731 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0), 732 BPF_STMT(BPF_RET | BPF_K, 30), 733 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0), 734 BPF_STMT(BPF_RET | BPF_K, 40), 735 BPF_STMT(BPF_RET | BPF_K, MAX_K) 736 }, 737 CLASSIC, 738 { 1, 2, 3, 4, 5 }, 739 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } }, 740 }, 741 { 742 "JSET", 743 .u.insns = { 744 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 745 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1), 746 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 747 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0), 748 BPF_STMT(BPF_LDX | BPF_LEN, 0), 749 BPF_STMT(BPF_MISC | BPF_TXA, 0), 750 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4), 751 BPF_STMT(BPF_MISC | BPF_TAX, 0), 752 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0), 753 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1), 754 BPF_STMT(BPF_RET | BPF_K, 10), 755 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1), 756 BPF_STMT(BPF_RET | BPF_K, 20), 757 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 758 BPF_STMT(BPF_RET | BPF_K, 30), 759 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 760 BPF_STMT(BPF_RET | BPF_K, 30), 761 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 762 BPF_STMT(BPF_RET | BPF_K, 30), 763 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 764 BPF_STMT(BPF_RET | BPF_K, 30), 765 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0), 766 BPF_STMT(BPF_RET | BPF_K, 30), 767 BPF_STMT(BPF_RET | BPF_K, MAX_K) 768 }, 769 CLASSIC, 770 { 0, 0xAA, 0x55, 1 }, 771 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } }, 772 }, 773 { 774 "tcpdump port 22", 775 .u.insns = { 776 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 777 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */ 778 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20), 779 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 780 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 781 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17), 782 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54), 783 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0), 784 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56), 785 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13), 786 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */ 787 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 788 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0), 789 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0), 790 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8), 791 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 792 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0), 793 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 794 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 795 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 796 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 797 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1), 798 BPF_STMT(BPF_RET | BPF_K, 0xffff), 799 BPF_STMT(BPF_RET | BPF_K, 0), 800 }, 801 CLASSIC, 802 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800) 803 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.], 804 * seq 1305692979:1305693027, ack 3650467037, win 65535, 805 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48 806 */ 807 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 808 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 809 0x08, 0x00, 810 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 811 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 812 0x0a, 0x01, 0x01, 0x95, /* ip src */ 813 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 814 0xc2, 0x24, 815 0x00, 0x16 /* dst port */ }, 816 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 817 }, 818 { 819 "tcpdump complex", 820 .u.insns = { 821 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] - 822 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and 823 * (len > 115 or len < 30000000000)' -d 824 */ 825 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 826 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0), 827 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29), 828 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23), 829 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27), 830 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 831 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0), 832 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 833 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14), 834 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0), 835 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16), 836 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20), 837 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16), 838 BPF_STMT(BPF_ST, 1), 839 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14), 840 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf), 841 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2), 842 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */ 843 BPF_STMT(BPF_LD | BPF_MEM, 1), 844 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0), 845 BPF_STMT(BPF_ST, 5), 846 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14), 847 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26), 848 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0), 849 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2), 850 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */ 851 BPF_STMT(BPF_LD | BPF_MEM, 5), 852 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0), 853 BPF_STMT(BPF_LD | BPF_LEN, 0), 854 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0), 855 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0), 856 BPF_STMT(BPF_RET | BPF_K, 0xffff), 857 BPF_STMT(BPF_RET | BPF_K, 0), 858 }, 859 CLASSIC, 860 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6, 861 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76, 862 0x08, 0x00, 863 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5, 864 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */ 865 0x0a, 0x01, 0x01, 0x95, /* ip src */ 866 0x0a, 0x01, 0x02, 0x0a, /* ip dst */ 867 0xc2, 0x24, 868 0x00, 0x16 /* dst port */ }, 869 { { 10, 0 }, { 30, 0 }, { 100, 65535 } }, 870 }, 871 { 872 "RET_A", 873 .u.insns = { 874 /* check that unitialized X and A contain zeros */ 875 BPF_STMT(BPF_MISC | BPF_TXA, 0), 876 BPF_STMT(BPF_RET | BPF_A, 0) 877 }, 878 CLASSIC, 879 { }, 880 { {1, 0}, {2, 0} }, 881 }, 882 { 883 "INT: ADD trivial", 884 .u.insns_int = { 885 BPF_ALU64_IMM(BPF_MOV, R1, 1), 886 BPF_ALU64_IMM(BPF_ADD, R1, 2), 887 BPF_ALU64_IMM(BPF_MOV, R2, 3), 888 BPF_ALU64_REG(BPF_SUB, R1, R2), 889 BPF_ALU64_IMM(BPF_ADD, R1, -1), 890 BPF_ALU64_IMM(BPF_MUL, R1, 3), 891 BPF_ALU64_REG(BPF_MOV, R0, R1), 892 BPF_EXIT_INSN(), 893 }, 894 INTERNAL, 895 { }, 896 { { 0, 0xfffffffd } } 897 }, 898 { 899 "INT: MUL_X", 900 .u.insns_int = { 901 BPF_ALU64_IMM(BPF_MOV, R0, -1), 902 BPF_ALU64_IMM(BPF_MOV, R1, -1), 903 BPF_ALU64_IMM(BPF_MOV, R2, 3), 904 BPF_ALU64_REG(BPF_MUL, R1, R2), 905 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1), 906 BPF_EXIT_INSN(), 907 BPF_ALU64_IMM(BPF_MOV, R0, 1), 908 BPF_EXIT_INSN(), 909 }, 910 INTERNAL, 911 { }, 912 { { 0, 1 } } 913 }, 914 { 915 "INT: MUL_X2", 916 .u.insns_int = { 917 BPF_ALU32_IMM(BPF_MOV, R0, -1), 918 BPF_ALU32_IMM(BPF_MOV, R1, -1), 919 BPF_ALU32_IMM(BPF_MOV, R2, 3), 920 BPF_ALU64_REG(BPF_MUL, R1, R2), 921 BPF_ALU64_IMM(BPF_RSH, R1, 8), 922 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1), 923 BPF_EXIT_INSN(), 924 BPF_ALU32_IMM(BPF_MOV, R0, 1), 925 BPF_EXIT_INSN(), 926 }, 927 INTERNAL, 928 { }, 929 { { 0, 1 } } 930 }, 931 { 932 "INT: MUL32_X", 933 .u.insns_int = { 934 BPF_ALU32_IMM(BPF_MOV, R0, -1), 935 BPF_ALU64_IMM(BPF_MOV, R1, -1), 936 BPF_ALU32_IMM(BPF_MOV, R2, 3), 937 BPF_ALU32_REG(BPF_MUL, R1, R2), 938 BPF_ALU64_IMM(BPF_RSH, R1, 8), 939 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1), 940 BPF_EXIT_INSN(), 941 BPF_ALU32_IMM(BPF_MOV, R0, 1), 942 BPF_EXIT_INSN(), 943 }, 944 INTERNAL, 945 { }, 946 { { 0, 1 } } 947 }, 948 { 949 /* Have to test all register combinations, since 950 * JITing of different registers will produce 951 * different asm code. 952 */ 953 "INT: ADD 64-bit", 954 .u.insns_int = { 955 BPF_ALU64_IMM(BPF_MOV, R0, 0), 956 BPF_ALU64_IMM(BPF_MOV, R1, 1), 957 BPF_ALU64_IMM(BPF_MOV, R2, 2), 958 BPF_ALU64_IMM(BPF_MOV, R3, 3), 959 BPF_ALU64_IMM(BPF_MOV, R4, 4), 960 BPF_ALU64_IMM(BPF_MOV, R5, 5), 961 BPF_ALU64_IMM(BPF_MOV, R6, 6), 962 BPF_ALU64_IMM(BPF_MOV, R7, 7), 963 BPF_ALU64_IMM(BPF_MOV, R8, 8), 964 BPF_ALU64_IMM(BPF_MOV, R9, 9), 965 BPF_ALU64_IMM(BPF_ADD, R0, 20), 966 BPF_ALU64_IMM(BPF_ADD, R1, 20), 967 BPF_ALU64_IMM(BPF_ADD, R2, 20), 968 BPF_ALU64_IMM(BPF_ADD, R3, 20), 969 BPF_ALU64_IMM(BPF_ADD, R4, 20), 970 BPF_ALU64_IMM(BPF_ADD, R5, 20), 971 BPF_ALU64_IMM(BPF_ADD, R6, 20), 972 BPF_ALU64_IMM(BPF_ADD, R7, 20), 973 BPF_ALU64_IMM(BPF_ADD, R8, 20), 974 BPF_ALU64_IMM(BPF_ADD, R9, 20), 975 BPF_ALU64_IMM(BPF_SUB, R0, 10), 976 BPF_ALU64_IMM(BPF_SUB, R1, 10), 977 BPF_ALU64_IMM(BPF_SUB, R2, 10), 978 BPF_ALU64_IMM(BPF_SUB, R3, 10), 979 BPF_ALU64_IMM(BPF_SUB, R4, 10), 980 BPF_ALU64_IMM(BPF_SUB, R5, 10), 981 BPF_ALU64_IMM(BPF_SUB, R6, 10), 982 BPF_ALU64_IMM(BPF_SUB, R7, 10), 983 BPF_ALU64_IMM(BPF_SUB, R8, 10), 984 BPF_ALU64_IMM(BPF_SUB, R9, 10), 985 BPF_ALU64_REG(BPF_ADD, R0, R0), 986 BPF_ALU64_REG(BPF_ADD, R0, R1), 987 BPF_ALU64_REG(BPF_ADD, R0, R2), 988 BPF_ALU64_REG(BPF_ADD, R0, R3), 989 BPF_ALU64_REG(BPF_ADD, R0, R4), 990 BPF_ALU64_REG(BPF_ADD, R0, R5), 991 BPF_ALU64_REG(BPF_ADD, R0, R6), 992 BPF_ALU64_REG(BPF_ADD, R0, R7), 993 BPF_ALU64_REG(BPF_ADD, R0, R8), 994 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 995 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 996 BPF_EXIT_INSN(), 997 BPF_ALU64_REG(BPF_ADD, R1, R0), 998 BPF_ALU64_REG(BPF_ADD, R1, R1), 999 BPF_ALU64_REG(BPF_ADD, R1, R2), 1000 BPF_ALU64_REG(BPF_ADD, R1, R3), 1001 BPF_ALU64_REG(BPF_ADD, R1, R4), 1002 BPF_ALU64_REG(BPF_ADD, R1, R5), 1003 BPF_ALU64_REG(BPF_ADD, R1, R6), 1004 BPF_ALU64_REG(BPF_ADD, R1, R7), 1005 BPF_ALU64_REG(BPF_ADD, R1, R8), 1006 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 1007 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 1008 BPF_EXIT_INSN(), 1009 BPF_ALU64_REG(BPF_ADD, R2, R0), 1010 BPF_ALU64_REG(BPF_ADD, R2, R1), 1011 BPF_ALU64_REG(BPF_ADD, R2, R2), 1012 BPF_ALU64_REG(BPF_ADD, R2, R3), 1013 BPF_ALU64_REG(BPF_ADD, R2, R4), 1014 BPF_ALU64_REG(BPF_ADD, R2, R5), 1015 BPF_ALU64_REG(BPF_ADD, R2, R6), 1016 BPF_ALU64_REG(BPF_ADD, R2, R7), 1017 BPF_ALU64_REG(BPF_ADD, R2, R8), 1018 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 1019 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 1020 BPF_EXIT_INSN(), 1021 BPF_ALU64_REG(BPF_ADD, R3, R0), 1022 BPF_ALU64_REG(BPF_ADD, R3, R1), 1023 BPF_ALU64_REG(BPF_ADD, R3, R2), 1024 BPF_ALU64_REG(BPF_ADD, R3, R3), 1025 BPF_ALU64_REG(BPF_ADD, R3, R4), 1026 BPF_ALU64_REG(BPF_ADD, R3, R5), 1027 BPF_ALU64_REG(BPF_ADD, R3, R6), 1028 BPF_ALU64_REG(BPF_ADD, R3, R7), 1029 BPF_ALU64_REG(BPF_ADD, R3, R8), 1030 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 1031 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 1032 BPF_EXIT_INSN(), 1033 BPF_ALU64_REG(BPF_ADD, R4, R0), 1034 BPF_ALU64_REG(BPF_ADD, R4, R1), 1035 BPF_ALU64_REG(BPF_ADD, R4, R2), 1036 BPF_ALU64_REG(BPF_ADD, R4, R3), 1037 BPF_ALU64_REG(BPF_ADD, R4, R4), 1038 BPF_ALU64_REG(BPF_ADD, R4, R5), 1039 BPF_ALU64_REG(BPF_ADD, R4, R6), 1040 BPF_ALU64_REG(BPF_ADD, R4, R7), 1041 BPF_ALU64_REG(BPF_ADD, R4, R8), 1042 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 1043 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 1044 BPF_EXIT_INSN(), 1045 BPF_ALU64_REG(BPF_ADD, R5, R0), 1046 BPF_ALU64_REG(BPF_ADD, R5, R1), 1047 BPF_ALU64_REG(BPF_ADD, R5, R2), 1048 BPF_ALU64_REG(BPF_ADD, R5, R3), 1049 BPF_ALU64_REG(BPF_ADD, R5, R4), 1050 BPF_ALU64_REG(BPF_ADD, R5, R5), 1051 BPF_ALU64_REG(BPF_ADD, R5, R6), 1052 BPF_ALU64_REG(BPF_ADD, R5, R7), 1053 BPF_ALU64_REG(BPF_ADD, R5, R8), 1054 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 1055 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 1056 BPF_EXIT_INSN(), 1057 BPF_ALU64_REG(BPF_ADD, R6, R0), 1058 BPF_ALU64_REG(BPF_ADD, R6, R1), 1059 BPF_ALU64_REG(BPF_ADD, R6, R2), 1060 BPF_ALU64_REG(BPF_ADD, R6, R3), 1061 BPF_ALU64_REG(BPF_ADD, R6, R4), 1062 BPF_ALU64_REG(BPF_ADD, R6, R5), 1063 BPF_ALU64_REG(BPF_ADD, R6, R6), 1064 BPF_ALU64_REG(BPF_ADD, R6, R7), 1065 BPF_ALU64_REG(BPF_ADD, R6, R8), 1066 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 1067 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 1068 BPF_EXIT_INSN(), 1069 BPF_ALU64_REG(BPF_ADD, R7, R0), 1070 BPF_ALU64_REG(BPF_ADD, R7, R1), 1071 BPF_ALU64_REG(BPF_ADD, R7, R2), 1072 BPF_ALU64_REG(BPF_ADD, R7, R3), 1073 BPF_ALU64_REG(BPF_ADD, R7, R4), 1074 BPF_ALU64_REG(BPF_ADD, R7, R5), 1075 BPF_ALU64_REG(BPF_ADD, R7, R6), 1076 BPF_ALU64_REG(BPF_ADD, R7, R7), 1077 BPF_ALU64_REG(BPF_ADD, R7, R8), 1078 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 1079 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 1080 BPF_EXIT_INSN(), 1081 BPF_ALU64_REG(BPF_ADD, R8, R0), 1082 BPF_ALU64_REG(BPF_ADD, R8, R1), 1083 BPF_ALU64_REG(BPF_ADD, R8, R2), 1084 BPF_ALU64_REG(BPF_ADD, R8, R3), 1085 BPF_ALU64_REG(BPF_ADD, R8, R4), 1086 BPF_ALU64_REG(BPF_ADD, R8, R5), 1087 BPF_ALU64_REG(BPF_ADD, R8, R6), 1088 BPF_ALU64_REG(BPF_ADD, R8, R7), 1089 BPF_ALU64_REG(BPF_ADD, R8, R8), 1090 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 1091 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 1092 BPF_EXIT_INSN(), 1093 BPF_ALU64_REG(BPF_ADD, R9, R0), 1094 BPF_ALU64_REG(BPF_ADD, R9, R1), 1095 BPF_ALU64_REG(BPF_ADD, R9, R2), 1096 BPF_ALU64_REG(BPF_ADD, R9, R3), 1097 BPF_ALU64_REG(BPF_ADD, R9, R4), 1098 BPF_ALU64_REG(BPF_ADD, R9, R5), 1099 BPF_ALU64_REG(BPF_ADD, R9, R6), 1100 BPF_ALU64_REG(BPF_ADD, R9, R7), 1101 BPF_ALU64_REG(BPF_ADD, R9, R8), 1102 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 1103 BPF_ALU64_REG(BPF_MOV, R0, R9), 1104 BPF_EXIT_INSN(), 1105 }, 1106 INTERNAL, 1107 { }, 1108 { { 0, 2957380 } } 1109 }, 1110 { 1111 "INT: ADD 32-bit", 1112 .u.insns_int = { 1113 BPF_ALU32_IMM(BPF_MOV, R0, 20), 1114 BPF_ALU32_IMM(BPF_MOV, R1, 1), 1115 BPF_ALU32_IMM(BPF_MOV, R2, 2), 1116 BPF_ALU32_IMM(BPF_MOV, R3, 3), 1117 BPF_ALU32_IMM(BPF_MOV, R4, 4), 1118 BPF_ALU32_IMM(BPF_MOV, R5, 5), 1119 BPF_ALU32_IMM(BPF_MOV, R6, 6), 1120 BPF_ALU32_IMM(BPF_MOV, R7, 7), 1121 BPF_ALU32_IMM(BPF_MOV, R8, 8), 1122 BPF_ALU32_IMM(BPF_MOV, R9, 9), 1123 BPF_ALU64_IMM(BPF_ADD, R1, 10), 1124 BPF_ALU64_IMM(BPF_ADD, R2, 10), 1125 BPF_ALU64_IMM(BPF_ADD, R3, 10), 1126 BPF_ALU64_IMM(BPF_ADD, R4, 10), 1127 BPF_ALU64_IMM(BPF_ADD, R5, 10), 1128 BPF_ALU64_IMM(BPF_ADD, R6, 10), 1129 BPF_ALU64_IMM(BPF_ADD, R7, 10), 1130 BPF_ALU64_IMM(BPF_ADD, R8, 10), 1131 BPF_ALU64_IMM(BPF_ADD, R9, 10), 1132 BPF_ALU32_REG(BPF_ADD, R0, R1), 1133 BPF_ALU32_REG(BPF_ADD, R0, R2), 1134 BPF_ALU32_REG(BPF_ADD, R0, R3), 1135 BPF_ALU32_REG(BPF_ADD, R0, R4), 1136 BPF_ALU32_REG(BPF_ADD, R0, R5), 1137 BPF_ALU32_REG(BPF_ADD, R0, R6), 1138 BPF_ALU32_REG(BPF_ADD, R0, R7), 1139 BPF_ALU32_REG(BPF_ADD, R0, R8), 1140 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */ 1141 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1), 1142 BPF_EXIT_INSN(), 1143 BPF_ALU32_REG(BPF_ADD, R1, R0), 1144 BPF_ALU32_REG(BPF_ADD, R1, R1), 1145 BPF_ALU32_REG(BPF_ADD, R1, R2), 1146 BPF_ALU32_REG(BPF_ADD, R1, R3), 1147 BPF_ALU32_REG(BPF_ADD, R1, R4), 1148 BPF_ALU32_REG(BPF_ADD, R1, R5), 1149 BPF_ALU32_REG(BPF_ADD, R1, R6), 1150 BPF_ALU32_REG(BPF_ADD, R1, R7), 1151 BPF_ALU32_REG(BPF_ADD, R1, R8), 1152 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */ 1153 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1), 1154 BPF_EXIT_INSN(), 1155 BPF_ALU32_REG(BPF_ADD, R2, R0), 1156 BPF_ALU32_REG(BPF_ADD, R2, R1), 1157 BPF_ALU32_REG(BPF_ADD, R2, R2), 1158 BPF_ALU32_REG(BPF_ADD, R2, R3), 1159 BPF_ALU32_REG(BPF_ADD, R2, R4), 1160 BPF_ALU32_REG(BPF_ADD, R2, R5), 1161 BPF_ALU32_REG(BPF_ADD, R2, R6), 1162 BPF_ALU32_REG(BPF_ADD, R2, R7), 1163 BPF_ALU32_REG(BPF_ADD, R2, R8), 1164 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */ 1165 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1), 1166 BPF_EXIT_INSN(), 1167 BPF_ALU32_REG(BPF_ADD, R3, R0), 1168 BPF_ALU32_REG(BPF_ADD, R3, R1), 1169 BPF_ALU32_REG(BPF_ADD, R3, R2), 1170 BPF_ALU32_REG(BPF_ADD, R3, R3), 1171 BPF_ALU32_REG(BPF_ADD, R3, R4), 1172 BPF_ALU32_REG(BPF_ADD, R3, R5), 1173 BPF_ALU32_REG(BPF_ADD, R3, R6), 1174 BPF_ALU32_REG(BPF_ADD, R3, R7), 1175 BPF_ALU32_REG(BPF_ADD, R3, R8), 1176 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */ 1177 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1), 1178 BPF_EXIT_INSN(), 1179 BPF_ALU32_REG(BPF_ADD, R4, R0), 1180 BPF_ALU32_REG(BPF_ADD, R4, R1), 1181 BPF_ALU32_REG(BPF_ADD, R4, R2), 1182 BPF_ALU32_REG(BPF_ADD, R4, R3), 1183 BPF_ALU32_REG(BPF_ADD, R4, R4), 1184 BPF_ALU32_REG(BPF_ADD, R4, R5), 1185 BPF_ALU32_REG(BPF_ADD, R4, R6), 1186 BPF_ALU32_REG(BPF_ADD, R4, R7), 1187 BPF_ALU32_REG(BPF_ADD, R4, R8), 1188 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */ 1189 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1), 1190 BPF_EXIT_INSN(), 1191 BPF_ALU32_REG(BPF_ADD, R5, R0), 1192 BPF_ALU32_REG(BPF_ADD, R5, R1), 1193 BPF_ALU32_REG(BPF_ADD, R5, R2), 1194 BPF_ALU32_REG(BPF_ADD, R5, R3), 1195 BPF_ALU32_REG(BPF_ADD, R5, R4), 1196 BPF_ALU32_REG(BPF_ADD, R5, R5), 1197 BPF_ALU32_REG(BPF_ADD, R5, R6), 1198 BPF_ALU32_REG(BPF_ADD, R5, R7), 1199 BPF_ALU32_REG(BPF_ADD, R5, R8), 1200 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */ 1201 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1), 1202 BPF_EXIT_INSN(), 1203 BPF_ALU32_REG(BPF_ADD, R6, R0), 1204 BPF_ALU32_REG(BPF_ADD, R6, R1), 1205 BPF_ALU32_REG(BPF_ADD, R6, R2), 1206 BPF_ALU32_REG(BPF_ADD, R6, R3), 1207 BPF_ALU32_REG(BPF_ADD, R6, R4), 1208 BPF_ALU32_REG(BPF_ADD, R6, R5), 1209 BPF_ALU32_REG(BPF_ADD, R6, R6), 1210 BPF_ALU32_REG(BPF_ADD, R6, R7), 1211 BPF_ALU32_REG(BPF_ADD, R6, R8), 1212 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */ 1213 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1), 1214 BPF_EXIT_INSN(), 1215 BPF_ALU32_REG(BPF_ADD, R7, R0), 1216 BPF_ALU32_REG(BPF_ADD, R7, R1), 1217 BPF_ALU32_REG(BPF_ADD, R7, R2), 1218 BPF_ALU32_REG(BPF_ADD, R7, R3), 1219 BPF_ALU32_REG(BPF_ADD, R7, R4), 1220 BPF_ALU32_REG(BPF_ADD, R7, R5), 1221 BPF_ALU32_REG(BPF_ADD, R7, R6), 1222 BPF_ALU32_REG(BPF_ADD, R7, R7), 1223 BPF_ALU32_REG(BPF_ADD, R7, R8), 1224 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */ 1225 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1), 1226 BPF_EXIT_INSN(), 1227 BPF_ALU32_REG(BPF_ADD, R8, R0), 1228 BPF_ALU32_REG(BPF_ADD, R8, R1), 1229 BPF_ALU32_REG(BPF_ADD, R8, R2), 1230 BPF_ALU32_REG(BPF_ADD, R8, R3), 1231 BPF_ALU32_REG(BPF_ADD, R8, R4), 1232 BPF_ALU32_REG(BPF_ADD, R8, R5), 1233 BPF_ALU32_REG(BPF_ADD, R8, R6), 1234 BPF_ALU32_REG(BPF_ADD, R8, R7), 1235 BPF_ALU32_REG(BPF_ADD, R8, R8), 1236 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */ 1237 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1), 1238 BPF_EXIT_INSN(), 1239 BPF_ALU32_REG(BPF_ADD, R9, R0), 1240 BPF_ALU32_REG(BPF_ADD, R9, R1), 1241 BPF_ALU32_REG(BPF_ADD, R9, R2), 1242 BPF_ALU32_REG(BPF_ADD, R9, R3), 1243 BPF_ALU32_REG(BPF_ADD, R9, R4), 1244 BPF_ALU32_REG(BPF_ADD, R9, R5), 1245 BPF_ALU32_REG(BPF_ADD, R9, R6), 1246 BPF_ALU32_REG(BPF_ADD, R9, R7), 1247 BPF_ALU32_REG(BPF_ADD, R9, R8), 1248 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */ 1249 BPF_ALU32_REG(BPF_MOV, R0, R9), 1250 BPF_EXIT_INSN(), 1251 }, 1252 INTERNAL, 1253 { }, 1254 { { 0, 2957380 } } 1255 }, 1256 { /* Mainly checking JIT here. */ 1257 "INT: SUB", 1258 .u.insns_int = { 1259 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1260 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1261 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1262 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1263 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1264 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1265 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1266 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1267 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1268 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1269 BPF_ALU64_REG(BPF_SUB, R0, R0), 1270 BPF_ALU64_REG(BPF_SUB, R0, R1), 1271 BPF_ALU64_REG(BPF_SUB, R0, R2), 1272 BPF_ALU64_REG(BPF_SUB, R0, R3), 1273 BPF_ALU64_REG(BPF_SUB, R0, R4), 1274 BPF_ALU64_REG(BPF_SUB, R0, R5), 1275 BPF_ALU64_REG(BPF_SUB, R0, R6), 1276 BPF_ALU64_REG(BPF_SUB, R0, R7), 1277 BPF_ALU64_REG(BPF_SUB, R0, R8), 1278 BPF_ALU64_REG(BPF_SUB, R0, R9), 1279 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1280 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1), 1281 BPF_EXIT_INSN(), 1282 BPF_ALU64_REG(BPF_SUB, R1, R0), 1283 BPF_ALU64_REG(BPF_SUB, R1, R2), 1284 BPF_ALU64_REG(BPF_SUB, R1, R3), 1285 BPF_ALU64_REG(BPF_SUB, R1, R4), 1286 BPF_ALU64_REG(BPF_SUB, R1, R5), 1287 BPF_ALU64_REG(BPF_SUB, R1, R6), 1288 BPF_ALU64_REG(BPF_SUB, R1, R7), 1289 BPF_ALU64_REG(BPF_SUB, R1, R8), 1290 BPF_ALU64_REG(BPF_SUB, R1, R9), 1291 BPF_ALU64_IMM(BPF_SUB, R1, 10), 1292 BPF_ALU64_REG(BPF_SUB, R2, R0), 1293 BPF_ALU64_REG(BPF_SUB, R2, R1), 1294 BPF_ALU64_REG(BPF_SUB, R2, R3), 1295 BPF_ALU64_REG(BPF_SUB, R2, R4), 1296 BPF_ALU64_REG(BPF_SUB, R2, R5), 1297 BPF_ALU64_REG(BPF_SUB, R2, R6), 1298 BPF_ALU64_REG(BPF_SUB, R2, R7), 1299 BPF_ALU64_REG(BPF_SUB, R2, R8), 1300 BPF_ALU64_REG(BPF_SUB, R2, R9), 1301 BPF_ALU64_IMM(BPF_SUB, R2, 10), 1302 BPF_ALU64_REG(BPF_SUB, R3, R0), 1303 BPF_ALU64_REG(BPF_SUB, R3, R1), 1304 BPF_ALU64_REG(BPF_SUB, R3, R2), 1305 BPF_ALU64_REG(BPF_SUB, R3, R4), 1306 BPF_ALU64_REG(BPF_SUB, R3, R5), 1307 BPF_ALU64_REG(BPF_SUB, R3, R6), 1308 BPF_ALU64_REG(BPF_SUB, R3, R7), 1309 BPF_ALU64_REG(BPF_SUB, R3, R8), 1310 BPF_ALU64_REG(BPF_SUB, R3, R9), 1311 BPF_ALU64_IMM(BPF_SUB, R3, 10), 1312 BPF_ALU64_REG(BPF_SUB, R4, R0), 1313 BPF_ALU64_REG(BPF_SUB, R4, R1), 1314 BPF_ALU64_REG(BPF_SUB, R4, R2), 1315 BPF_ALU64_REG(BPF_SUB, R4, R3), 1316 BPF_ALU64_REG(BPF_SUB, R4, R5), 1317 BPF_ALU64_REG(BPF_SUB, R4, R6), 1318 BPF_ALU64_REG(BPF_SUB, R4, R7), 1319 BPF_ALU64_REG(BPF_SUB, R4, R8), 1320 BPF_ALU64_REG(BPF_SUB, R4, R9), 1321 BPF_ALU64_IMM(BPF_SUB, R4, 10), 1322 BPF_ALU64_REG(BPF_SUB, R5, R0), 1323 BPF_ALU64_REG(BPF_SUB, R5, R1), 1324 BPF_ALU64_REG(BPF_SUB, R5, R2), 1325 BPF_ALU64_REG(BPF_SUB, R5, R3), 1326 BPF_ALU64_REG(BPF_SUB, R5, R4), 1327 BPF_ALU64_REG(BPF_SUB, R5, R6), 1328 BPF_ALU64_REG(BPF_SUB, R5, R7), 1329 BPF_ALU64_REG(BPF_SUB, R5, R8), 1330 BPF_ALU64_REG(BPF_SUB, R5, R9), 1331 BPF_ALU64_IMM(BPF_SUB, R5, 10), 1332 BPF_ALU64_REG(BPF_SUB, R6, R0), 1333 BPF_ALU64_REG(BPF_SUB, R6, R1), 1334 BPF_ALU64_REG(BPF_SUB, R6, R2), 1335 BPF_ALU64_REG(BPF_SUB, R6, R3), 1336 BPF_ALU64_REG(BPF_SUB, R6, R4), 1337 BPF_ALU64_REG(BPF_SUB, R6, R5), 1338 BPF_ALU64_REG(BPF_SUB, R6, R7), 1339 BPF_ALU64_REG(BPF_SUB, R6, R8), 1340 BPF_ALU64_REG(BPF_SUB, R6, R9), 1341 BPF_ALU64_IMM(BPF_SUB, R6, 10), 1342 BPF_ALU64_REG(BPF_SUB, R7, R0), 1343 BPF_ALU64_REG(BPF_SUB, R7, R1), 1344 BPF_ALU64_REG(BPF_SUB, R7, R2), 1345 BPF_ALU64_REG(BPF_SUB, R7, R3), 1346 BPF_ALU64_REG(BPF_SUB, R7, R4), 1347 BPF_ALU64_REG(BPF_SUB, R7, R5), 1348 BPF_ALU64_REG(BPF_SUB, R7, R6), 1349 BPF_ALU64_REG(BPF_SUB, R7, R8), 1350 BPF_ALU64_REG(BPF_SUB, R7, R9), 1351 BPF_ALU64_IMM(BPF_SUB, R7, 10), 1352 BPF_ALU64_REG(BPF_SUB, R8, R0), 1353 BPF_ALU64_REG(BPF_SUB, R8, R1), 1354 BPF_ALU64_REG(BPF_SUB, R8, R2), 1355 BPF_ALU64_REG(BPF_SUB, R8, R3), 1356 BPF_ALU64_REG(BPF_SUB, R8, R4), 1357 BPF_ALU64_REG(BPF_SUB, R8, R5), 1358 BPF_ALU64_REG(BPF_SUB, R8, R6), 1359 BPF_ALU64_REG(BPF_SUB, R8, R7), 1360 BPF_ALU64_REG(BPF_SUB, R8, R9), 1361 BPF_ALU64_IMM(BPF_SUB, R8, 10), 1362 BPF_ALU64_REG(BPF_SUB, R9, R0), 1363 BPF_ALU64_REG(BPF_SUB, R9, R1), 1364 BPF_ALU64_REG(BPF_SUB, R9, R2), 1365 BPF_ALU64_REG(BPF_SUB, R9, R3), 1366 BPF_ALU64_REG(BPF_SUB, R9, R4), 1367 BPF_ALU64_REG(BPF_SUB, R9, R5), 1368 BPF_ALU64_REG(BPF_SUB, R9, R6), 1369 BPF_ALU64_REG(BPF_SUB, R9, R7), 1370 BPF_ALU64_REG(BPF_SUB, R9, R8), 1371 BPF_ALU64_IMM(BPF_SUB, R9, 10), 1372 BPF_ALU64_IMM(BPF_SUB, R0, 10), 1373 BPF_ALU64_IMM(BPF_NEG, R0, 0), 1374 BPF_ALU64_REG(BPF_SUB, R0, R1), 1375 BPF_ALU64_REG(BPF_SUB, R0, R2), 1376 BPF_ALU64_REG(BPF_SUB, R0, R3), 1377 BPF_ALU64_REG(BPF_SUB, R0, R4), 1378 BPF_ALU64_REG(BPF_SUB, R0, R5), 1379 BPF_ALU64_REG(BPF_SUB, R0, R6), 1380 BPF_ALU64_REG(BPF_SUB, R0, R7), 1381 BPF_ALU64_REG(BPF_SUB, R0, R8), 1382 BPF_ALU64_REG(BPF_SUB, R0, R9), 1383 BPF_EXIT_INSN(), 1384 }, 1385 INTERNAL, 1386 { }, 1387 { { 0, 11 } } 1388 }, 1389 { /* Mainly checking JIT here. */ 1390 "INT: XOR", 1391 .u.insns_int = { 1392 BPF_ALU64_REG(BPF_SUB, R0, R0), 1393 BPF_ALU64_REG(BPF_XOR, R1, R1), 1394 BPF_JMP_REG(BPF_JEQ, R0, R1, 1), 1395 BPF_EXIT_INSN(), 1396 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1397 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1398 BPF_ALU64_REG(BPF_SUB, R1, R1), 1399 BPF_ALU64_REG(BPF_XOR, R2, R2), 1400 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 1401 BPF_EXIT_INSN(), 1402 BPF_ALU64_REG(BPF_SUB, R2, R2), 1403 BPF_ALU64_REG(BPF_XOR, R3, R3), 1404 BPF_ALU64_IMM(BPF_MOV, R0, 10), 1405 BPF_ALU64_IMM(BPF_MOV, R1, -1), 1406 BPF_JMP_REG(BPF_JEQ, R2, R3, 1), 1407 BPF_EXIT_INSN(), 1408 BPF_ALU64_REG(BPF_SUB, R3, R3), 1409 BPF_ALU64_REG(BPF_XOR, R4, R4), 1410 BPF_ALU64_IMM(BPF_MOV, R2, 1), 1411 BPF_ALU64_IMM(BPF_MOV, R5, -1), 1412 BPF_JMP_REG(BPF_JEQ, R3, R4, 1), 1413 BPF_EXIT_INSN(), 1414 BPF_ALU64_REG(BPF_SUB, R4, R4), 1415 BPF_ALU64_REG(BPF_XOR, R5, R5), 1416 BPF_ALU64_IMM(BPF_MOV, R3, 1), 1417 BPF_ALU64_IMM(BPF_MOV, R7, -1), 1418 BPF_JMP_REG(BPF_JEQ, R5, R4, 1), 1419 BPF_EXIT_INSN(), 1420 BPF_ALU64_IMM(BPF_MOV, R5, 1), 1421 BPF_ALU64_REG(BPF_SUB, R5, R5), 1422 BPF_ALU64_REG(BPF_XOR, R6, R6), 1423 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1424 BPF_ALU64_IMM(BPF_MOV, R8, -1), 1425 BPF_JMP_REG(BPF_JEQ, R5, R6, 1), 1426 BPF_EXIT_INSN(), 1427 BPF_ALU64_REG(BPF_SUB, R6, R6), 1428 BPF_ALU64_REG(BPF_XOR, R7, R7), 1429 BPF_JMP_REG(BPF_JEQ, R7, R6, 1), 1430 BPF_EXIT_INSN(), 1431 BPF_ALU64_REG(BPF_SUB, R7, R7), 1432 BPF_ALU64_REG(BPF_XOR, R8, R8), 1433 BPF_JMP_REG(BPF_JEQ, R7, R8, 1), 1434 BPF_EXIT_INSN(), 1435 BPF_ALU64_REG(BPF_SUB, R8, R8), 1436 BPF_ALU64_REG(BPF_XOR, R9, R9), 1437 BPF_JMP_REG(BPF_JEQ, R9, R8, 1), 1438 BPF_EXIT_INSN(), 1439 BPF_ALU64_REG(BPF_SUB, R9, R9), 1440 BPF_ALU64_REG(BPF_XOR, R0, R0), 1441 BPF_JMP_REG(BPF_JEQ, R9, R0, 1), 1442 BPF_EXIT_INSN(), 1443 BPF_ALU64_REG(BPF_SUB, R1, R1), 1444 BPF_ALU64_REG(BPF_XOR, R0, R0), 1445 BPF_JMP_REG(BPF_JEQ, R9, R0, 2), 1446 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1447 BPF_EXIT_INSN(), 1448 BPF_ALU64_IMM(BPF_MOV, R0, 1), 1449 BPF_EXIT_INSN(), 1450 }, 1451 INTERNAL, 1452 { }, 1453 { { 0, 1 } } 1454 }, 1455 { /* Mainly checking JIT here. */ 1456 "INT: MUL", 1457 .u.insns_int = { 1458 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1459 BPF_ALU64_IMM(BPF_MOV, R1, 1), 1460 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1461 BPF_ALU64_IMM(BPF_MOV, R3, 3), 1462 BPF_ALU64_IMM(BPF_MOV, R4, 4), 1463 BPF_ALU64_IMM(BPF_MOV, R5, 5), 1464 BPF_ALU64_IMM(BPF_MOV, R6, 6), 1465 BPF_ALU64_IMM(BPF_MOV, R7, 7), 1466 BPF_ALU64_IMM(BPF_MOV, R8, 8), 1467 BPF_ALU64_IMM(BPF_MOV, R9, 9), 1468 BPF_ALU64_REG(BPF_MUL, R0, R0), 1469 BPF_ALU64_REG(BPF_MUL, R0, R1), 1470 BPF_ALU64_REG(BPF_MUL, R0, R2), 1471 BPF_ALU64_REG(BPF_MUL, R0, R3), 1472 BPF_ALU64_REG(BPF_MUL, R0, R4), 1473 BPF_ALU64_REG(BPF_MUL, R0, R5), 1474 BPF_ALU64_REG(BPF_MUL, R0, R6), 1475 BPF_ALU64_REG(BPF_MUL, R0, R7), 1476 BPF_ALU64_REG(BPF_MUL, R0, R8), 1477 BPF_ALU64_REG(BPF_MUL, R0, R9), 1478 BPF_ALU64_IMM(BPF_MUL, R0, 10), 1479 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1), 1480 BPF_EXIT_INSN(), 1481 BPF_ALU64_REG(BPF_MUL, R1, R0), 1482 BPF_ALU64_REG(BPF_MUL, R1, R2), 1483 BPF_ALU64_REG(BPF_MUL, R1, R3), 1484 BPF_ALU64_REG(BPF_MUL, R1, R4), 1485 BPF_ALU64_REG(BPF_MUL, R1, R5), 1486 BPF_ALU64_REG(BPF_MUL, R1, R6), 1487 BPF_ALU64_REG(BPF_MUL, R1, R7), 1488 BPF_ALU64_REG(BPF_MUL, R1, R8), 1489 BPF_ALU64_REG(BPF_MUL, R1, R9), 1490 BPF_ALU64_IMM(BPF_MUL, R1, 10), 1491 BPF_ALU64_REG(BPF_MOV, R2, R1), 1492 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1493 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1), 1494 BPF_EXIT_INSN(), 1495 BPF_ALU64_IMM(BPF_LSH, R1, 32), 1496 BPF_ALU64_IMM(BPF_ARSH, R1, 32), 1497 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1), 1498 BPF_EXIT_INSN(), 1499 BPF_ALU64_REG(BPF_MUL, R2, R0), 1500 BPF_ALU64_REG(BPF_MUL, R2, R1), 1501 BPF_ALU64_REG(BPF_MUL, R2, R3), 1502 BPF_ALU64_REG(BPF_MUL, R2, R4), 1503 BPF_ALU64_REG(BPF_MUL, R2, R5), 1504 BPF_ALU64_REG(BPF_MUL, R2, R6), 1505 BPF_ALU64_REG(BPF_MUL, R2, R7), 1506 BPF_ALU64_REG(BPF_MUL, R2, R8), 1507 BPF_ALU64_REG(BPF_MUL, R2, R9), 1508 BPF_ALU64_IMM(BPF_MUL, R2, 10), 1509 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1510 BPF_ALU64_REG(BPF_MOV, R0, R2), 1511 BPF_EXIT_INSN(), 1512 }, 1513 INTERNAL, 1514 { }, 1515 { { 0, 0x35d97ef2 } } 1516 }, 1517 { 1518 "INT: ALU MIX", 1519 .u.insns_int = { 1520 BPF_ALU64_IMM(BPF_MOV, R0, 11), 1521 BPF_ALU64_IMM(BPF_ADD, R0, -1), 1522 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1523 BPF_ALU64_IMM(BPF_XOR, R2, 3), 1524 BPF_ALU64_REG(BPF_DIV, R0, R2), 1525 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1), 1526 BPF_EXIT_INSN(), 1527 BPF_ALU64_IMM(BPF_MOD, R0, 3), 1528 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1), 1529 BPF_EXIT_INSN(), 1530 BPF_ALU64_IMM(BPF_MOV, R0, -1), 1531 BPF_EXIT_INSN(), 1532 }, 1533 INTERNAL, 1534 { }, 1535 { { 0, -1 } } 1536 }, 1537 { 1538 "INT: shifts by register", 1539 .u.insns_int = { 1540 BPF_MOV64_IMM(R0, -1234), 1541 BPF_MOV64_IMM(R1, 1), 1542 BPF_ALU32_REG(BPF_RSH, R0, R1), 1543 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1), 1544 BPF_EXIT_INSN(), 1545 BPF_MOV64_IMM(R2, 1), 1546 BPF_ALU64_REG(BPF_LSH, R0, R2), 1547 BPF_MOV32_IMM(R4, -1234), 1548 BPF_JMP_REG(BPF_JEQ, R0, R4, 1), 1549 BPF_EXIT_INSN(), 1550 BPF_ALU64_IMM(BPF_AND, R4, 63), 1551 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */ 1552 BPF_MOV64_IMM(R3, 47), 1553 BPF_ALU64_REG(BPF_ARSH, R0, R3), 1554 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1), 1555 BPF_EXIT_INSN(), 1556 BPF_MOV64_IMM(R2, 1), 1557 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */ 1558 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1), 1559 BPF_EXIT_INSN(), 1560 BPF_MOV64_IMM(R4, 4), 1561 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */ 1562 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1), 1563 BPF_EXIT_INSN(), 1564 BPF_MOV64_IMM(R4, 5), 1565 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */ 1566 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1), 1567 BPF_EXIT_INSN(), 1568 BPF_MOV64_IMM(R0, -1), 1569 BPF_EXIT_INSN(), 1570 }, 1571 INTERNAL, 1572 { }, 1573 { { 0, -1 } } 1574 }, 1575 { 1576 "INT: DIV + ABS", 1577 .u.insns_int = { 1578 BPF_ALU64_REG(BPF_MOV, R6, R1), 1579 BPF_LD_ABS(BPF_B, 3), 1580 BPF_ALU64_IMM(BPF_MOV, R2, 2), 1581 BPF_ALU32_REG(BPF_DIV, R0, R2), 1582 BPF_ALU64_REG(BPF_MOV, R8, R0), 1583 BPF_LD_ABS(BPF_B, 4), 1584 BPF_ALU64_REG(BPF_ADD, R8, R0), 1585 BPF_LD_IND(BPF_B, R8, -70), 1586 BPF_EXIT_INSN(), 1587 }, 1588 INTERNAL, 1589 { 10, 20, 30, 40, 50 }, 1590 { { 4, 0 }, { 5, 10 } } 1591 }, 1592 { 1593 "INT: DIV by zero", 1594 .u.insns_int = { 1595 BPF_ALU64_REG(BPF_MOV, R6, R1), 1596 BPF_ALU64_IMM(BPF_MOV, R7, 0), 1597 BPF_LD_ABS(BPF_B, 3), 1598 BPF_ALU32_REG(BPF_DIV, R0, R7), 1599 BPF_EXIT_INSN(), 1600 }, 1601 INTERNAL, 1602 { 10, 20, 30, 40, 50 }, 1603 { { 3, 0 }, { 4, 0 } } 1604 }, 1605 { 1606 "check: missing ret", 1607 .u.insns = { 1608 BPF_STMT(BPF_LD | BPF_IMM, 1), 1609 }, 1610 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1611 { }, 1612 { } 1613 }, 1614 { 1615 "check: div_k_0", 1616 .u.insns = { 1617 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0), 1618 BPF_STMT(BPF_RET | BPF_K, 0) 1619 }, 1620 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1621 { }, 1622 { } 1623 }, 1624 { 1625 "check: unknown insn", 1626 .u.insns = { 1627 /* seccomp insn, rejected in socket filter */ 1628 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0), 1629 BPF_STMT(BPF_RET | BPF_K, 0) 1630 }, 1631 CLASSIC | FLAG_EXPECTED_FAIL, 1632 { }, 1633 { } 1634 }, 1635 { 1636 "check: out of range spill/fill", 1637 .u.insns = { 1638 BPF_STMT(BPF_STX, 16), 1639 BPF_STMT(BPF_RET | BPF_K, 0) 1640 }, 1641 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1642 { }, 1643 { } 1644 }, 1645 { 1646 "JUMPS + HOLES", 1647 .u.insns = { 1648 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1649 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15), 1650 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1651 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1652 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1653 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1654 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1655 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1656 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1657 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1658 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1659 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1660 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1661 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1662 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1663 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4), 1664 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1665 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2), 1666 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1667 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 1668 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 1669 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1670 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1671 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1672 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1673 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1674 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1675 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1676 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1677 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1678 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1679 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1680 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1681 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1682 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3), 1683 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2), 1684 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1685 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15), 1686 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14), 1687 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1688 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1689 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1690 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1691 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1692 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1693 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1694 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1695 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1696 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1697 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1698 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1699 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1700 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3), 1701 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2), 1702 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0), 1703 BPF_STMT(BPF_RET | BPF_A, 0), 1704 BPF_STMT(BPF_RET | BPF_A, 0), 1705 }, 1706 CLASSIC, 1707 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 1708 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4, 1709 0x08, 0x00, 1710 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 1711 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */ 1712 0xc0, 0xa8, 0x33, 0x01, 1713 0xc0, 0xa8, 0x33, 0x02, 1714 0xbb, 0xb6, 1715 0xa9, 0xfa, 1716 0x00, 0x14, 0x00, 0x00, 1717 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1718 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1719 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1720 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1721 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1722 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1723 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 1724 0xcc, 0xcc, 0xcc, 0xcc }, 1725 { { 88, 0x001b } } 1726 }, 1727 { 1728 "check: RET X", 1729 .u.insns = { 1730 BPF_STMT(BPF_RET | BPF_X, 0), 1731 }, 1732 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1733 { }, 1734 { }, 1735 }, 1736 { 1737 "check: LDX + RET X", 1738 .u.insns = { 1739 BPF_STMT(BPF_LDX | BPF_IMM, 42), 1740 BPF_STMT(BPF_RET | BPF_X, 0), 1741 }, 1742 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1743 { }, 1744 { }, 1745 }, 1746 { /* Mainly checking JIT here. */ 1747 "M[]: alt STX + LDX", 1748 .u.insns = { 1749 BPF_STMT(BPF_LDX | BPF_IMM, 100), 1750 BPF_STMT(BPF_STX, 0), 1751 BPF_STMT(BPF_LDX | BPF_MEM, 0), 1752 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1753 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1754 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1755 BPF_STMT(BPF_STX, 1), 1756 BPF_STMT(BPF_LDX | BPF_MEM, 1), 1757 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1758 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1759 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1760 BPF_STMT(BPF_STX, 2), 1761 BPF_STMT(BPF_LDX | BPF_MEM, 2), 1762 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1763 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1764 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1765 BPF_STMT(BPF_STX, 3), 1766 BPF_STMT(BPF_LDX | BPF_MEM, 3), 1767 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1768 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1769 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1770 BPF_STMT(BPF_STX, 4), 1771 BPF_STMT(BPF_LDX | BPF_MEM, 4), 1772 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1773 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1774 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1775 BPF_STMT(BPF_STX, 5), 1776 BPF_STMT(BPF_LDX | BPF_MEM, 5), 1777 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1778 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1779 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1780 BPF_STMT(BPF_STX, 6), 1781 BPF_STMT(BPF_LDX | BPF_MEM, 6), 1782 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1783 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1784 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1785 BPF_STMT(BPF_STX, 7), 1786 BPF_STMT(BPF_LDX | BPF_MEM, 7), 1787 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1788 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1789 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1790 BPF_STMT(BPF_STX, 8), 1791 BPF_STMT(BPF_LDX | BPF_MEM, 8), 1792 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1793 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1794 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1795 BPF_STMT(BPF_STX, 9), 1796 BPF_STMT(BPF_LDX | BPF_MEM, 9), 1797 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1798 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1799 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1800 BPF_STMT(BPF_STX, 10), 1801 BPF_STMT(BPF_LDX | BPF_MEM, 10), 1802 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1803 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1804 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1805 BPF_STMT(BPF_STX, 11), 1806 BPF_STMT(BPF_LDX | BPF_MEM, 11), 1807 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1808 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1809 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1810 BPF_STMT(BPF_STX, 12), 1811 BPF_STMT(BPF_LDX | BPF_MEM, 12), 1812 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1813 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1814 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1815 BPF_STMT(BPF_STX, 13), 1816 BPF_STMT(BPF_LDX | BPF_MEM, 13), 1817 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1818 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1819 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1820 BPF_STMT(BPF_STX, 14), 1821 BPF_STMT(BPF_LDX | BPF_MEM, 14), 1822 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1823 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1824 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1825 BPF_STMT(BPF_STX, 15), 1826 BPF_STMT(BPF_LDX | BPF_MEM, 15), 1827 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1828 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1), 1829 BPF_STMT(BPF_MISC | BPF_TAX, 0), 1830 BPF_STMT(BPF_RET | BPF_A, 0), 1831 }, 1832 CLASSIC | FLAG_NO_DATA, 1833 { }, 1834 { { 0, 116 } }, 1835 }, 1836 { /* Mainly checking JIT here. */ 1837 "M[]: full STX + full LDX", 1838 .u.insns = { 1839 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb), 1840 BPF_STMT(BPF_STX, 0), 1841 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae), 1842 BPF_STMT(BPF_STX, 1), 1843 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf), 1844 BPF_STMT(BPF_STX, 2), 1845 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc), 1846 BPF_STMT(BPF_STX, 3), 1847 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb), 1848 BPF_STMT(BPF_STX, 4), 1849 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda), 1850 BPF_STMT(BPF_STX, 5), 1851 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb), 1852 BPF_STMT(BPF_STX, 6), 1853 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade), 1854 BPF_STMT(BPF_STX, 7), 1855 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec), 1856 BPF_STMT(BPF_STX, 8), 1857 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc), 1858 BPF_STMT(BPF_STX, 9), 1859 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac), 1860 BPF_STMT(BPF_STX, 10), 1861 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea), 1862 BPF_STMT(BPF_STX, 11), 1863 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb), 1864 BPF_STMT(BPF_STX, 12), 1865 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf), 1866 BPF_STMT(BPF_STX, 13), 1867 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde), 1868 BPF_STMT(BPF_STX, 14), 1869 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad), 1870 BPF_STMT(BPF_STX, 15), 1871 BPF_STMT(BPF_LDX | BPF_MEM, 0), 1872 BPF_STMT(BPF_MISC | BPF_TXA, 0), 1873 BPF_STMT(BPF_LDX | BPF_MEM, 1), 1874 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1875 BPF_STMT(BPF_LDX | BPF_MEM, 2), 1876 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1877 BPF_STMT(BPF_LDX | BPF_MEM, 3), 1878 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1879 BPF_STMT(BPF_LDX | BPF_MEM, 4), 1880 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1881 BPF_STMT(BPF_LDX | BPF_MEM, 5), 1882 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1883 BPF_STMT(BPF_LDX | BPF_MEM, 6), 1884 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1885 BPF_STMT(BPF_LDX | BPF_MEM, 7), 1886 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1887 BPF_STMT(BPF_LDX | BPF_MEM, 8), 1888 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1889 BPF_STMT(BPF_LDX | BPF_MEM, 9), 1890 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1891 BPF_STMT(BPF_LDX | BPF_MEM, 10), 1892 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1893 BPF_STMT(BPF_LDX | BPF_MEM, 11), 1894 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1895 BPF_STMT(BPF_LDX | BPF_MEM, 12), 1896 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1897 BPF_STMT(BPF_LDX | BPF_MEM, 13), 1898 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1899 BPF_STMT(BPF_LDX | BPF_MEM, 14), 1900 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1901 BPF_STMT(BPF_LDX | BPF_MEM, 15), 1902 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0), 1903 BPF_STMT(BPF_RET | BPF_A, 0), 1904 }, 1905 CLASSIC | FLAG_NO_DATA, 1906 { }, 1907 { { 0, 0x2a5a5e5 } }, 1908 }, 1909 { 1910 "check: SKF_AD_MAX", 1911 .u.insns = { 1912 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1913 SKF_AD_OFF + SKF_AD_MAX), 1914 BPF_STMT(BPF_RET | BPF_A, 0), 1915 }, 1916 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 1917 { }, 1918 { }, 1919 }, 1920 { /* Passes checker but fails during runtime. */ 1921 "LD [SKF_AD_OFF-1]", 1922 .u.insns = { 1923 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1924 SKF_AD_OFF - 1), 1925 BPF_STMT(BPF_RET | BPF_K, 1), 1926 }, 1927 CLASSIC, 1928 { }, 1929 { { 1, 0 } }, 1930 }, 1931 { 1932 "load 64-bit immediate", 1933 .u.insns_int = { 1934 BPF_LD_IMM64(R1, 0x567800001234LL), 1935 BPF_MOV64_REG(R2, R1), 1936 BPF_MOV64_REG(R3, R2), 1937 BPF_ALU64_IMM(BPF_RSH, R2, 32), 1938 BPF_ALU64_IMM(BPF_LSH, R3, 32), 1939 BPF_ALU64_IMM(BPF_RSH, R3, 32), 1940 BPF_ALU64_IMM(BPF_MOV, R0, 0), 1941 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1), 1942 BPF_EXIT_INSN(), 1943 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1), 1944 BPF_EXIT_INSN(), 1945 BPF_LD_IMM64(R0, 0x1ffffffffLL), 1946 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */ 1947 BPF_EXIT_INSN(), 1948 }, 1949 INTERNAL, 1950 { }, 1951 { { 0, 1 } } 1952 }, 1953 { 1954 "nmap reduced", 1955 .u.insns_int = { 1956 BPF_MOV64_REG(R6, R1), 1957 BPF_LD_ABS(BPF_H, 12), 1958 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 28), 1959 BPF_LD_ABS(BPF_H, 12), 1960 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 26), 1961 BPF_MOV32_IMM(R0, 18), 1962 BPF_STX_MEM(BPF_W, R10, R0, -64), 1963 BPF_LDX_MEM(BPF_W, R7, R10, -64), 1964 BPF_LD_IND(BPF_W, R7, 14), 1965 BPF_STX_MEM(BPF_W, R10, R0, -60), 1966 BPF_MOV32_IMM(R0, 280971478), 1967 BPF_STX_MEM(BPF_W, R10, R0, -56), 1968 BPF_LDX_MEM(BPF_W, R7, R10, -56), 1969 BPF_LDX_MEM(BPF_W, R0, R10, -60), 1970 BPF_ALU32_REG(BPF_SUB, R0, R7), 1971 BPF_JMP_IMM(BPF_JNE, R0, 0, 15), 1972 BPF_LD_ABS(BPF_H, 12), 1973 BPF_JMP_IMM(BPF_JNE, R0, 0x806, 13), 1974 BPF_MOV32_IMM(R0, 22), 1975 BPF_STX_MEM(BPF_W, R10, R0, -56), 1976 BPF_LDX_MEM(BPF_W, R7, R10, -56), 1977 BPF_LD_IND(BPF_H, R7, 14), 1978 BPF_STX_MEM(BPF_W, R10, R0, -52), 1979 BPF_MOV32_IMM(R0, 17366), 1980 BPF_STX_MEM(BPF_W, R10, R0, -48), 1981 BPF_LDX_MEM(BPF_W, R7, R10, -48), 1982 BPF_LDX_MEM(BPF_W, R0, R10, -52), 1983 BPF_ALU32_REG(BPF_SUB, R0, R7), 1984 BPF_JMP_IMM(BPF_JNE, R0, 0, 2), 1985 BPF_MOV32_IMM(R0, 256), 1986 BPF_EXIT_INSN(), 1987 BPF_MOV32_IMM(R0, 0), 1988 BPF_EXIT_INSN(), 1989 }, 1990 INTERNAL, 1991 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x06, 0, 0, 1992 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1993 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6}, 1994 { { 38, 256 } } 1995 }, 1996 /* BPF_ALU | BPF_MOV | BPF_X */ 1997 { 1998 "ALU_MOV_X: dst = 2", 1999 .u.insns_int = { 2000 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2001 BPF_ALU32_REG(BPF_MOV, R0, R1), 2002 BPF_EXIT_INSN(), 2003 }, 2004 INTERNAL, 2005 { }, 2006 { { 0, 2 } }, 2007 }, 2008 { 2009 "ALU_MOV_X: dst = 4294967295", 2010 .u.insns_int = { 2011 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 2012 BPF_ALU32_REG(BPF_MOV, R0, R1), 2013 BPF_EXIT_INSN(), 2014 }, 2015 INTERNAL, 2016 { }, 2017 { { 0, 4294967295U } }, 2018 }, 2019 { 2020 "ALU64_MOV_X: dst = 2", 2021 .u.insns_int = { 2022 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2023 BPF_ALU64_REG(BPF_MOV, R0, R1), 2024 BPF_EXIT_INSN(), 2025 }, 2026 INTERNAL, 2027 { }, 2028 { { 0, 2 } }, 2029 }, 2030 { 2031 "ALU64_MOV_X: dst = 4294967295", 2032 .u.insns_int = { 2033 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 2034 BPF_ALU64_REG(BPF_MOV, R0, R1), 2035 BPF_EXIT_INSN(), 2036 }, 2037 INTERNAL, 2038 { }, 2039 { { 0, 4294967295U } }, 2040 }, 2041 /* BPF_ALU | BPF_MOV | BPF_K */ 2042 { 2043 "ALU_MOV_K: dst = 2", 2044 .u.insns_int = { 2045 BPF_ALU32_IMM(BPF_MOV, R0, 2), 2046 BPF_EXIT_INSN(), 2047 }, 2048 INTERNAL, 2049 { }, 2050 { { 0, 2 } }, 2051 }, 2052 { 2053 "ALU_MOV_K: dst = 4294967295", 2054 .u.insns_int = { 2055 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U), 2056 BPF_EXIT_INSN(), 2057 }, 2058 INTERNAL, 2059 { }, 2060 { { 0, 4294967295U } }, 2061 }, 2062 { 2063 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff", 2064 .u.insns_int = { 2065 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 2066 BPF_LD_IMM64(R3, 0x00000000ffffffffLL), 2067 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff), 2068 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2069 BPF_MOV32_IMM(R0, 2), 2070 BPF_EXIT_INSN(), 2071 BPF_MOV32_IMM(R0, 1), 2072 BPF_EXIT_INSN(), 2073 }, 2074 INTERNAL, 2075 { }, 2076 { { 0, 0x1 } }, 2077 }, 2078 { 2079 "ALU64_MOV_K: dst = 2", 2080 .u.insns_int = { 2081 BPF_ALU64_IMM(BPF_MOV, R0, 2), 2082 BPF_EXIT_INSN(), 2083 }, 2084 INTERNAL, 2085 { }, 2086 { { 0, 2 } }, 2087 }, 2088 { 2089 "ALU64_MOV_K: dst = 2147483647", 2090 .u.insns_int = { 2091 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647), 2092 BPF_EXIT_INSN(), 2093 }, 2094 INTERNAL, 2095 { }, 2096 { { 0, 2147483647 } }, 2097 }, 2098 { 2099 "ALU64_OR_K: dst = 0x0", 2100 .u.insns_int = { 2101 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 2102 BPF_LD_IMM64(R3, 0x0), 2103 BPF_ALU64_IMM(BPF_MOV, R2, 0x0), 2104 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2105 BPF_MOV32_IMM(R0, 2), 2106 BPF_EXIT_INSN(), 2107 BPF_MOV32_IMM(R0, 1), 2108 BPF_EXIT_INSN(), 2109 }, 2110 INTERNAL, 2111 { }, 2112 { { 0, 0x1 } }, 2113 }, 2114 { 2115 "ALU64_MOV_K: dst = -1", 2116 .u.insns_int = { 2117 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 2118 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 2119 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff), 2120 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2121 BPF_MOV32_IMM(R0, 2), 2122 BPF_EXIT_INSN(), 2123 BPF_MOV32_IMM(R0, 1), 2124 BPF_EXIT_INSN(), 2125 }, 2126 INTERNAL, 2127 { }, 2128 { { 0, 0x1 } }, 2129 }, 2130 /* BPF_ALU | BPF_ADD | BPF_X */ 2131 { 2132 "ALU_ADD_X: 1 + 2 = 3", 2133 .u.insns_int = { 2134 BPF_LD_IMM64(R0, 1), 2135 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2136 BPF_ALU32_REG(BPF_ADD, R0, R1), 2137 BPF_EXIT_INSN(), 2138 }, 2139 INTERNAL, 2140 { }, 2141 { { 0, 3 } }, 2142 }, 2143 { 2144 "ALU_ADD_X: 1 + 4294967294 = 4294967295", 2145 .u.insns_int = { 2146 BPF_LD_IMM64(R0, 1), 2147 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 2148 BPF_ALU32_REG(BPF_ADD, R0, R1), 2149 BPF_EXIT_INSN(), 2150 }, 2151 INTERNAL, 2152 { }, 2153 { { 0, 4294967295U } }, 2154 }, 2155 { 2156 "ALU64_ADD_X: 1 + 2 = 3", 2157 .u.insns_int = { 2158 BPF_LD_IMM64(R0, 1), 2159 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2160 BPF_ALU64_REG(BPF_ADD, R0, R1), 2161 BPF_EXIT_INSN(), 2162 }, 2163 INTERNAL, 2164 { }, 2165 { { 0, 3 } }, 2166 }, 2167 { 2168 "ALU64_ADD_X: 1 + 4294967294 = 4294967295", 2169 .u.insns_int = { 2170 BPF_LD_IMM64(R0, 1), 2171 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 2172 BPF_ALU64_REG(BPF_ADD, R0, R1), 2173 BPF_EXIT_INSN(), 2174 }, 2175 INTERNAL, 2176 { }, 2177 { { 0, 4294967295U } }, 2178 }, 2179 /* BPF_ALU | BPF_ADD | BPF_K */ 2180 { 2181 "ALU_ADD_K: 1 + 2 = 3", 2182 .u.insns_int = { 2183 BPF_LD_IMM64(R0, 1), 2184 BPF_ALU32_IMM(BPF_ADD, R0, 2), 2185 BPF_EXIT_INSN(), 2186 }, 2187 INTERNAL, 2188 { }, 2189 { { 0, 3 } }, 2190 }, 2191 { 2192 "ALU_ADD_K: 3 + 0 = 3", 2193 .u.insns_int = { 2194 BPF_LD_IMM64(R0, 3), 2195 BPF_ALU32_IMM(BPF_ADD, R0, 0), 2196 BPF_EXIT_INSN(), 2197 }, 2198 INTERNAL, 2199 { }, 2200 { { 0, 3 } }, 2201 }, 2202 { 2203 "ALU_ADD_K: 1 + 4294967294 = 4294967295", 2204 .u.insns_int = { 2205 BPF_LD_IMM64(R0, 1), 2206 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U), 2207 BPF_EXIT_INSN(), 2208 }, 2209 INTERNAL, 2210 { }, 2211 { { 0, 4294967295U } }, 2212 }, 2213 { 2214 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff", 2215 .u.insns_int = { 2216 BPF_LD_IMM64(R2, 0x0), 2217 BPF_LD_IMM64(R3, 0x00000000ffffffff), 2218 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff), 2219 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2220 BPF_MOV32_IMM(R0, 2), 2221 BPF_EXIT_INSN(), 2222 BPF_MOV32_IMM(R0, 1), 2223 BPF_EXIT_INSN(), 2224 }, 2225 INTERNAL, 2226 { }, 2227 { { 0, 0x1 } }, 2228 }, 2229 { 2230 "ALU64_ADD_K: 1 + 2 = 3", 2231 .u.insns_int = { 2232 BPF_LD_IMM64(R0, 1), 2233 BPF_ALU64_IMM(BPF_ADD, R0, 2), 2234 BPF_EXIT_INSN(), 2235 }, 2236 INTERNAL, 2237 { }, 2238 { { 0, 3 } }, 2239 }, 2240 { 2241 "ALU64_ADD_K: 3 + 0 = 3", 2242 .u.insns_int = { 2243 BPF_LD_IMM64(R0, 3), 2244 BPF_ALU64_IMM(BPF_ADD, R0, 0), 2245 BPF_EXIT_INSN(), 2246 }, 2247 INTERNAL, 2248 { }, 2249 { { 0, 3 } }, 2250 }, 2251 { 2252 "ALU64_ADD_K: 1 + 2147483646 = 2147483647", 2253 .u.insns_int = { 2254 BPF_LD_IMM64(R0, 1), 2255 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646), 2256 BPF_EXIT_INSN(), 2257 }, 2258 INTERNAL, 2259 { }, 2260 { { 0, 2147483647 } }, 2261 }, 2262 { 2263 "ALU64_ADD_K: 2147483646 + -2147483647 = -1", 2264 .u.insns_int = { 2265 BPF_LD_IMM64(R0, 2147483646), 2266 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647), 2267 BPF_EXIT_INSN(), 2268 }, 2269 INTERNAL, 2270 { }, 2271 { { 0, -1 } }, 2272 }, 2273 { 2274 "ALU64_ADD_K: 1 + 0 = 1", 2275 .u.insns_int = { 2276 BPF_LD_IMM64(R2, 0x1), 2277 BPF_LD_IMM64(R3, 0x1), 2278 BPF_ALU64_IMM(BPF_ADD, R2, 0x0), 2279 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2280 BPF_MOV32_IMM(R0, 2), 2281 BPF_EXIT_INSN(), 2282 BPF_MOV32_IMM(R0, 1), 2283 BPF_EXIT_INSN(), 2284 }, 2285 INTERNAL, 2286 { }, 2287 { { 0, 0x1 } }, 2288 }, 2289 { 2290 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff", 2291 .u.insns_int = { 2292 BPF_LD_IMM64(R2, 0x0), 2293 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 2294 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff), 2295 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2296 BPF_MOV32_IMM(R0, 2), 2297 BPF_EXIT_INSN(), 2298 BPF_MOV32_IMM(R0, 1), 2299 BPF_EXIT_INSN(), 2300 }, 2301 INTERNAL, 2302 { }, 2303 { { 0, 0x1 } }, 2304 }, 2305 /* BPF_ALU | BPF_SUB | BPF_X */ 2306 { 2307 "ALU_SUB_X: 3 - 1 = 2", 2308 .u.insns_int = { 2309 BPF_LD_IMM64(R0, 3), 2310 BPF_ALU32_IMM(BPF_MOV, R1, 1), 2311 BPF_ALU32_REG(BPF_SUB, R0, R1), 2312 BPF_EXIT_INSN(), 2313 }, 2314 INTERNAL, 2315 { }, 2316 { { 0, 2 } }, 2317 }, 2318 { 2319 "ALU_SUB_X: 4294967295 - 4294967294 = 1", 2320 .u.insns_int = { 2321 BPF_LD_IMM64(R0, 4294967295U), 2322 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 2323 BPF_ALU32_REG(BPF_SUB, R0, R1), 2324 BPF_EXIT_INSN(), 2325 }, 2326 INTERNAL, 2327 { }, 2328 { { 0, 1 } }, 2329 }, 2330 { 2331 "ALU64_SUB_X: 3 - 1 = 2", 2332 .u.insns_int = { 2333 BPF_LD_IMM64(R0, 3), 2334 BPF_ALU32_IMM(BPF_MOV, R1, 1), 2335 BPF_ALU64_REG(BPF_SUB, R0, R1), 2336 BPF_EXIT_INSN(), 2337 }, 2338 INTERNAL, 2339 { }, 2340 { { 0, 2 } }, 2341 }, 2342 { 2343 "ALU64_SUB_X: 4294967295 - 4294967294 = 1", 2344 .u.insns_int = { 2345 BPF_LD_IMM64(R0, 4294967295U), 2346 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U), 2347 BPF_ALU64_REG(BPF_SUB, R0, R1), 2348 BPF_EXIT_INSN(), 2349 }, 2350 INTERNAL, 2351 { }, 2352 { { 0, 1 } }, 2353 }, 2354 /* BPF_ALU | BPF_SUB | BPF_K */ 2355 { 2356 "ALU_SUB_K: 3 - 1 = 2", 2357 .u.insns_int = { 2358 BPF_LD_IMM64(R0, 3), 2359 BPF_ALU32_IMM(BPF_SUB, R0, 1), 2360 BPF_EXIT_INSN(), 2361 }, 2362 INTERNAL, 2363 { }, 2364 { { 0, 2 } }, 2365 }, 2366 { 2367 "ALU_SUB_K: 3 - 0 = 3", 2368 .u.insns_int = { 2369 BPF_LD_IMM64(R0, 3), 2370 BPF_ALU32_IMM(BPF_SUB, R0, 0), 2371 BPF_EXIT_INSN(), 2372 }, 2373 INTERNAL, 2374 { }, 2375 { { 0, 3 } }, 2376 }, 2377 { 2378 "ALU_SUB_K: 4294967295 - 4294967294 = 1", 2379 .u.insns_int = { 2380 BPF_LD_IMM64(R0, 4294967295U), 2381 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U), 2382 BPF_EXIT_INSN(), 2383 }, 2384 INTERNAL, 2385 { }, 2386 { { 0, 1 } }, 2387 }, 2388 { 2389 "ALU64_SUB_K: 3 - 1 = 2", 2390 .u.insns_int = { 2391 BPF_LD_IMM64(R0, 3), 2392 BPF_ALU64_IMM(BPF_SUB, R0, 1), 2393 BPF_EXIT_INSN(), 2394 }, 2395 INTERNAL, 2396 { }, 2397 { { 0, 2 } }, 2398 }, 2399 { 2400 "ALU64_SUB_K: 3 - 0 = 3", 2401 .u.insns_int = { 2402 BPF_LD_IMM64(R0, 3), 2403 BPF_ALU64_IMM(BPF_SUB, R0, 0), 2404 BPF_EXIT_INSN(), 2405 }, 2406 INTERNAL, 2407 { }, 2408 { { 0, 3 } }, 2409 }, 2410 { 2411 "ALU64_SUB_K: 4294967294 - 4294967295 = -1", 2412 .u.insns_int = { 2413 BPF_LD_IMM64(R0, 4294967294U), 2414 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U), 2415 BPF_EXIT_INSN(), 2416 }, 2417 INTERNAL, 2418 { }, 2419 { { 0, -1 } }, 2420 }, 2421 { 2422 "ALU64_ADD_K: 2147483646 - 2147483647 = -1", 2423 .u.insns_int = { 2424 BPF_LD_IMM64(R0, 2147483646), 2425 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647), 2426 BPF_EXIT_INSN(), 2427 }, 2428 INTERNAL, 2429 { }, 2430 { { 0, -1 } }, 2431 }, 2432 /* BPF_ALU | BPF_MUL | BPF_X */ 2433 { 2434 "ALU_MUL_X: 2 * 3 = 6", 2435 .u.insns_int = { 2436 BPF_LD_IMM64(R0, 2), 2437 BPF_ALU32_IMM(BPF_MOV, R1, 3), 2438 BPF_ALU32_REG(BPF_MUL, R0, R1), 2439 BPF_EXIT_INSN(), 2440 }, 2441 INTERNAL, 2442 { }, 2443 { { 0, 6 } }, 2444 }, 2445 { 2446 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 2447 .u.insns_int = { 2448 BPF_LD_IMM64(R0, 2), 2449 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8), 2450 BPF_ALU32_REG(BPF_MUL, R0, R1), 2451 BPF_EXIT_INSN(), 2452 }, 2453 INTERNAL, 2454 { }, 2455 { { 0, 0xFFFFFFF0 } }, 2456 }, 2457 { 2458 "ALU_MUL_X: -1 * -1 = 1", 2459 .u.insns_int = { 2460 BPF_LD_IMM64(R0, -1), 2461 BPF_ALU32_IMM(BPF_MOV, R1, -1), 2462 BPF_ALU32_REG(BPF_MUL, R0, R1), 2463 BPF_EXIT_INSN(), 2464 }, 2465 INTERNAL, 2466 { }, 2467 { { 0, 1 } }, 2468 }, 2469 { 2470 "ALU64_MUL_X: 2 * 3 = 6", 2471 .u.insns_int = { 2472 BPF_LD_IMM64(R0, 2), 2473 BPF_ALU32_IMM(BPF_MOV, R1, 3), 2474 BPF_ALU64_REG(BPF_MUL, R0, R1), 2475 BPF_EXIT_INSN(), 2476 }, 2477 INTERNAL, 2478 { }, 2479 { { 0, 6 } }, 2480 }, 2481 { 2482 "ALU64_MUL_X: 1 * 2147483647 = 2147483647", 2483 .u.insns_int = { 2484 BPF_LD_IMM64(R0, 1), 2485 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 2486 BPF_ALU64_REG(BPF_MUL, R0, R1), 2487 BPF_EXIT_INSN(), 2488 }, 2489 INTERNAL, 2490 { }, 2491 { { 0, 2147483647 } }, 2492 }, 2493 /* BPF_ALU | BPF_MUL | BPF_K */ 2494 { 2495 "ALU_MUL_K: 2 * 3 = 6", 2496 .u.insns_int = { 2497 BPF_LD_IMM64(R0, 2), 2498 BPF_ALU32_IMM(BPF_MUL, R0, 3), 2499 BPF_EXIT_INSN(), 2500 }, 2501 INTERNAL, 2502 { }, 2503 { { 0, 6 } }, 2504 }, 2505 { 2506 "ALU_MUL_K: 3 * 1 = 3", 2507 .u.insns_int = { 2508 BPF_LD_IMM64(R0, 3), 2509 BPF_ALU32_IMM(BPF_MUL, R0, 1), 2510 BPF_EXIT_INSN(), 2511 }, 2512 INTERNAL, 2513 { }, 2514 { { 0, 3 } }, 2515 }, 2516 { 2517 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0", 2518 .u.insns_int = { 2519 BPF_LD_IMM64(R0, 2), 2520 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8), 2521 BPF_EXIT_INSN(), 2522 }, 2523 INTERNAL, 2524 { }, 2525 { { 0, 0xFFFFFFF0 } }, 2526 }, 2527 { 2528 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff", 2529 .u.insns_int = { 2530 BPF_LD_IMM64(R2, 0x1), 2531 BPF_LD_IMM64(R3, 0x00000000ffffffff), 2532 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff), 2533 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2534 BPF_MOV32_IMM(R0, 2), 2535 BPF_EXIT_INSN(), 2536 BPF_MOV32_IMM(R0, 1), 2537 BPF_EXIT_INSN(), 2538 }, 2539 INTERNAL, 2540 { }, 2541 { { 0, 0x1 } }, 2542 }, 2543 { 2544 "ALU64_MUL_K: 2 * 3 = 6", 2545 .u.insns_int = { 2546 BPF_LD_IMM64(R0, 2), 2547 BPF_ALU64_IMM(BPF_MUL, R0, 3), 2548 BPF_EXIT_INSN(), 2549 }, 2550 INTERNAL, 2551 { }, 2552 { { 0, 6 } }, 2553 }, 2554 { 2555 "ALU64_MUL_K: 3 * 1 = 3", 2556 .u.insns_int = { 2557 BPF_LD_IMM64(R0, 3), 2558 BPF_ALU64_IMM(BPF_MUL, R0, 1), 2559 BPF_EXIT_INSN(), 2560 }, 2561 INTERNAL, 2562 { }, 2563 { { 0, 3 } }, 2564 }, 2565 { 2566 "ALU64_MUL_K: 1 * 2147483647 = 2147483647", 2567 .u.insns_int = { 2568 BPF_LD_IMM64(R0, 1), 2569 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647), 2570 BPF_EXIT_INSN(), 2571 }, 2572 INTERNAL, 2573 { }, 2574 { { 0, 2147483647 } }, 2575 }, 2576 { 2577 "ALU64_MUL_K: 1 * -2147483647 = -2147483647", 2578 .u.insns_int = { 2579 BPF_LD_IMM64(R0, 1), 2580 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647), 2581 BPF_EXIT_INSN(), 2582 }, 2583 INTERNAL, 2584 { }, 2585 { { 0, -2147483647 } }, 2586 }, 2587 { 2588 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff", 2589 .u.insns_int = { 2590 BPF_LD_IMM64(R2, 0x1), 2591 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 2592 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff), 2593 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2594 BPF_MOV32_IMM(R0, 2), 2595 BPF_EXIT_INSN(), 2596 BPF_MOV32_IMM(R0, 1), 2597 BPF_EXIT_INSN(), 2598 }, 2599 INTERNAL, 2600 { }, 2601 { { 0, 0x1 } }, 2602 }, 2603 /* BPF_ALU | BPF_DIV | BPF_X */ 2604 { 2605 "ALU_DIV_X: 6 / 2 = 3", 2606 .u.insns_int = { 2607 BPF_LD_IMM64(R0, 6), 2608 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2609 BPF_ALU32_REG(BPF_DIV, R0, R1), 2610 BPF_EXIT_INSN(), 2611 }, 2612 INTERNAL, 2613 { }, 2614 { { 0, 3 } }, 2615 }, 2616 { 2617 "ALU_DIV_X: 4294967295 / 4294967295 = 1", 2618 .u.insns_int = { 2619 BPF_LD_IMM64(R0, 4294967295U), 2620 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U), 2621 BPF_ALU32_REG(BPF_DIV, R0, R1), 2622 BPF_EXIT_INSN(), 2623 }, 2624 INTERNAL, 2625 { }, 2626 { { 0, 1 } }, 2627 }, 2628 { 2629 "ALU64_DIV_X: 6 / 2 = 3", 2630 .u.insns_int = { 2631 BPF_LD_IMM64(R0, 6), 2632 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2633 BPF_ALU64_REG(BPF_DIV, R0, R1), 2634 BPF_EXIT_INSN(), 2635 }, 2636 INTERNAL, 2637 { }, 2638 { { 0, 3 } }, 2639 }, 2640 { 2641 "ALU64_DIV_X: 2147483647 / 2147483647 = 1", 2642 .u.insns_int = { 2643 BPF_LD_IMM64(R0, 2147483647), 2644 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647), 2645 BPF_ALU64_REG(BPF_DIV, R0, R1), 2646 BPF_EXIT_INSN(), 2647 }, 2648 INTERNAL, 2649 { }, 2650 { { 0, 1 } }, 2651 }, 2652 { 2653 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001", 2654 .u.insns_int = { 2655 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 2656 BPF_LD_IMM64(R4, 0xffffffffffffffffLL), 2657 BPF_LD_IMM64(R3, 0x0000000000000001LL), 2658 BPF_ALU64_REG(BPF_DIV, R2, R4), 2659 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2660 BPF_MOV32_IMM(R0, 2), 2661 BPF_EXIT_INSN(), 2662 BPF_MOV32_IMM(R0, 1), 2663 BPF_EXIT_INSN(), 2664 }, 2665 INTERNAL, 2666 { }, 2667 { { 0, 0x1 } }, 2668 }, 2669 /* BPF_ALU | BPF_DIV | BPF_K */ 2670 { 2671 "ALU_DIV_K: 6 / 2 = 3", 2672 .u.insns_int = { 2673 BPF_LD_IMM64(R0, 6), 2674 BPF_ALU32_IMM(BPF_DIV, R0, 2), 2675 BPF_EXIT_INSN(), 2676 }, 2677 INTERNAL, 2678 { }, 2679 { { 0, 3 } }, 2680 }, 2681 { 2682 "ALU_DIV_K: 3 / 1 = 3", 2683 .u.insns_int = { 2684 BPF_LD_IMM64(R0, 3), 2685 BPF_ALU32_IMM(BPF_DIV, R0, 1), 2686 BPF_EXIT_INSN(), 2687 }, 2688 INTERNAL, 2689 { }, 2690 { { 0, 3 } }, 2691 }, 2692 { 2693 "ALU_DIV_K: 4294967295 / 4294967295 = 1", 2694 .u.insns_int = { 2695 BPF_LD_IMM64(R0, 4294967295U), 2696 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U), 2697 BPF_EXIT_INSN(), 2698 }, 2699 INTERNAL, 2700 { }, 2701 { { 0, 1 } }, 2702 }, 2703 { 2704 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1", 2705 .u.insns_int = { 2706 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 2707 BPF_LD_IMM64(R3, 0x1UL), 2708 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff), 2709 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2710 BPF_MOV32_IMM(R0, 2), 2711 BPF_EXIT_INSN(), 2712 BPF_MOV32_IMM(R0, 1), 2713 BPF_EXIT_INSN(), 2714 }, 2715 INTERNAL, 2716 { }, 2717 { { 0, 0x1 } }, 2718 }, 2719 { 2720 "ALU64_DIV_K: 6 / 2 = 3", 2721 .u.insns_int = { 2722 BPF_LD_IMM64(R0, 6), 2723 BPF_ALU64_IMM(BPF_DIV, R0, 2), 2724 BPF_EXIT_INSN(), 2725 }, 2726 INTERNAL, 2727 { }, 2728 { { 0, 3 } }, 2729 }, 2730 { 2731 "ALU64_DIV_K: 3 / 1 = 3", 2732 .u.insns_int = { 2733 BPF_LD_IMM64(R0, 3), 2734 BPF_ALU64_IMM(BPF_DIV, R0, 1), 2735 BPF_EXIT_INSN(), 2736 }, 2737 INTERNAL, 2738 { }, 2739 { { 0, 3 } }, 2740 }, 2741 { 2742 "ALU64_DIV_K: 2147483647 / 2147483647 = 1", 2743 .u.insns_int = { 2744 BPF_LD_IMM64(R0, 2147483647), 2745 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647), 2746 BPF_EXIT_INSN(), 2747 }, 2748 INTERNAL, 2749 { }, 2750 { { 0, 1 } }, 2751 }, 2752 { 2753 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001", 2754 .u.insns_int = { 2755 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 2756 BPF_LD_IMM64(R3, 0x0000000000000001LL), 2757 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff), 2758 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2759 BPF_MOV32_IMM(R0, 2), 2760 BPF_EXIT_INSN(), 2761 BPF_MOV32_IMM(R0, 1), 2762 BPF_EXIT_INSN(), 2763 }, 2764 INTERNAL, 2765 { }, 2766 { { 0, 0x1 } }, 2767 }, 2768 /* BPF_ALU | BPF_MOD | BPF_X */ 2769 { 2770 "ALU_MOD_X: 3 % 2 = 1", 2771 .u.insns_int = { 2772 BPF_LD_IMM64(R0, 3), 2773 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2774 BPF_ALU32_REG(BPF_MOD, R0, R1), 2775 BPF_EXIT_INSN(), 2776 }, 2777 INTERNAL, 2778 { }, 2779 { { 0, 1 } }, 2780 }, 2781 { 2782 "ALU_MOD_X: 4294967295 % 4294967293 = 2", 2783 .u.insns_int = { 2784 BPF_LD_IMM64(R0, 4294967295U), 2785 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U), 2786 BPF_ALU32_REG(BPF_MOD, R0, R1), 2787 BPF_EXIT_INSN(), 2788 }, 2789 INTERNAL, 2790 { }, 2791 { { 0, 2 } }, 2792 }, 2793 { 2794 "ALU64_MOD_X: 3 % 2 = 1", 2795 .u.insns_int = { 2796 BPF_LD_IMM64(R0, 3), 2797 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2798 BPF_ALU64_REG(BPF_MOD, R0, R1), 2799 BPF_EXIT_INSN(), 2800 }, 2801 INTERNAL, 2802 { }, 2803 { { 0, 1 } }, 2804 }, 2805 { 2806 "ALU64_MOD_X: 2147483647 % 2147483645 = 2", 2807 .u.insns_int = { 2808 BPF_LD_IMM64(R0, 2147483647), 2809 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645), 2810 BPF_ALU64_REG(BPF_MOD, R0, R1), 2811 BPF_EXIT_INSN(), 2812 }, 2813 INTERNAL, 2814 { }, 2815 { { 0, 2 } }, 2816 }, 2817 /* BPF_ALU | BPF_MOD | BPF_K */ 2818 { 2819 "ALU_MOD_K: 3 % 2 = 1", 2820 .u.insns_int = { 2821 BPF_LD_IMM64(R0, 3), 2822 BPF_ALU32_IMM(BPF_MOD, R0, 2), 2823 BPF_EXIT_INSN(), 2824 }, 2825 INTERNAL, 2826 { }, 2827 { { 0, 1 } }, 2828 }, 2829 { 2830 "ALU_MOD_K: 3 % 1 = 0", 2831 .u.insns_int = { 2832 BPF_LD_IMM64(R0, 3), 2833 BPF_ALU32_IMM(BPF_MOD, R0, 1), 2834 BPF_EXIT_INSN(), 2835 }, 2836 INTERNAL, 2837 { }, 2838 { { 0, 0 } }, 2839 }, 2840 { 2841 "ALU_MOD_K: 4294967295 % 4294967293 = 2", 2842 .u.insns_int = { 2843 BPF_LD_IMM64(R0, 4294967295U), 2844 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U), 2845 BPF_EXIT_INSN(), 2846 }, 2847 INTERNAL, 2848 { }, 2849 { { 0, 2 } }, 2850 }, 2851 { 2852 "ALU64_MOD_K: 3 % 2 = 1", 2853 .u.insns_int = { 2854 BPF_LD_IMM64(R0, 3), 2855 BPF_ALU64_IMM(BPF_MOD, R0, 2), 2856 BPF_EXIT_INSN(), 2857 }, 2858 INTERNAL, 2859 { }, 2860 { { 0, 1 } }, 2861 }, 2862 { 2863 "ALU64_MOD_K: 3 % 1 = 0", 2864 .u.insns_int = { 2865 BPF_LD_IMM64(R0, 3), 2866 BPF_ALU64_IMM(BPF_MOD, R0, 1), 2867 BPF_EXIT_INSN(), 2868 }, 2869 INTERNAL, 2870 { }, 2871 { { 0, 0 } }, 2872 }, 2873 { 2874 "ALU64_MOD_K: 2147483647 % 2147483645 = 2", 2875 .u.insns_int = { 2876 BPF_LD_IMM64(R0, 2147483647), 2877 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645), 2878 BPF_EXIT_INSN(), 2879 }, 2880 INTERNAL, 2881 { }, 2882 { { 0, 2 } }, 2883 }, 2884 /* BPF_ALU | BPF_AND | BPF_X */ 2885 { 2886 "ALU_AND_X: 3 & 2 = 2", 2887 .u.insns_int = { 2888 BPF_LD_IMM64(R0, 3), 2889 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2890 BPF_ALU32_REG(BPF_AND, R0, R1), 2891 BPF_EXIT_INSN(), 2892 }, 2893 INTERNAL, 2894 { }, 2895 { { 0, 2 } }, 2896 }, 2897 { 2898 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 2899 .u.insns_int = { 2900 BPF_LD_IMM64(R0, 0xffffffff), 2901 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 2902 BPF_ALU32_REG(BPF_AND, R0, R1), 2903 BPF_EXIT_INSN(), 2904 }, 2905 INTERNAL, 2906 { }, 2907 { { 0, 0xffffffff } }, 2908 }, 2909 { 2910 "ALU64_AND_X: 3 & 2 = 2", 2911 .u.insns_int = { 2912 BPF_LD_IMM64(R0, 3), 2913 BPF_ALU32_IMM(BPF_MOV, R1, 2), 2914 BPF_ALU64_REG(BPF_AND, R0, R1), 2915 BPF_EXIT_INSN(), 2916 }, 2917 INTERNAL, 2918 { }, 2919 { { 0, 2 } }, 2920 }, 2921 { 2922 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff", 2923 .u.insns_int = { 2924 BPF_LD_IMM64(R0, 0xffffffff), 2925 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 2926 BPF_ALU64_REG(BPF_AND, R0, R1), 2927 BPF_EXIT_INSN(), 2928 }, 2929 INTERNAL, 2930 { }, 2931 { { 0, 0xffffffff } }, 2932 }, 2933 /* BPF_ALU | BPF_AND | BPF_K */ 2934 { 2935 "ALU_AND_K: 3 & 2 = 2", 2936 .u.insns_int = { 2937 BPF_LD_IMM64(R0, 3), 2938 BPF_ALU32_IMM(BPF_AND, R0, 2), 2939 BPF_EXIT_INSN(), 2940 }, 2941 INTERNAL, 2942 { }, 2943 { { 0, 2 } }, 2944 }, 2945 { 2946 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 2947 .u.insns_int = { 2948 BPF_LD_IMM64(R0, 0xffffffff), 2949 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff), 2950 BPF_EXIT_INSN(), 2951 }, 2952 INTERNAL, 2953 { }, 2954 { { 0, 0xffffffff } }, 2955 }, 2956 { 2957 "ALU64_AND_K: 3 & 2 = 2", 2958 .u.insns_int = { 2959 BPF_LD_IMM64(R0, 3), 2960 BPF_ALU64_IMM(BPF_AND, R0, 2), 2961 BPF_EXIT_INSN(), 2962 }, 2963 INTERNAL, 2964 { }, 2965 { { 0, 2 } }, 2966 }, 2967 { 2968 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff", 2969 .u.insns_int = { 2970 BPF_LD_IMM64(R0, 0xffffffff), 2971 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff), 2972 BPF_EXIT_INSN(), 2973 }, 2974 INTERNAL, 2975 { }, 2976 { { 0, 0xffffffff } }, 2977 }, 2978 { 2979 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000ffff00000000", 2980 .u.insns_int = { 2981 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 2982 BPF_LD_IMM64(R3, 0x0000000000000000LL), 2983 BPF_ALU64_IMM(BPF_AND, R2, 0x0), 2984 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 2985 BPF_MOV32_IMM(R0, 2), 2986 BPF_EXIT_INSN(), 2987 BPF_MOV32_IMM(R0, 1), 2988 BPF_EXIT_INSN(), 2989 }, 2990 INTERNAL, 2991 { }, 2992 { { 0, 0x1 } }, 2993 }, 2994 { 2995 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffffffff", 2996 .u.insns_int = { 2997 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 2998 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 2999 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 3000 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3001 BPF_MOV32_IMM(R0, 2), 3002 BPF_EXIT_INSN(), 3003 BPF_MOV32_IMM(R0, 1), 3004 BPF_EXIT_INSN(), 3005 }, 3006 INTERNAL, 3007 { }, 3008 { { 0, 0x1 } }, 3009 }, 3010 { 3011 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff", 3012 .u.insns_int = { 3013 BPF_LD_IMM64(R2, 0xffffffffffffffffLL), 3014 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3015 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff), 3016 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3017 BPF_MOV32_IMM(R0, 2), 3018 BPF_EXIT_INSN(), 3019 BPF_MOV32_IMM(R0, 1), 3020 BPF_EXIT_INSN(), 3021 }, 3022 INTERNAL, 3023 { }, 3024 { { 0, 0x1 } }, 3025 }, 3026 /* BPF_ALU | BPF_OR | BPF_X */ 3027 { 3028 "ALU_OR_X: 1 | 2 = 3", 3029 .u.insns_int = { 3030 BPF_LD_IMM64(R0, 1), 3031 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3032 BPF_ALU32_REG(BPF_OR, R0, R1), 3033 BPF_EXIT_INSN(), 3034 }, 3035 INTERNAL, 3036 { }, 3037 { { 0, 3 } }, 3038 }, 3039 { 3040 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff", 3041 .u.insns_int = { 3042 BPF_LD_IMM64(R0, 0), 3043 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 3044 BPF_ALU32_REG(BPF_OR, R0, R1), 3045 BPF_EXIT_INSN(), 3046 }, 3047 INTERNAL, 3048 { }, 3049 { { 0, 0xffffffff } }, 3050 }, 3051 { 3052 "ALU64_OR_X: 1 | 2 = 3", 3053 .u.insns_int = { 3054 BPF_LD_IMM64(R0, 1), 3055 BPF_ALU32_IMM(BPF_MOV, R1, 2), 3056 BPF_ALU64_REG(BPF_OR, R0, R1), 3057 BPF_EXIT_INSN(), 3058 }, 3059 INTERNAL, 3060 { }, 3061 { { 0, 3 } }, 3062 }, 3063 { 3064 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff", 3065 .u.insns_int = { 3066 BPF_LD_IMM64(R0, 0), 3067 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 3068 BPF_ALU64_REG(BPF_OR, R0, R1), 3069 BPF_EXIT_INSN(), 3070 }, 3071 INTERNAL, 3072 { }, 3073 { { 0, 0xffffffff } }, 3074 }, 3075 /* BPF_ALU | BPF_OR | BPF_K */ 3076 { 3077 "ALU_OR_K: 1 | 2 = 3", 3078 .u.insns_int = { 3079 BPF_LD_IMM64(R0, 1), 3080 BPF_ALU32_IMM(BPF_OR, R0, 2), 3081 BPF_EXIT_INSN(), 3082 }, 3083 INTERNAL, 3084 { }, 3085 { { 0, 3 } }, 3086 }, 3087 { 3088 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff", 3089 .u.insns_int = { 3090 BPF_LD_IMM64(R0, 0), 3091 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff), 3092 BPF_EXIT_INSN(), 3093 }, 3094 INTERNAL, 3095 { }, 3096 { { 0, 0xffffffff } }, 3097 }, 3098 { 3099 "ALU64_OR_K: 1 | 2 = 3", 3100 .u.insns_int = { 3101 BPF_LD_IMM64(R0, 1), 3102 BPF_ALU64_IMM(BPF_OR, R0, 2), 3103 BPF_EXIT_INSN(), 3104 }, 3105 INTERNAL, 3106 { }, 3107 { { 0, 3 } }, 3108 }, 3109 { 3110 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff", 3111 .u.insns_int = { 3112 BPF_LD_IMM64(R0, 0), 3113 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff), 3114 BPF_EXIT_INSN(), 3115 }, 3116 INTERNAL, 3117 { }, 3118 { { 0, 0xffffffff } }, 3119 }, 3120 { 3121 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffff00000000", 3122 .u.insns_int = { 3123 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3124 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 3125 BPF_ALU64_IMM(BPF_OR, R2, 0x0), 3126 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3127 BPF_MOV32_IMM(R0, 2), 3128 BPF_EXIT_INSN(), 3129 BPF_MOV32_IMM(R0, 1), 3130 BPF_EXIT_INSN(), 3131 }, 3132 INTERNAL, 3133 { }, 3134 { { 0, 0x1 } }, 3135 }, 3136 { 3137 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff", 3138 .u.insns_int = { 3139 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3140 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3141 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 3142 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3143 BPF_MOV32_IMM(R0, 2), 3144 BPF_EXIT_INSN(), 3145 BPF_MOV32_IMM(R0, 1), 3146 BPF_EXIT_INSN(), 3147 }, 3148 INTERNAL, 3149 { }, 3150 { { 0, 0x1 } }, 3151 }, 3152 { 3153 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff", 3154 .u.insns_int = { 3155 BPF_LD_IMM64(R2, 0x0000000000000000LL), 3156 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3157 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff), 3158 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3159 BPF_MOV32_IMM(R0, 2), 3160 BPF_EXIT_INSN(), 3161 BPF_MOV32_IMM(R0, 1), 3162 BPF_EXIT_INSN(), 3163 }, 3164 INTERNAL, 3165 { }, 3166 { { 0, 0x1 } }, 3167 }, 3168 /* BPF_ALU | BPF_XOR | BPF_X */ 3169 { 3170 "ALU_XOR_X: 5 ^ 6 = 3", 3171 .u.insns_int = { 3172 BPF_LD_IMM64(R0, 5), 3173 BPF_ALU32_IMM(BPF_MOV, R1, 6), 3174 BPF_ALU32_REG(BPF_XOR, R0, R1), 3175 BPF_EXIT_INSN(), 3176 }, 3177 INTERNAL, 3178 { }, 3179 { { 0, 3 } }, 3180 }, 3181 { 3182 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe", 3183 .u.insns_int = { 3184 BPF_LD_IMM64(R0, 1), 3185 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 3186 BPF_ALU32_REG(BPF_XOR, R0, R1), 3187 BPF_EXIT_INSN(), 3188 }, 3189 INTERNAL, 3190 { }, 3191 { { 0, 0xfffffffe } }, 3192 }, 3193 { 3194 "ALU64_XOR_X: 5 ^ 6 = 3", 3195 .u.insns_int = { 3196 BPF_LD_IMM64(R0, 5), 3197 BPF_ALU32_IMM(BPF_MOV, R1, 6), 3198 BPF_ALU64_REG(BPF_XOR, R0, R1), 3199 BPF_EXIT_INSN(), 3200 }, 3201 INTERNAL, 3202 { }, 3203 { { 0, 3 } }, 3204 }, 3205 { 3206 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe", 3207 .u.insns_int = { 3208 BPF_LD_IMM64(R0, 1), 3209 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff), 3210 BPF_ALU64_REG(BPF_XOR, R0, R1), 3211 BPF_EXIT_INSN(), 3212 }, 3213 INTERNAL, 3214 { }, 3215 { { 0, 0xfffffffe } }, 3216 }, 3217 /* BPF_ALU | BPF_XOR | BPF_K */ 3218 { 3219 "ALU_XOR_K: 5 ^ 6 = 3", 3220 .u.insns_int = { 3221 BPF_LD_IMM64(R0, 5), 3222 BPF_ALU32_IMM(BPF_XOR, R0, 6), 3223 BPF_EXIT_INSN(), 3224 }, 3225 INTERNAL, 3226 { }, 3227 { { 0, 3 } }, 3228 }, 3229 { 3230 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe", 3231 .u.insns_int = { 3232 BPF_LD_IMM64(R0, 1), 3233 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff), 3234 BPF_EXIT_INSN(), 3235 }, 3236 INTERNAL, 3237 { }, 3238 { { 0, 0xfffffffe } }, 3239 }, 3240 { 3241 "ALU64_XOR_K: 5 ^ 6 = 3", 3242 .u.insns_int = { 3243 BPF_LD_IMM64(R0, 5), 3244 BPF_ALU64_IMM(BPF_XOR, R0, 6), 3245 BPF_EXIT_INSN(), 3246 }, 3247 INTERNAL, 3248 { }, 3249 { { 0, 3 } }, 3250 }, 3251 { 3252 "ALU64_XOR_K: 1 & 0xffffffff = 0xfffffffe", 3253 .u.insns_int = { 3254 BPF_LD_IMM64(R0, 1), 3255 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff), 3256 BPF_EXIT_INSN(), 3257 }, 3258 INTERNAL, 3259 { }, 3260 { { 0, 0xfffffffe } }, 3261 }, 3262 { 3263 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000", 3264 .u.insns_int = { 3265 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3266 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL), 3267 BPF_ALU64_IMM(BPF_XOR, R2, 0x0), 3268 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3269 BPF_MOV32_IMM(R0, 2), 3270 BPF_EXIT_INSN(), 3271 BPF_MOV32_IMM(R0, 1), 3272 BPF_EXIT_INSN(), 3273 }, 3274 INTERNAL, 3275 { }, 3276 { { 0, 0x1 } }, 3277 }, 3278 { 3279 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff", 3280 .u.insns_int = { 3281 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL), 3282 BPF_LD_IMM64(R3, 0xffff00000000ffffLL), 3283 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 3284 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3285 BPF_MOV32_IMM(R0, 2), 3286 BPF_EXIT_INSN(), 3287 BPF_MOV32_IMM(R0, 1), 3288 BPF_EXIT_INSN(), 3289 }, 3290 INTERNAL, 3291 { }, 3292 { { 0, 0x1 } }, 3293 }, 3294 { 3295 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff", 3296 .u.insns_int = { 3297 BPF_LD_IMM64(R2, 0x0000000000000000LL), 3298 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3299 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff), 3300 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3301 BPF_MOV32_IMM(R0, 2), 3302 BPF_EXIT_INSN(), 3303 BPF_MOV32_IMM(R0, 1), 3304 BPF_EXIT_INSN(), 3305 }, 3306 INTERNAL, 3307 { }, 3308 { { 0, 0x1 } }, 3309 }, 3310 /* BPF_ALU | BPF_LSH | BPF_X */ 3311 { 3312 "ALU_LSH_X: 1 << 1 = 2", 3313 .u.insns_int = { 3314 BPF_LD_IMM64(R0, 1), 3315 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3316 BPF_ALU32_REG(BPF_LSH, R0, R1), 3317 BPF_EXIT_INSN(), 3318 }, 3319 INTERNAL, 3320 { }, 3321 { { 0, 2 } }, 3322 }, 3323 { 3324 "ALU_LSH_X: 1 << 31 = 0x80000000", 3325 .u.insns_int = { 3326 BPF_LD_IMM64(R0, 1), 3327 BPF_ALU32_IMM(BPF_MOV, R1, 31), 3328 BPF_ALU32_REG(BPF_LSH, R0, R1), 3329 BPF_EXIT_INSN(), 3330 }, 3331 INTERNAL, 3332 { }, 3333 { { 0, 0x80000000 } }, 3334 }, 3335 { 3336 "ALU64_LSH_X: 1 << 1 = 2", 3337 .u.insns_int = { 3338 BPF_LD_IMM64(R0, 1), 3339 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3340 BPF_ALU64_REG(BPF_LSH, R0, R1), 3341 BPF_EXIT_INSN(), 3342 }, 3343 INTERNAL, 3344 { }, 3345 { { 0, 2 } }, 3346 }, 3347 { 3348 "ALU64_LSH_X: 1 << 31 = 0x80000000", 3349 .u.insns_int = { 3350 BPF_LD_IMM64(R0, 1), 3351 BPF_ALU32_IMM(BPF_MOV, R1, 31), 3352 BPF_ALU64_REG(BPF_LSH, R0, R1), 3353 BPF_EXIT_INSN(), 3354 }, 3355 INTERNAL, 3356 { }, 3357 { { 0, 0x80000000 } }, 3358 }, 3359 /* BPF_ALU | BPF_LSH | BPF_K */ 3360 { 3361 "ALU_LSH_K: 1 << 1 = 2", 3362 .u.insns_int = { 3363 BPF_LD_IMM64(R0, 1), 3364 BPF_ALU32_IMM(BPF_LSH, R0, 1), 3365 BPF_EXIT_INSN(), 3366 }, 3367 INTERNAL, 3368 { }, 3369 { { 0, 2 } }, 3370 }, 3371 { 3372 "ALU_LSH_K: 1 << 31 = 0x80000000", 3373 .u.insns_int = { 3374 BPF_LD_IMM64(R0, 1), 3375 BPF_ALU32_IMM(BPF_LSH, R0, 31), 3376 BPF_EXIT_INSN(), 3377 }, 3378 INTERNAL, 3379 { }, 3380 { { 0, 0x80000000 } }, 3381 }, 3382 { 3383 "ALU64_LSH_K: 1 << 1 = 2", 3384 .u.insns_int = { 3385 BPF_LD_IMM64(R0, 1), 3386 BPF_ALU64_IMM(BPF_LSH, R0, 1), 3387 BPF_EXIT_INSN(), 3388 }, 3389 INTERNAL, 3390 { }, 3391 { { 0, 2 } }, 3392 }, 3393 { 3394 "ALU64_LSH_K: 1 << 31 = 0x80000000", 3395 .u.insns_int = { 3396 BPF_LD_IMM64(R0, 1), 3397 BPF_ALU64_IMM(BPF_LSH, R0, 31), 3398 BPF_EXIT_INSN(), 3399 }, 3400 INTERNAL, 3401 { }, 3402 { { 0, 0x80000000 } }, 3403 }, 3404 /* BPF_ALU | BPF_RSH | BPF_X */ 3405 { 3406 "ALU_RSH_X: 2 >> 1 = 1", 3407 .u.insns_int = { 3408 BPF_LD_IMM64(R0, 2), 3409 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3410 BPF_ALU32_REG(BPF_RSH, R0, R1), 3411 BPF_EXIT_INSN(), 3412 }, 3413 INTERNAL, 3414 { }, 3415 { { 0, 1 } }, 3416 }, 3417 { 3418 "ALU_RSH_X: 0x80000000 >> 31 = 1", 3419 .u.insns_int = { 3420 BPF_LD_IMM64(R0, 0x80000000), 3421 BPF_ALU32_IMM(BPF_MOV, R1, 31), 3422 BPF_ALU32_REG(BPF_RSH, R0, R1), 3423 BPF_EXIT_INSN(), 3424 }, 3425 INTERNAL, 3426 { }, 3427 { { 0, 1 } }, 3428 }, 3429 { 3430 "ALU64_RSH_X: 2 >> 1 = 1", 3431 .u.insns_int = { 3432 BPF_LD_IMM64(R0, 2), 3433 BPF_ALU32_IMM(BPF_MOV, R1, 1), 3434 BPF_ALU64_REG(BPF_RSH, R0, R1), 3435 BPF_EXIT_INSN(), 3436 }, 3437 INTERNAL, 3438 { }, 3439 { { 0, 1 } }, 3440 }, 3441 { 3442 "ALU64_RSH_X: 0x80000000 >> 31 = 1", 3443 .u.insns_int = { 3444 BPF_LD_IMM64(R0, 0x80000000), 3445 BPF_ALU32_IMM(BPF_MOV, R1, 31), 3446 BPF_ALU64_REG(BPF_RSH, R0, R1), 3447 BPF_EXIT_INSN(), 3448 }, 3449 INTERNAL, 3450 { }, 3451 { { 0, 1 } }, 3452 }, 3453 /* BPF_ALU | BPF_RSH | BPF_K */ 3454 { 3455 "ALU_RSH_K: 2 >> 1 = 1", 3456 .u.insns_int = { 3457 BPF_LD_IMM64(R0, 2), 3458 BPF_ALU32_IMM(BPF_RSH, R0, 1), 3459 BPF_EXIT_INSN(), 3460 }, 3461 INTERNAL, 3462 { }, 3463 { { 0, 1 } }, 3464 }, 3465 { 3466 "ALU_RSH_K: 0x80000000 >> 31 = 1", 3467 .u.insns_int = { 3468 BPF_LD_IMM64(R0, 0x80000000), 3469 BPF_ALU32_IMM(BPF_RSH, R0, 31), 3470 BPF_EXIT_INSN(), 3471 }, 3472 INTERNAL, 3473 { }, 3474 { { 0, 1 } }, 3475 }, 3476 { 3477 "ALU64_RSH_K: 2 >> 1 = 1", 3478 .u.insns_int = { 3479 BPF_LD_IMM64(R0, 2), 3480 BPF_ALU64_IMM(BPF_RSH, R0, 1), 3481 BPF_EXIT_INSN(), 3482 }, 3483 INTERNAL, 3484 { }, 3485 { { 0, 1 } }, 3486 }, 3487 { 3488 "ALU64_RSH_K: 0x80000000 >> 31 = 1", 3489 .u.insns_int = { 3490 BPF_LD_IMM64(R0, 0x80000000), 3491 BPF_ALU64_IMM(BPF_RSH, R0, 31), 3492 BPF_EXIT_INSN(), 3493 }, 3494 INTERNAL, 3495 { }, 3496 { { 0, 1 } }, 3497 }, 3498 /* BPF_ALU | BPF_ARSH | BPF_X */ 3499 { 3500 "ALU_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 3501 .u.insns_int = { 3502 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 3503 BPF_ALU32_IMM(BPF_MOV, R1, 40), 3504 BPF_ALU64_REG(BPF_ARSH, R0, R1), 3505 BPF_EXIT_INSN(), 3506 }, 3507 INTERNAL, 3508 { }, 3509 { { 0, 0xffff00ff } }, 3510 }, 3511 /* BPF_ALU | BPF_ARSH | BPF_K */ 3512 { 3513 "ALU_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff", 3514 .u.insns_int = { 3515 BPF_LD_IMM64(R0, 0xff00ff0000000000LL), 3516 BPF_ALU64_IMM(BPF_ARSH, R0, 40), 3517 BPF_EXIT_INSN(), 3518 }, 3519 INTERNAL, 3520 { }, 3521 { { 0, 0xffff00ff } }, 3522 }, 3523 /* BPF_ALU | BPF_NEG */ 3524 { 3525 "ALU_NEG: -(3) = -3", 3526 .u.insns_int = { 3527 BPF_ALU32_IMM(BPF_MOV, R0, 3), 3528 BPF_ALU32_IMM(BPF_NEG, R0, 0), 3529 BPF_EXIT_INSN(), 3530 }, 3531 INTERNAL, 3532 { }, 3533 { { 0, -3 } }, 3534 }, 3535 { 3536 "ALU_NEG: -(-3) = 3", 3537 .u.insns_int = { 3538 BPF_ALU32_IMM(BPF_MOV, R0, -3), 3539 BPF_ALU32_IMM(BPF_NEG, R0, 0), 3540 BPF_EXIT_INSN(), 3541 }, 3542 INTERNAL, 3543 { }, 3544 { { 0, 3 } }, 3545 }, 3546 { 3547 "ALU64_NEG: -(3) = -3", 3548 .u.insns_int = { 3549 BPF_LD_IMM64(R0, 3), 3550 BPF_ALU64_IMM(BPF_NEG, R0, 0), 3551 BPF_EXIT_INSN(), 3552 }, 3553 INTERNAL, 3554 { }, 3555 { { 0, -3 } }, 3556 }, 3557 { 3558 "ALU64_NEG: -(-3) = 3", 3559 .u.insns_int = { 3560 BPF_LD_IMM64(R0, -3), 3561 BPF_ALU64_IMM(BPF_NEG, R0, 0), 3562 BPF_EXIT_INSN(), 3563 }, 3564 INTERNAL, 3565 { }, 3566 { { 0, 3 } }, 3567 }, 3568 /* BPF_ALU | BPF_END | BPF_FROM_BE */ 3569 { 3570 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef", 3571 .u.insns_int = { 3572 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3573 BPF_ENDIAN(BPF_FROM_BE, R0, 16), 3574 BPF_EXIT_INSN(), 3575 }, 3576 INTERNAL, 3577 { }, 3578 { { 0, cpu_to_be16(0xcdef) } }, 3579 }, 3580 { 3581 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef", 3582 .u.insns_int = { 3583 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3584 BPF_ENDIAN(BPF_FROM_BE, R0, 32), 3585 BPF_EXIT_INSN(), 3586 }, 3587 INTERNAL, 3588 { }, 3589 { { 0, cpu_to_be32(0x89abcdef) } }, 3590 }, 3591 { 3592 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef", 3593 .u.insns_int = { 3594 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3595 BPF_ENDIAN(BPF_FROM_BE, R0, 64), 3596 BPF_EXIT_INSN(), 3597 }, 3598 INTERNAL, 3599 { }, 3600 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } }, 3601 }, 3602 /* BPF_ALU | BPF_END | BPF_FROM_LE */ 3603 { 3604 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd", 3605 .u.insns_int = { 3606 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3607 BPF_ENDIAN(BPF_FROM_LE, R0, 16), 3608 BPF_EXIT_INSN(), 3609 }, 3610 INTERNAL, 3611 { }, 3612 { { 0, cpu_to_le16(0xcdef) } }, 3613 }, 3614 { 3615 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89", 3616 .u.insns_int = { 3617 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3618 BPF_ENDIAN(BPF_FROM_LE, R0, 32), 3619 BPF_EXIT_INSN(), 3620 }, 3621 INTERNAL, 3622 { }, 3623 { { 0, cpu_to_le32(0x89abcdef) } }, 3624 }, 3625 { 3626 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301", 3627 .u.insns_int = { 3628 BPF_LD_IMM64(R0, 0x0123456789abcdefLL), 3629 BPF_ENDIAN(BPF_FROM_LE, R0, 64), 3630 BPF_EXIT_INSN(), 3631 }, 3632 INTERNAL, 3633 { }, 3634 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } }, 3635 }, 3636 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */ 3637 { 3638 "ST_MEM_B: Store/Load byte: max negative", 3639 .u.insns_int = { 3640 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3641 BPF_ST_MEM(BPF_B, R10, -40, 0xff), 3642 BPF_LDX_MEM(BPF_B, R0, R10, -40), 3643 BPF_EXIT_INSN(), 3644 }, 3645 INTERNAL, 3646 { }, 3647 { { 0, 0xff } }, 3648 }, 3649 { 3650 "ST_MEM_B: Store/Load byte: max positive", 3651 .u.insns_int = { 3652 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3653 BPF_ST_MEM(BPF_H, R10, -40, 0x7f), 3654 BPF_LDX_MEM(BPF_H, R0, R10, -40), 3655 BPF_EXIT_INSN(), 3656 }, 3657 INTERNAL, 3658 { }, 3659 { { 0, 0x7f } }, 3660 }, 3661 { 3662 "STX_MEM_B: Store/Load byte: max negative", 3663 .u.insns_int = { 3664 BPF_LD_IMM64(R0, 0), 3665 BPF_LD_IMM64(R1, 0xffLL), 3666 BPF_STX_MEM(BPF_B, R10, R1, -40), 3667 BPF_LDX_MEM(BPF_B, R0, R10, -40), 3668 BPF_EXIT_INSN(), 3669 }, 3670 INTERNAL, 3671 { }, 3672 { { 0, 0xff } }, 3673 }, 3674 { 3675 "ST_MEM_H: Store/Load half word: max negative", 3676 .u.insns_int = { 3677 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3678 BPF_ST_MEM(BPF_H, R10, -40, 0xffff), 3679 BPF_LDX_MEM(BPF_H, R0, R10, -40), 3680 BPF_EXIT_INSN(), 3681 }, 3682 INTERNAL, 3683 { }, 3684 { { 0, 0xffff } }, 3685 }, 3686 { 3687 "ST_MEM_H: Store/Load half word: max positive", 3688 .u.insns_int = { 3689 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3690 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff), 3691 BPF_LDX_MEM(BPF_H, R0, R10, -40), 3692 BPF_EXIT_INSN(), 3693 }, 3694 INTERNAL, 3695 { }, 3696 { { 0, 0x7fff } }, 3697 }, 3698 { 3699 "STX_MEM_H: Store/Load half word: max negative", 3700 .u.insns_int = { 3701 BPF_LD_IMM64(R0, 0), 3702 BPF_LD_IMM64(R1, 0xffffLL), 3703 BPF_STX_MEM(BPF_H, R10, R1, -40), 3704 BPF_LDX_MEM(BPF_H, R0, R10, -40), 3705 BPF_EXIT_INSN(), 3706 }, 3707 INTERNAL, 3708 { }, 3709 { { 0, 0xffff } }, 3710 }, 3711 { 3712 "ST_MEM_W: Store/Load word: max negative", 3713 .u.insns_int = { 3714 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3715 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff), 3716 BPF_LDX_MEM(BPF_W, R0, R10, -40), 3717 BPF_EXIT_INSN(), 3718 }, 3719 INTERNAL, 3720 { }, 3721 { { 0, 0xffffffff } }, 3722 }, 3723 { 3724 "ST_MEM_W: Store/Load word: max positive", 3725 .u.insns_int = { 3726 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3727 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff), 3728 BPF_LDX_MEM(BPF_W, R0, R10, -40), 3729 BPF_EXIT_INSN(), 3730 }, 3731 INTERNAL, 3732 { }, 3733 { { 0, 0x7fffffff } }, 3734 }, 3735 { 3736 "STX_MEM_W: Store/Load word: max negative", 3737 .u.insns_int = { 3738 BPF_LD_IMM64(R0, 0), 3739 BPF_LD_IMM64(R1, 0xffffffffLL), 3740 BPF_STX_MEM(BPF_W, R10, R1, -40), 3741 BPF_LDX_MEM(BPF_W, R0, R10, -40), 3742 BPF_EXIT_INSN(), 3743 }, 3744 INTERNAL, 3745 { }, 3746 { { 0, 0xffffffff } }, 3747 }, 3748 { 3749 "ST_MEM_DW: Store/Load double word: max negative", 3750 .u.insns_int = { 3751 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3752 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 3753 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 3754 BPF_EXIT_INSN(), 3755 }, 3756 INTERNAL, 3757 { }, 3758 { { 0, 0xffffffff } }, 3759 }, 3760 { 3761 "ST_MEM_DW: Store/Load double word: max negative 2", 3762 .u.insns_int = { 3763 BPF_LD_IMM64(R2, 0xffff00000000ffffLL), 3764 BPF_LD_IMM64(R3, 0xffffffffffffffffLL), 3765 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff), 3766 BPF_LDX_MEM(BPF_DW, R2, R10, -40), 3767 BPF_JMP_REG(BPF_JEQ, R2, R3, 2), 3768 BPF_MOV32_IMM(R0, 2), 3769 BPF_EXIT_INSN(), 3770 BPF_MOV32_IMM(R0, 1), 3771 BPF_EXIT_INSN(), 3772 }, 3773 INTERNAL, 3774 { }, 3775 { { 0, 0x1 } }, 3776 }, 3777 { 3778 "ST_MEM_DW: Store/Load double word: max positive", 3779 .u.insns_int = { 3780 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3781 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff), 3782 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 3783 BPF_EXIT_INSN(), 3784 }, 3785 INTERNAL, 3786 { }, 3787 { { 0, 0x7fffffff } }, 3788 }, 3789 { 3790 "STX_MEM_DW: Store/Load double word: max negative", 3791 .u.insns_int = { 3792 BPF_LD_IMM64(R0, 0), 3793 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 3794 BPF_STX_MEM(BPF_W, R10, R1, -40), 3795 BPF_LDX_MEM(BPF_W, R0, R10, -40), 3796 BPF_EXIT_INSN(), 3797 }, 3798 INTERNAL, 3799 { }, 3800 { { 0, 0xffffffff } }, 3801 }, 3802 /* BPF_STX | BPF_XADD | BPF_W/DW */ 3803 { 3804 "STX_XADD_W: Test: 0x12 + 0x10 = 0x22", 3805 .u.insns_int = { 3806 BPF_ALU32_IMM(BPF_MOV, R0, 0x12), 3807 BPF_ST_MEM(BPF_W, R10, -40, 0x10), 3808 BPF_STX_XADD(BPF_W, R10, R0, -40), 3809 BPF_LDX_MEM(BPF_W, R0, R10, -40), 3810 BPF_EXIT_INSN(), 3811 }, 3812 INTERNAL, 3813 { }, 3814 { { 0, 0x22 } }, 3815 }, 3816 { 3817 "STX_XADD_DW: Test: 0x12 + 0x10 = 0x22", 3818 .u.insns_int = { 3819 BPF_ALU32_IMM(BPF_MOV, R0, 0x12), 3820 BPF_ST_MEM(BPF_DW, R10, -40, 0x10), 3821 BPF_STX_XADD(BPF_DW, R10, R0, -40), 3822 BPF_LDX_MEM(BPF_DW, R0, R10, -40), 3823 BPF_EXIT_INSN(), 3824 }, 3825 INTERNAL, 3826 { }, 3827 { { 0, 0x22 } }, 3828 }, 3829 /* BPF_JMP | BPF_EXIT */ 3830 { 3831 "JMP_EXIT", 3832 .u.insns_int = { 3833 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711), 3834 BPF_EXIT_INSN(), 3835 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712), 3836 }, 3837 INTERNAL, 3838 { }, 3839 { { 0, 0x4711 } }, 3840 }, 3841 /* BPF_JMP | BPF_JA */ 3842 { 3843 "JMP_JA: Unconditional jump: if (true) return 1", 3844 .u.insns_int = { 3845 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3846 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 3847 BPF_EXIT_INSN(), 3848 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3849 BPF_EXIT_INSN(), 3850 }, 3851 INTERNAL, 3852 { }, 3853 { { 0, 1 } }, 3854 }, 3855 /* BPF_JMP | BPF_JSGT | BPF_K */ 3856 { 3857 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1", 3858 .u.insns_int = { 3859 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3860 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 3861 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1), 3862 BPF_EXIT_INSN(), 3863 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3864 BPF_EXIT_INSN(), 3865 }, 3866 INTERNAL, 3867 { }, 3868 { { 0, 1 } }, 3869 }, 3870 { 3871 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0", 3872 .u.insns_int = { 3873 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3874 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 3875 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1), 3876 BPF_EXIT_INSN(), 3877 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3878 BPF_EXIT_INSN(), 3879 }, 3880 INTERNAL, 3881 { }, 3882 { { 0, 1 } }, 3883 }, 3884 /* BPF_JMP | BPF_JSGE | BPF_K */ 3885 { 3886 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1", 3887 .u.insns_int = { 3888 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3889 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 3890 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1), 3891 BPF_EXIT_INSN(), 3892 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3893 BPF_EXIT_INSN(), 3894 }, 3895 INTERNAL, 3896 { }, 3897 { { 0, 1 } }, 3898 }, 3899 { 3900 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1", 3901 .u.insns_int = { 3902 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3903 BPF_LD_IMM64(R1, 0xffffffffffffffffLL), 3904 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1), 3905 BPF_EXIT_INSN(), 3906 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3907 BPF_EXIT_INSN(), 3908 }, 3909 INTERNAL, 3910 { }, 3911 { { 0, 1 } }, 3912 }, 3913 /* BPF_JMP | BPF_JGT | BPF_K */ 3914 { 3915 "JMP_JGT_K: if (3 > 2) return 1", 3916 .u.insns_int = { 3917 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3918 BPF_LD_IMM64(R1, 3), 3919 BPF_JMP_IMM(BPF_JGT, R1, 2, 1), 3920 BPF_EXIT_INSN(), 3921 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3922 BPF_EXIT_INSN(), 3923 }, 3924 INTERNAL, 3925 { }, 3926 { { 0, 1 } }, 3927 }, 3928 /* BPF_JMP | BPF_JGE | BPF_K */ 3929 { 3930 "JMP_JGE_K: if (3 >= 2) return 1", 3931 .u.insns_int = { 3932 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3933 BPF_LD_IMM64(R1, 3), 3934 BPF_JMP_IMM(BPF_JGE, R1, 2, 1), 3935 BPF_EXIT_INSN(), 3936 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3937 BPF_EXIT_INSN(), 3938 }, 3939 INTERNAL, 3940 { }, 3941 { { 0, 1 } }, 3942 }, 3943 { 3944 "JMP_JGE_K: if (3 >= 3) return 1", 3945 .u.insns_int = { 3946 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3947 BPF_LD_IMM64(R1, 3), 3948 BPF_JMP_IMM(BPF_JGE, R1, 3, 1), 3949 BPF_EXIT_INSN(), 3950 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3951 BPF_EXIT_INSN(), 3952 }, 3953 INTERNAL, 3954 { }, 3955 { { 0, 1 } }, 3956 }, 3957 /* BPF_JMP | BPF_JNE | BPF_K */ 3958 { 3959 "JMP_JNE_K: if (3 != 2) return 1", 3960 .u.insns_int = { 3961 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3962 BPF_LD_IMM64(R1, 3), 3963 BPF_JMP_IMM(BPF_JNE, R1, 2, 1), 3964 BPF_EXIT_INSN(), 3965 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3966 BPF_EXIT_INSN(), 3967 }, 3968 INTERNAL, 3969 { }, 3970 { { 0, 1 } }, 3971 }, 3972 /* BPF_JMP | BPF_JEQ | BPF_K */ 3973 { 3974 "JMP_JEQ_K: if (3 == 3) return 1", 3975 .u.insns_int = { 3976 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3977 BPF_LD_IMM64(R1, 3), 3978 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1), 3979 BPF_EXIT_INSN(), 3980 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3981 BPF_EXIT_INSN(), 3982 }, 3983 INTERNAL, 3984 { }, 3985 { { 0, 1 } }, 3986 }, 3987 /* BPF_JMP | BPF_JSET | BPF_K */ 3988 { 3989 "JMP_JSET_K: if (0x3 & 0x2) return 1", 3990 .u.insns_int = { 3991 BPF_ALU32_IMM(BPF_MOV, R0, 0), 3992 BPF_LD_IMM64(R1, 3), 3993 BPF_JMP_IMM(BPF_JNE, R1, 2, 1), 3994 BPF_EXIT_INSN(), 3995 BPF_ALU32_IMM(BPF_MOV, R0, 1), 3996 BPF_EXIT_INSN(), 3997 }, 3998 INTERNAL, 3999 { }, 4000 { { 0, 1 } }, 4001 }, 4002 { 4003 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1", 4004 .u.insns_int = { 4005 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4006 BPF_LD_IMM64(R1, 3), 4007 BPF_JMP_IMM(BPF_JNE, R1, 0xffffffff, 1), 4008 BPF_EXIT_INSN(), 4009 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4010 BPF_EXIT_INSN(), 4011 }, 4012 INTERNAL, 4013 { }, 4014 { { 0, 1 } }, 4015 }, 4016 /* BPF_JMP | BPF_JSGT | BPF_X */ 4017 { 4018 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1", 4019 .u.insns_int = { 4020 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4021 BPF_LD_IMM64(R1, -1), 4022 BPF_LD_IMM64(R2, -2), 4023 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 4024 BPF_EXIT_INSN(), 4025 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4026 BPF_EXIT_INSN(), 4027 }, 4028 INTERNAL, 4029 { }, 4030 { { 0, 1 } }, 4031 }, 4032 { 4033 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0", 4034 .u.insns_int = { 4035 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4036 BPF_LD_IMM64(R1, -1), 4037 BPF_LD_IMM64(R2, -1), 4038 BPF_JMP_REG(BPF_JSGT, R1, R2, 1), 4039 BPF_EXIT_INSN(), 4040 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4041 BPF_EXIT_INSN(), 4042 }, 4043 INTERNAL, 4044 { }, 4045 { { 0, 1 } }, 4046 }, 4047 /* BPF_JMP | BPF_JSGE | BPF_X */ 4048 { 4049 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1", 4050 .u.insns_int = { 4051 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4052 BPF_LD_IMM64(R1, -1), 4053 BPF_LD_IMM64(R2, -2), 4054 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 4055 BPF_EXIT_INSN(), 4056 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4057 BPF_EXIT_INSN(), 4058 }, 4059 INTERNAL, 4060 { }, 4061 { { 0, 1 } }, 4062 }, 4063 { 4064 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1", 4065 .u.insns_int = { 4066 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4067 BPF_LD_IMM64(R1, -1), 4068 BPF_LD_IMM64(R2, -1), 4069 BPF_JMP_REG(BPF_JSGE, R1, R2, 1), 4070 BPF_EXIT_INSN(), 4071 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4072 BPF_EXIT_INSN(), 4073 }, 4074 INTERNAL, 4075 { }, 4076 { { 0, 1 } }, 4077 }, 4078 /* BPF_JMP | BPF_JGT | BPF_X */ 4079 { 4080 "JMP_JGT_X: if (3 > 2) return 1", 4081 .u.insns_int = { 4082 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4083 BPF_LD_IMM64(R1, 3), 4084 BPF_LD_IMM64(R2, 2), 4085 BPF_JMP_REG(BPF_JGT, R1, R2, 1), 4086 BPF_EXIT_INSN(), 4087 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4088 BPF_EXIT_INSN(), 4089 }, 4090 INTERNAL, 4091 { }, 4092 { { 0, 1 } }, 4093 }, 4094 /* BPF_JMP | BPF_JGE | BPF_X */ 4095 { 4096 "JMP_JGE_X: if (3 >= 2) return 1", 4097 .u.insns_int = { 4098 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4099 BPF_LD_IMM64(R1, 3), 4100 BPF_LD_IMM64(R2, 2), 4101 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 4102 BPF_EXIT_INSN(), 4103 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4104 BPF_EXIT_INSN(), 4105 }, 4106 INTERNAL, 4107 { }, 4108 { { 0, 1 } }, 4109 }, 4110 { 4111 "JMP_JGE_X: if (3 >= 3) return 1", 4112 .u.insns_int = { 4113 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4114 BPF_LD_IMM64(R1, 3), 4115 BPF_LD_IMM64(R2, 3), 4116 BPF_JMP_REG(BPF_JGE, R1, R2, 1), 4117 BPF_EXIT_INSN(), 4118 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4119 BPF_EXIT_INSN(), 4120 }, 4121 INTERNAL, 4122 { }, 4123 { { 0, 1 } }, 4124 }, 4125 /* BPF_JMP | BPF_JNE | BPF_X */ 4126 { 4127 "JMP_JNE_X: if (3 != 2) return 1", 4128 .u.insns_int = { 4129 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4130 BPF_LD_IMM64(R1, 3), 4131 BPF_LD_IMM64(R2, 2), 4132 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 4133 BPF_EXIT_INSN(), 4134 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4135 BPF_EXIT_INSN(), 4136 }, 4137 INTERNAL, 4138 { }, 4139 { { 0, 1 } }, 4140 }, 4141 /* BPF_JMP | BPF_JEQ | BPF_X */ 4142 { 4143 "JMP_JEQ_X: if (3 == 3) return 1", 4144 .u.insns_int = { 4145 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4146 BPF_LD_IMM64(R1, 3), 4147 BPF_LD_IMM64(R2, 3), 4148 BPF_JMP_REG(BPF_JEQ, R1, R2, 1), 4149 BPF_EXIT_INSN(), 4150 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4151 BPF_EXIT_INSN(), 4152 }, 4153 INTERNAL, 4154 { }, 4155 { { 0, 1 } }, 4156 }, 4157 /* BPF_JMP | BPF_JSET | BPF_X */ 4158 { 4159 "JMP_JSET_X: if (0x3 & 0x2) return 1", 4160 .u.insns_int = { 4161 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4162 BPF_LD_IMM64(R1, 3), 4163 BPF_LD_IMM64(R2, 2), 4164 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 4165 BPF_EXIT_INSN(), 4166 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4167 BPF_EXIT_INSN(), 4168 }, 4169 INTERNAL, 4170 { }, 4171 { { 0, 1 } }, 4172 }, 4173 { 4174 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1", 4175 .u.insns_int = { 4176 BPF_ALU32_IMM(BPF_MOV, R0, 0), 4177 BPF_LD_IMM64(R1, 3), 4178 BPF_LD_IMM64(R2, 0xffffffff), 4179 BPF_JMP_REG(BPF_JNE, R1, R2, 1), 4180 BPF_EXIT_INSN(), 4181 BPF_ALU32_IMM(BPF_MOV, R0, 1), 4182 BPF_EXIT_INSN(), 4183 }, 4184 INTERNAL, 4185 { }, 4186 { { 0, 1 } }, 4187 }, 4188 { /* Mainly checking JIT here. */ 4189 "BPF_MAXINSNS: Maximum possible literals", 4190 { }, 4191 CLASSIC | FLAG_NO_DATA, 4192 { }, 4193 { { 0, 0xffffffff } }, 4194 .fill_helper = bpf_fill_maxinsns1, 4195 }, 4196 { /* Mainly checking JIT here. */ 4197 "BPF_MAXINSNS: Single literal", 4198 { }, 4199 CLASSIC | FLAG_NO_DATA, 4200 { }, 4201 { { 0, 0xfefefefe } }, 4202 .fill_helper = bpf_fill_maxinsns2, 4203 }, 4204 { /* Mainly checking JIT here. */ 4205 "BPF_MAXINSNS: Run/add until end", 4206 { }, 4207 CLASSIC | FLAG_NO_DATA, 4208 { }, 4209 { { 0, 0x947bf368 } }, 4210 .fill_helper = bpf_fill_maxinsns3, 4211 }, 4212 { 4213 "BPF_MAXINSNS: Too many instructions", 4214 { }, 4215 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL, 4216 { }, 4217 { }, 4218 .fill_helper = bpf_fill_maxinsns4, 4219 }, 4220 { /* Mainly checking JIT here. */ 4221 "BPF_MAXINSNS: Very long jump", 4222 { }, 4223 CLASSIC | FLAG_NO_DATA, 4224 { }, 4225 { { 0, 0xabababab } }, 4226 .fill_helper = bpf_fill_maxinsns5, 4227 }, 4228 { /* Mainly checking JIT here. */ 4229 "BPF_MAXINSNS: Ctx heavy transformations", 4230 { }, 4231 CLASSIC, 4232 { }, 4233 { 4234 { 1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }, 4235 { 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) } 4236 }, 4237 .fill_helper = bpf_fill_maxinsns6, 4238 }, 4239 { /* Mainly checking JIT here. */ 4240 "BPF_MAXINSNS: Call heavy transformations", 4241 { }, 4242 CLASSIC | FLAG_NO_DATA, 4243 { }, 4244 { { 1, 0 }, { 10, 0 } }, 4245 .fill_helper = bpf_fill_maxinsns7, 4246 }, 4247 { /* Mainly checking JIT here. */ 4248 "BPF_MAXINSNS: Jump heavy test", 4249 { }, 4250 CLASSIC | FLAG_NO_DATA, 4251 { }, 4252 { { 0, 0xffffffff } }, 4253 .fill_helper = bpf_fill_maxinsns8, 4254 }, 4255 }; 4256 4257 static struct net_device dev; 4258 4259 static struct sk_buff *populate_skb(char *buf, int size) 4260 { 4261 struct sk_buff *skb; 4262 4263 if (size >= MAX_DATA) 4264 return NULL; 4265 4266 skb = alloc_skb(MAX_DATA, GFP_KERNEL); 4267 if (!skb) 4268 return NULL; 4269 4270 memcpy(__skb_put(skb, size), buf, size); 4271 4272 /* Initialize a fake skb with test pattern. */ 4273 skb_reset_mac_header(skb); 4274 skb->protocol = htons(ETH_P_IP); 4275 skb->pkt_type = SKB_TYPE; 4276 skb->mark = SKB_MARK; 4277 skb->hash = SKB_HASH; 4278 skb->queue_mapping = SKB_QUEUE_MAP; 4279 skb->vlan_tci = SKB_VLAN_TCI; 4280 skb->dev = &dev; 4281 skb->dev->ifindex = SKB_DEV_IFINDEX; 4282 skb->dev->type = SKB_DEV_TYPE; 4283 skb_set_network_header(skb, min(size, ETH_HLEN)); 4284 4285 return skb; 4286 } 4287 4288 static void *generate_test_data(struct bpf_test *test, int sub) 4289 { 4290 if (test->aux & FLAG_NO_DATA) 4291 return NULL; 4292 4293 /* Test case expects an skb, so populate one. Various 4294 * subtests generate skbs of different sizes based on 4295 * the same data. 4296 */ 4297 return populate_skb(test->data, test->test[sub].data_size); 4298 } 4299 4300 static void release_test_data(const struct bpf_test *test, void *data) 4301 { 4302 if (test->aux & FLAG_NO_DATA) 4303 return; 4304 4305 kfree_skb(data); 4306 } 4307 4308 static int filter_length(int which) 4309 { 4310 struct sock_filter *fp; 4311 int len; 4312 4313 if (tests[which].fill_helper) 4314 return tests[which].u.ptr.len; 4315 4316 fp = tests[which].u.insns; 4317 for (len = MAX_INSNS - 1; len > 0; --len) 4318 if (fp[len].code != 0 || fp[len].k != 0) 4319 break; 4320 4321 return len + 1; 4322 } 4323 4324 static void *filter_pointer(int which) 4325 { 4326 if (tests[which].fill_helper) 4327 return tests[which].u.ptr.insns; 4328 else 4329 return tests[which].u.insns; 4330 } 4331 4332 static struct bpf_prog *generate_filter(int which, int *err) 4333 { 4334 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 4335 unsigned int flen = filter_length(which); 4336 void *fptr = filter_pointer(which); 4337 struct sock_fprog_kern fprog; 4338 struct bpf_prog *fp; 4339 4340 switch (test_type) { 4341 case CLASSIC: 4342 fprog.filter = fptr; 4343 fprog.len = flen; 4344 4345 *err = bpf_prog_create(&fp, &fprog); 4346 if (tests[which].aux & FLAG_EXPECTED_FAIL) { 4347 if (*err == -EINVAL) { 4348 pr_cont("PASS\n"); 4349 /* Verifier rejected filter as expected. */ 4350 *err = 0; 4351 return NULL; 4352 } else { 4353 pr_cont("UNEXPECTED_PASS\n"); 4354 /* Verifier didn't reject the test that's 4355 * bad enough, just return! 4356 */ 4357 *err = -EINVAL; 4358 return NULL; 4359 } 4360 } 4361 /* We don't expect to fail. */ 4362 if (*err) { 4363 pr_cont("FAIL to attach err=%d len=%d\n", 4364 *err, fprog.len); 4365 return NULL; 4366 } 4367 break; 4368 4369 case INTERNAL: 4370 fp = bpf_prog_alloc(bpf_prog_size(flen), 0); 4371 if (fp == NULL) { 4372 pr_cont("UNEXPECTED_FAIL no memory left\n"); 4373 *err = -ENOMEM; 4374 return NULL; 4375 } 4376 4377 fp->len = flen; 4378 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn)); 4379 4380 bpf_prog_select_runtime(fp); 4381 break; 4382 } 4383 4384 *err = 0; 4385 return fp; 4386 } 4387 4388 static void release_filter(struct bpf_prog *fp, int which) 4389 { 4390 __u8 test_type = tests[which].aux & TEST_TYPE_MASK; 4391 4392 switch (test_type) { 4393 case CLASSIC: 4394 bpf_prog_destroy(fp); 4395 break; 4396 case INTERNAL: 4397 bpf_prog_free(fp); 4398 break; 4399 } 4400 } 4401 4402 static int __run_one(const struct bpf_prog *fp, const void *data, 4403 int runs, u64 *duration) 4404 { 4405 u64 start, finish; 4406 int ret = 0, i; 4407 4408 start = ktime_to_us(ktime_get()); 4409 4410 for (i = 0; i < runs; i++) 4411 ret = BPF_PROG_RUN(fp, data); 4412 4413 finish = ktime_to_us(ktime_get()); 4414 4415 *duration = (finish - start) * 1000ULL; 4416 do_div(*duration, runs); 4417 4418 return ret; 4419 } 4420 4421 static int run_one(const struct bpf_prog *fp, struct bpf_test *test) 4422 { 4423 int err_cnt = 0, i, runs = MAX_TESTRUNS; 4424 4425 for (i = 0; i < MAX_SUBTESTS; i++) { 4426 void *data; 4427 u64 duration; 4428 u32 ret; 4429 4430 if (test->test[i].data_size == 0 && 4431 test->test[i].result == 0) 4432 break; 4433 4434 data = generate_test_data(test, i); 4435 ret = __run_one(fp, data, runs, &duration); 4436 release_test_data(test, data); 4437 4438 if (ret == test->test[i].result) { 4439 pr_cont("%lld ", duration); 4440 } else { 4441 pr_cont("ret %d != %d ", ret, 4442 test->test[i].result); 4443 err_cnt++; 4444 } 4445 } 4446 4447 return err_cnt; 4448 } 4449 4450 static __init int prepare_bpf_tests(void) 4451 { 4452 int i; 4453 4454 for (i = 0; i < ARRAY_SIZE(tests); i++) { 4455 if (tests[i].fill_helper && 4456 tests[i].fill_helper(&tests[i]) < 0) 4457 return -ENOMEM; 4458 } 4459 4460 return 0; 4461 } 4462 4463 static __init void destroy_bpf_tests(void) 4464 { 4465 int i; 4466 4467 for (i = 0; i < ARRAY_SIZE(tests); i++) { 4468 if (tests[i].fill_helper) 4469 kfree(tests[i].u.ptr.insns); 4470 } 4471 } 4472 4473 static __init int test_bpf(void) 4474 { 4475 int i, err_cnt = 0, pass_cnt = 0; 4476 int jit_cnt = 0, run_cnt = 0; 4477 4478 for (i = 0; i < ARRAY_SIZE(tests); i++) { 4479 struct bpf_prog *fp; 4480 int err; 4481 4482 pr_info("#%d %s ", i, tests[i].descr); 4483 4484 fp = generate_filter(i, &err); 4485 if (fp == NULL) { 4486 if (err == 0) { 4487 pass_cnt++; 4488 continue; 4489 } 4490 4491 return err; 4492 } 4493 4494 pr_cont("jited:%u ", fp->jited); 4495 4496 run_cnt++; 4497 if (fp->jited) 4498 jit_cnt++; 4499 4500 err = run_one(fp, &tests[i]); 4501 release_filter(fp, i); 4502 4503 if (err) { 4504 pr_cont("FAIL (%d times)\n", err); 4505 err_cnt++; 4506 } else { 4507 pr_cont("PASS\n"); 4508 pass_cnt++; 4509 } 4510 } 4511 4512 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n", 4513 pass_cnt, err_cnt, jit_cnt, run_cnt); 4514 4515 return err_cnt ? -EINVAL : 0; 4516 } 4517 4518 static int __init test_bpf_init(void) 4519 { 4520 int ret; 4521 4522 ret = prepare_bpf_tests(); 4523 if (ret < 0) 4524 return ret; 4525 4526 ret = test_bpf(); 4527 4528 destroy_bpf_tests(); 4529 return ret; 4530 } 4531 4532 static void __exit test_bpf_exit(void) 4533 { 4534 } 4535 4536 module_init(test_bpf_init); 4537 module_exit(test_bpf_exit); 4538 4539 MODULE_LICENSE("GPL"); 4540