1 /* $NetBSD: t_bpfjit.c,v 1.5 2014/06/24 10:53:30 alnsn Exp $ */ 2 3 /*- 4 * Copyright (c) 2011-2012, 2014 Alexander Nasonov. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 22 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __RCSID("$NetBSD: t_bpfjit.c,v 1.5 2014/06/24 10:53:30 alnsn Exp $"); 34 35 #include <atf-c.h> 36 #include <stdint.h> 37 #include <string.h> 38 39 #include <net/bpf.h> 40 #include <net/bpfjit.h> 41 42 static uint8_t deadbeef_at_5[16] = { 43 0, 0xf1, 2, 0xf3, 4, 0xde, 0xad, 0xbe, 0xef, 0xff 44 }; 45 46 static inline 47 unsigned int jitcall(bpfjit_func_t fn, 48 const uint8_t *pkt, unsigned int wirelen, unsigned int buflen) 49 { 50 bpf_args_t args; 51 52 args.pkt = pkt; 53 args.wirelen = wirelen; 54 args.buflen = buflen; 55 56 return fn(NULL, &args); 57 } 58 59 ATF_TC(bpfjit_empty); 60 ATF_TC_HEAD(bpfjit_empty, tc) 61 { 62 atf_tc_set_md_var(tc, "descr", 63 "Test that JIT compilation for an empty bpf program fails"); 64 } 65 66 ATF_TC_BODY(bpfjit_empty, tc) 67 { 68 struct bpf_insn dummy; 69 70 ATF_CHECK(bpfjit_generate_code(NULL, &dummy, 0) == NULL); 71 } 72 73 ATF_TC(bpfjit_alu_add_k); 74 ATF_TC_HEAD(bpfjit_alu_add_k, tc) 75 { 76 atf_tc_set_md_var(tc, "descr", 77 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_K"); 78 } 79 80 ATF_TC_BODY(bpfjit_alu_add_k, tc) 81 { 82 static struct bpf_insn insns[] = { 83 BPF_STMT(BPF_LD+BPF_IMM, 3), 84 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 2), 85 BPF_STMT(BPF_RET+BPF_A, 0) 86 }; 87 88 bpfjit_func_t code; 89 uint8_t pkt[1]; /* the program doesn't read any data */ 90 91 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 92 93 ATF_CHECK(bpf_validate(insns, insn_count)); 94 95 code = bpfjit_generate_code(NULL, insns, insn_count); 96 ATF_REQUIRE(code != NULL); 97 98 ATF_CHECK(jitcall(code, pkt, 1, 1) == 5); 99 100 bpfjit_free_code(code); 101 } 102 103 ATF_TC(bpfjit_alu_sub_k); 104 ATF_TC_HEAD(bpfjit_alu_sub_k, tc) 105 { 106 atf_tc_set_md_var(tc, "descr", 107 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_K"); 108 } 109 110 ATF_TC_BODY(bpfjit_alu_sub_k, tc) 111 { 112 static struct bpf_insn insns[] = { 113 BPF_STMT(BPF_LD+BPF_IMM, 1), 114 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, 2), 115 BPF_STMT(BPF_RET+BPF_A, 0) 116 }; 117 118 bpfjit_func_t code; 119 uint8_t pkt[1]; /* the program doesn't read any data */ 120 121 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 122 123 ATF_CHECK(bpf_validate(insns, insn_count)); 124 125 code = bpfjit_generate_code(NULL, insns, insn_count); 126 ATF_REQUIRE(code != NULL); 127 128 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 129 130 bpfjit_free_code(code); 131 } 132 133 ATF_TC(bpfjit_alu_mul_k); 134 ATF_TC_HEAD(bpfjit_alu_mul_k, tc) 135 { 136 atf_tc_set_md_var(tc, "descr", 137 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_K"); 138 } 139 140 ATF_TC_BODY(bpfjit_alu_mul_k, tc) 141 { 142 static struct bpf_insn insns[] = { 143 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 144 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, 3), 145 BPF_STMT(BPF_RET+BPF_A, 0) 146 }; 147 148 bpfjit_func_t code; 149 uint8_t pkt[1]; /* the program doesn't read any data */ 150 151 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 152 153 ATF_CHECK(bpf_validate(insns, insn_count)); 154 155 code = bpfjit_generate_code(NULL, insns, insn_count); 156 ATF_REQUIRE(code != NULL); 157 158 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd)); 159 160 bpfjit_free_code(code); 161 } 162 163 ATF_TC(bpfjit_alu_div0_k); 164 ATF_TC_HEAD(bpfjit_alu_div0_k, tc) 165 { 166 atf_tc_set_md_var(tc, "descr", 167 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0"); 168 } 169 170 ATF_TC_BODY(bpfjit_alu_div0_k, tc) 171 { 172 static struct bpf_insn insns[] = { 173 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 0), 174 BPF_STMT(BPF_RET+BPF_A, 0) 175 }; 176 177 bpfjit_func_t code; 178 uint8_t pkt[1]; /* the program doesn't read any data */ 179 180 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 181 182 //ATF_CHECK(bpf_validate(insns, insn_count)); 183 184 code = bpfjit_generate_code(NULL, insns, insn_count); 185 ATF_REQUIRE(code != NULL); 186 187 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 188 189 bpfjit_free_code(code); 190 } 191 192 ATF_TC(bpfjit_alu_div1_k); 193 ATF_TC_HEAD(bpfjit_alu_div1_k, tc) 194 { 195 atf_tc_set_md_var(tc, "descr", 196 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=1"); 197 } 198 199 ATF_TC_BODY(bpfjit_alu_div1_k, tc) 200 { 201 static struct bpf_insn insns[] = { 202 BPF_STMT(BPF_LD+BPF_IMM, 7), 203 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 1), 204 BPF_STMT(BPF_RET+BPF_A, 0) 205 }; 206 207 bpfjit_func_t code; 208 uint8_t pkt[1]; /* the program doesn't read any data */ 209 210 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 211 212 ATF_CHECK(bpf_validate(insns, insn_count)); 213 214 code = bpfjit_generate_code(NULL, insns, insn_count); 215 ATF_REQUIRE(code != NULL); 216 217 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 218 219 bpfjit_free_code(code); 220 } 221 222 ATF_TC(bpfjit_alu_div2_k); 223 ATF_TC_HEAD(bpfjit_alu_div2_k, tc) 224 { 225 atf_tc_set_md_var(tc, "descr", 226 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=2"); 227 } 228 229 ATF_TC_BODY(bpfjit_alu_div2_k, tc) 230 { 231 static struct bpf_insn insns[] = { 232 BPF_STMT(BPF_LD+BPF_IMM, 7), 233 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 2), 234 BPF_STMT(BPF_RET+BPF_A, 0) 235 }; 236 237 bpfjit_func_t code; 238 uint8_t pkt[1]; /* the program doesn't read any data */ 239 240 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 241 242 ATF_CHECK(bpf_validate(insns, insn_count)); 243 244 code = bpfjit_generate_code(NULL, insns, insn_count); 245 ATF_REQUIRE(code != NULL); 246 247 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 248 249 bpfjit_free_code(code); 250 } 251 252 ATF_TC(bpfjit_alu_div4_k); 253 ATF_TC_HEAD(bpfjit_alu_div4_k, tc) 254 { 255 atf_tc_set_md_var(tc, "descr", 256 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=4"); 257 } 258 259 ATF_TC_BODY(bpfjit_alu_div4_k, tc) 260 { 261 static struct bpf_insn insns[] = { 262 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 263 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), 264 BPF_STMT(BPF_RET+BPF_A, 0) 265 }; 266 267 bpfjit_func_t code; 268 uint8_t pkt[1]; /* the program doesn't read any data */ 269 270 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 271 272 ATF_CHECK(bpf_validate(insns, insn_count)); 273 274 code = bpfjit_generate_code(NULL, insns, insn_count); 275 ATF_REQUIRE(code != NULL); 276 277 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff)); 278 279 bpfjit_free_code(code); 280 } 281 282 ATF_TC(bpfjit_alu_div10_k); 283 ATF_TC_HEAD(bpfjit_alu_div10_k, tc) 284 { 285 atf_tc_set_md_var(tc, "descr", 286 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10"); 287 } 288 289 ATF_TC_BODY(bpfjit_alu_div10_k, tc) 290 { 291 static struct bpf_insn insns[] = { 292 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 293 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10), 294 BPF_STMT(BPF_RET+BPF_A, 0) 295 }; 296 297 bpfjit_func_t code; 298 uint8_t pkt[1]; /* the program doesn't read any data */ 299 300 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 301 302 ATF_CHECK(bpf_validate(insns, insn_count)); 303 304 code = bpfjit_generate_code(NULL, insns, insn_count); 305 ATF_REQUIRE(code != NULL); 306 307 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384)); 308 309 bpfjit_free_code(code); 310 } 311 312 ATF_TC(bpfjit_alu_div10000_k); 313 ATF_TC_HEAD(bpfjit_alu_div10000_k, tc) 314 { 315 atf_tc_set_md_var(tc, "descr", 316 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10000"); 317 } 318 319 ATF_TC_BODY(bpfjit_alu_div10000_k, tc) 320 { 321 static struct bpf_insn insns[] = { 322 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 323 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10000), 324 BPF_STMT(BPF_RET+BPF_A, 0) 325 }; 326 327 bpfjit_func_t code; 328 uint8_t pkt[1]; /* the program doesn't read any data */ 329 330 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 331 332 ATF_CHECK(bpf_validate(insns, insn_count)); 333 334 code = bpfjit_generate_code(NULL, insns, insn_count); 335 ATF_REQUIRE(code != NULL); 336 337 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484)); 338 339 bpfjit_free_code(code); 340 } 341 342 ATF_TC(bpfjit_alu_div7609801_k); 343 ATF_TC_HEAD(bpfjit_alu_div7609801_k, tc) 344 { 345 atf_tc_set_md_var(tc, "descr", 346 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=7609801"); 347 } 348 349 ATF_TC_BODY(bpfjit_alu_div7609801_k, tc) 350 { 351 static struct bpf_insn insns[] = { 352 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 353 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(7609801)), 354 BPF_STMT(BPF_RET+BPF_A, 0) 355 }; 356 357 bpfjit_func_t code; 358 uint8_t pkt[1]; /* the program doesn't read any data */ 359 360 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 361 362 ATF_CHECK(bpf_validate(insns, insn_count)); 363 364 code = bpfjit_generate_code(NULL, insns, insn_count); 365 ATF_REQUIRE(code != NULL); 366 367 ATF_CHECK(jitcall(code, pkt, 1, 1) == 564); 368 369 bpfjit_free_code(code); 370 } 371 372 ATF_TC(bpfjit_alu_div80000000_k); 373 ATF_TC_HEAD(bpfjit_alu_div80000000_k, tc) 374 { 375 atf_tc_set_md_var(tc, "descr", 376 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0x80000000"); 377 } 378 379 ATF_TC_BODY(bpfjit_alu_div80000000_k, tc) 380 { 381 static struct bpf_insn insns[] = { 382 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 383 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0x80000000)), 384 BPF_STMT(BPF_RET+BPF_A, 0) 385 }; 386 387 bpfjit_func_t code; 388 uint8_t pkt[1]; /* the program doesn't read any data */ 389 390 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 391 392 ATF_CHECK(bpf_validate(insns, insn_count)); 393 394 code = bpfjit_generate_code(NULL, insns, insn_count); 395 ATF_REQUIRE(code != NULL); 396 397 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 398 399 bpfjit_free_code(code); 400 } 401 402 ATF_TC(bpfjit_alu_and_k); 403 ATF_TC_HEAD(bpfjit_alu_and_k, tc) 404 { 405 atf_tc_set_md_var(tc, "descr", 406 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_K"); 407 } 408 409 ATF_TC_BODY(bpfjit_alu_and_k, tc) 410 { 411 static struct bpf_insn insns[] = { 412 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 413 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xbeef), 414 BPF_STMT(BPF_RET+BPF_A, 0) 415 }; 416 417 bpfjit_func_t code; 418 uint8_t pkt[1]; /* the program doesn't read any data */ 419 420 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 421 422 ATF_CHECK(bpf_validate(insns, insn_count)); 423 424 code = bpfjit_generate_code(NULL, insns, insn_count); 425 ATF_REQUIRE(code != NULL); 426 427 ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef)); 428 429 bpfjit_free_code(code); 430 } 431 432 ATF_TC(bpfjit_alu_or_k); 433 ATF_TC_HEAD(bpfjit_alu_or_k, tc) 434 { 435 atf_tc_set_md_var(tc, "descr", 436 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_K"); 437 } 438 439 ATF_TC_BODY(bpfjit_alu_or_k, tc) 440 { 441 static struct bpf_insn insns[] = { 442 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 443 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, 0x0000beef), 444 BPF_STMT(BPF_RET+BPF_A, 0) 445 }; 446 447 bpfjit_func_t code; 448 uint8_t pkt[1]; /* the program doesn't read any data */ 449 450 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 451 452 ATF_CHECK(bpf_validate(insns, insn_count)); 453 454 code = bpfjit_generate_code(NULL, insns, insn_count); 455 ATF_REQUIRE(code != NULL); 456 457 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 458 459 bpfjit_free_code(code); 460 } 461 462 ATF_TC(bpfjit_alu_lsh_k); 463 ATF_TC_HEAD(bpfjit_alu_lsh_k, tc) 464 { 465 atf_tc_set_md_var(tc, "descr", 466 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K"); 467 } 468 469 ATF_TC_BODY(bpfjit_alu_lsh_k, tc) 470 { 471 static struct bpf_insn insns[] = { 472 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 473 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 16), 474 BPF_STMT(BPF_RET+BPF_A, 0) 475 }; 476 477 bpfjit_func_t code; 478 uint8_t pkt[1]; /* the program doesn't read any data */ 479 480 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 481 482 ATF_CHECK(bpf_validate(insns, insn_count)); 483 484 code = bpfjit_generate_code(NULL, insns, insn_count); 485 ATF_REQUIRE(code != NULL); 486 487 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000); 488 489 bpfjit_free_code(code); 490 } 491 492 ATF_TC(bpfjit_alu_lsh0_k); 493 ATF_TC_HEAD(bpfjit_alu_lsh0_k, tc) 494 { 495 atf_tc_set_md_var(tc, "descr", 496 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K with k=0"); 497 } 498 499 ATF_TC_BODY(bpfjit_alu_lsh0_k, tc) 500 { 501 static struct bpf_insn insns[] = { 502 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 503 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 0), 504 BPF_STMT(BPF_RET+BPF_A, 0) 505 }; 506 507 bpfjit_func_t code; 508 uint8_t pkt[1]; /* the program doesn't read any data */ 509 510 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 511 512 ATF_CHECK(bpf_validate(insns, insn_count)); 513 514 code = bpfjit_generate_code(NULL, insns, insn_count); 515 ATF_REQUIRE(code != NULL); 516 517 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 518 519 bpfjit_free_code(code); 520 } 521 522 ATF_TC(bpfjit_alu_rsh_k); 523 ATF_TC_HEAD(bpfjit_alu_rsh_k, tc) 524 { 525 atf_tc_set_md_var(tc, "descr", 526 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K"); 527 } 528 529 ATF_TC_BODY(bpfjit_alu_rsh_k, tc) 530 { 531 static struct bpf_insn insns[] = { 532 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 533 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 16), 534 BPF_STMT(BPF_RET+BPF_A, 0) 535 }; 536 537 bpfjit_func_t code; 538 uint8_t pkt[1]; /* the program doesn't read any data */ 539 540 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 541 542 ATF_CHECK(bpf_validate(insns, insn_count)); 543 544 code = bpfjit_generate_code(NULL, insns, insn_count); 545 ATF_REQUIRE(code != NULL); 546 547 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead); 548 549 bpfjit_free_code(code); 550 } 551 552 ATF_TC(bpfjit_alu_rsh0_k); 553 ATF_TC_HEAD(bpfjit_alu_rsh0_k, tc) 554 { 555 atf_tc_set_md_var(tc, "descr", 556 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K with k=0"); 557 } 558 559 ATF_TC_BODY(bpfjit_alu_rsh0_k, tc) 560 { 561 static struct bpf_insn insns[] = { 562 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 563 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 0), 564 BPF_STMT(BPF_RET+BPF_A, 0) 565 }; 566 567 bpfjit_func_t code; 568 uint8_t pkt[1]; /* the program doesn't read any data */ 569 570 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 571 572 ATF_CHECK(bpf_validate(insns, insn_count)); 573 574 code = bpfjit_generate_code(NULL, insns, insn_count); 575 ATF_REQUIRE(code != NULL); 576 577 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 578 579 bpfjit_free_code(code); 580 } 581 582 ATF_TC(bpfjit_alu_modulo_k); 583 ATF_TC_HEAD(bpfjit_alu_modulo_k, tc) 584 { 585 atf_tc_set_md_var(tc, "descr", 586 "Test JIT compilation of modulo logic of BPF_ALU+BPF_K operations"); 587 } 588 589 ATF_TC_BODY(bpfjit_alu_modulo_k, tc) 590 { 591 static struct bpf_insn insns[] = { 592 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 593 594 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 595 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x0fffff77)), 596 597 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 598 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 1), 599 600 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 601 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xdddddddd)), 602 603 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 604 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, UINT32_C(0xffffffff)), 605 606 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 607 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, UINT32_C(0x0000030c)), 608 609 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 610 BPF_STMT(BPF_ALU+BPF_NEG, 0), 611 612 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 613 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, UINT32_C(0xffffff0f)), 614 615 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 616 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 617 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 3), 618 619 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 620 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x7fffff77)), 621 622 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 623 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 624 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0xdead)), 625 626 BPF_STMT(BPF_RET+BPF_A, 0) 627 }; 628 629 bpfjit_func_t code; 630 uint8_t pkt[1]; /* the program doesn't read any data */ 631 632 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 633 634 ATF_CHECK(bpf_validate(insns, insn_count)); 635 636 code = bpfjit_generate_code(NULL, insns, insn_count); 637 ATF_REQUIRE(code != NULL); 638 639 ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 640 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994)); 641 642 643 bpfjit_free_code(code); 644 } 645 646 ATF_TC(bpfjit_alu_add_x); 647 ATF_TC_HEAD(bpfjit_alu_add_x, tc) 648 { 649 atf_tc_set_md_var(tc, "descr", 650 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_X"); 651 } 652 653 ATF_TC_BODY(bpfjit_alu_add_x, tc) 654 { 655 static struct bpf_insn insns[] = { 656 BPF_STMT(BPF_LD+BPF_IMM, 3), 657 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 658 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 659 BPF_STMT(BPF_RET+BPF_A, 0) 660 }; 661 662 bpfjit_func_t code; 663 uint8_t pkt[1]; /* the program doesn't read any data */ 664 665 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 666 667 ATF_CHECK(bpf_validate(insns, insn_count)); 668 669 code = bpfjit_generate_code(NULL, insns, insn_count); 670 ATF_REQUIRE(code != NULL); 671 672 ATF_CHECK(jitcall(code, pkt, 1, 1) == 5); 673 674 bpfjit_free_code(code); 675 } 676 677 ATF_TC(bpfjit_alu_sub_x); 678 ATF_TC_HEAD(bpfjit_alu_sub_x, tc) 679 { 680 atf_tc_set_md_var(tc, "descr", 681 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_X"); 682 } 683 684 ATF_TC_BODY(bpfjit_alu_sub_x, tc) 685 { 686 static struct bpf_insn insns[] = { 687 BPF_STMT(BPF_LD+BPF_IMM, 1), 688 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 689 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 690 BPF_STMT(BPF_RET+BPF_A, 0) 691 }; 692 693 bpfjit_func_t code; 694 uint8_t pkt[1]; /* the program doesn't read any data */ 695 696 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 697 698 ATF_CHECK(bpf_validate(insns, insn_count)); 699 700 code = bpfjit_generate_code(NULL, insns, insn_count); 701 ATF_REQUIRE(code != NULL); 702 703 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 704 705 bpfjit_free_code(code); 706 } 707 708 ATF_TC(bpfjit_alu_mul_x); 709 ATF_TC_HEAD(bpfjit_alu_mul_x, tc) 710 { 711 atf_tc_set_md_var(tc, "descr", 712 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_X"); 713 } 714 715 ATF_TC_BODY(bpfjit_alu_mul_x, tc) 716 { 717 static struct bpf_insn insns[] = { 718 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 719 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 720 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 721 BPF_STMT(BPF_RET+BPF_A, 0) 722 }; 723 724 bpfjit_func_t code; 725 uint8_t pkt[1]; /* the program doesn't read any data */ 726 727 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 728 729 ATF_CHECK(bpf_validate(insns, insn_count)); 730 731 code = bpfjit_generate_code(NULL, insns, insn_count); 732 ATF_REQUIRE(code != NULL); 733 734 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd)); 735 736 bpfjit_free_code(code); 737 } 738 739 ATF_TC(bpfjit_alu_div0_x); 740 ATF_TC_HEAD(bpfjit_alu_div0_x, tc) 741 { 742 atf_tc_set_md_var(tc, "descr", 743 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0"); 744 } 745 746 ATF_TC_BODY(bpfjit_alu_div0_x, tc) 747 { 748 static struct bpf_insn insns[] = { 749 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 750 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 751 BPF_STMT(BPF_RET+BPF_A, 0) 752 }; 753 754 bpfjit_func_t code; 755 uint8_t pkt[1]; /* the program doesn't read any data */ 756 757 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 758 759 ATF_CHECK(bpf_validate(insns, insn_count)); 760 761 code = bpfjit_generate_code(NULL, insns, insn_count); 762 ATF_REQUIRE(code != NULL); 763 764 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 765 766 bpfjit_free_code(code); 767 } 768 769 ATF_TC(bpfjit_alu_div1_x); 770 ATF_TC_HEAD(bpfjit_alu_div1_x, tc) 771 { 772 atf_tc_set_md_var(tc, "descr", 773 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=1"); 774 } 775 776 ATF_TC_BODY(bpfjit_alu_div1_x, tc) 777 { 778 static struct bpf_insn insns[] = { 779 BPF_STMT(BPF_LD+BPF_IMM, 7), 780 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 781 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 782 BPF_STMT(BPF_RET+BPF_A, 0) 783 }; 784 785 bpfjit_func_t code; 786 uint8_t pkt[1]; /* the program doesn't read any data */ 787 788 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 789 790 ATF_CHECK(bpf_validate(insns, insn_count)); 791 792 code = bpfjit_generate_code(NULL, insns, insn_count); 793 ATF_REQUIRE(code != NULL); 794 795 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 796 797 bpfjit_free_code(code); 798 } 799 800 ATF_TC(bpfjit_alu_div2_x); 801 ATF_TC_HEAD(bpfjit_alu_div2_x, tc) 802 { 803 atf_tc_set_md_var(tc, "descr", 804 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=2"); 805 } 806 807 ATF_TC_BODY(bpfjit_alu_div2_x, tc) 808 { 809 static struct bpf_insn insns[] = { 810 BPF_STMT(BPF_LD+BPF_IMM, 7), 811 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 812 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 813 BPF_STMT(BPF_RET+BPF_A, 0) 814 }; 815 816 bpfjit_func_t code; 817 uint8_t pkt[1]; /* the program doesn't read any data */ 818 819 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 820 821 ATF_CHECK(bpf_validate(insns, insn_count)); 822 823 code = bpfjit_generate_code(NULL, insns, insn_count); 824 ATF_REQUIRE(code != NULL); 825 826 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 827 828 bpfjit_free_code(code); 829 } 830 831 ATF_TC(bpfjit_alu_div4_x); 832 ATF_TC_HEAD(bpfjit_alu_div4_x, tc) 833 { 834 atf_tc_set_md_var(tc, "descr", 835 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=4"); 836 } 837 838 ATF_TC_BODY(bpfjit_alu_div4_x, tc) 839 { 840 static struct bpf_insn insns[] = { 841 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 842 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 843 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 844 BPF_STMT(BPF_RET+BPF_A, 0) 845 }; 846 847 bpfjit_func_t code; 848 uint8_t pkt[1]; /* the program doesn't read any data */ 849 850 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 851 852 ATF_CHECK(bpf_validate(insns, insn_count)); 853 854 code = bpfjit_generate_code(NULL, insns, insn_count); 855 ATF_REQUIRE(code != NULL); 856 857 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff)); 858 859 bpfjit_free_code(code); 860 } 861 862 ATF_TC(bpfjit_alu_div10_x); 863 ATF_TC_HEAD(bpfjit_alu_div10_x, tc) 864 { 865 atf_tc_set_md_var(tc, "descr", 866 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10"); 867 } 868 869 ATF_TC_BODY(bpfjit_alu_div10_x, tc) 870 { 871 static struct bpf_insn insns[] = { 872 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 873 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10), 874 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 875 BPF_STMT(BPF_RET+BPF_A, 0) 876 }; 877 878 bpfjit_func_t code; 879 uint8_t pkt[1]; /* the program doesn't read any data */ 880 881 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 882 883 ATF_CHECK(bpf_validate(insns, insn_count)); 884 885 code = bpfjit_generate_code(NULL, insns, insn_count); 886 ATF_REQUIRE(code != NULL); 887 888 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384)); 889 890 bpfjit_free_code(code); 891 } 892 893 ATF_TC(bpfjit_alu_div10000_x); 894 ATF_TC_HEAD(bpfjit_alu_div10000_x, tc) 895 { 896 atf_tc_set_md_var(tc, "descr", 897 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10000"); 898 } 899 900 ATF_TC_BODY(bpfjit_alu_div10000_x, tc) 901 { 902 static struct bpf_insn insns[] = { 903 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 904 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000), 905 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 906 BPF_STMT(BPF_RET+BPF_A, 0) 907 }; 908 909 bpfjit_func_t code; 910 uint8_t pkt[1]; /* the program doesn't read any data */ 911 912 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 913 914 ATF_CHECK(bpf_validate(insns, insn_count)); 915 916 code = bpfjit_generate_code(NULL, insns, insn_count); 917 ATF_REQUIRE(code != NULL); 918 919 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484)); 920 921 bpfjit_free_code(code); 922 } 923 924 ATF_TC(bpfjit_alu_div7609801_x); 925 ATF_TC_HEAD(bpfjit_alu_div7609801_x, tc) 926 { 927 atf_tc_set_md_var(tc, "descr", 928 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=7609801"); 929 } 930 931 ATF_TC_BODY(bpfjit_alu_div7609801_x, tc) 932 { 933 static struct bpf_insn insns[] = { 934 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 935 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)), 936 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 937 BPF_STMT(BPF_RET+BPF_A, 0) 938 }; 939 940 bpfjit_func_t code; 941 uint8_t pkt[1]; /* the program doesn't read any data */ 942 943 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 944 945 ATF_CHECK(bpf_validate(insns, insn_count)); 946 947 code = bpfjit_generate_code(NULL, insns, insn_count); 948 ATF_REQUIRE(code != NULL); 949 950 ATF_CHECK(jitcall(code, pkt, 1, 1) == 564); 951 952 bpfjit_free_code(code); 953 } 954 955 ATF_TC(bpfjit_alu_div80000000_x); 956 ATF_TC_HEAD(bpfjit_alu_div80000000_x, tc) 957 { 958 atf_tc_set_md_var(tc, "descr", 959 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0x80000000"); 960 } 961 962 ATF_TC_BODY(bpfjit_alu_div80000000_x, tc) 963 { 964 static struct bpf_insn insns[] = { 965 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX - 33), 966 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)), 967 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 968 BPF_STMT(BPF_RET+BPF_A, 0) 969 }; 970 971 bpfjit_func_t code; 972 uint8_t pkt[1]; /* the program doesn't read any data */ 973 974 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 975 976 ATF_CHECK(bpf_validate(insns, insn_count)); 977 978 code = bpfjit_generate_code(NULL, insns, insn_count); 979 ATF_REQUIRE(code != NULL); 980 981 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 982 983 bpfjit_free_code(code); 984 } 985 986 ATF_TC(bpfjit_alu_and_x); 987 ATF_TC_HEAD(bpfjit_alu_and_x, tc) 988 { 989 atf_tc_set_md_var(tc, "descr", 990 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_X"); 991 } 992 993 ATF_TC_BODY(bpfjit_alu_and_x, tc) 994 { 995 static struct bpf_insn insns[] = { 996 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 997 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0xbeef), 998 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 999 BPF_STMT(BPF_RET+BPF_A, 0) 1000 }; 1001 1002 bpfjit_func_t code; 1003 uint8_t pkt[1]; /* the program doesn't read any data */ 1004 1005 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1006 1007 ATF_CHECK(bpf_validate(insns, insn_count)); 1008 1009 code = bpfjit_generate_code(NULL, insns, insn_count); 1010 ATF_REQUIRE(code != NULL); 1011 1012 ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef)); 1013 1014 bpfjit_free_code(code); 1015 } 1016 1017 ATF_TC(bpfjit_alu_or_x); 1018 ATF_TC_HEAD(bpfjit_alu_or_x, tc) 1019 { 1020 atf_tc_set_md_var(tc, "descr", 1021 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_X"); 1022 } 1023 1024 ATF_TC_BODY(bpfjit_alu_or_x, tc) 1025 { 1026 static struct bpf_insn insns[] = { 1027 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 1028 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0x0000beef), 1029 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1030 BPF_STMT(BPF_RET+BPF_A, 0) 1031 }; 1032 1033 bpfjit_func_t code; 1034 uint8_t pkt[1]; /* the program doesn't read any data */ 1035 1036 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1037 1038 ATF_CHECK(bpf_validate(insns, insn_count)); 1039 1040 code = bpfjit_generate_code(NULL, insns, insn_count); 1041 ATF_REQUIRE(code != NULL); 1042 1043 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1044 1045 bpfjit_free_code(code); 1046 } 1047 1048 ATF_TC(bpfjit_alu_lsh_x); 1049 ATF_TC_HEAD(bpfjit_alu_lsh_x, tc) 1050 { 1051 atf_tc_set_md_var(tc, "descr", 1052 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X"); 1053 } 1054 1055 ATF_TC_BODY(bpfjit_alu_lsh_x, tc) 1056 { 1057 static struct bpf_insn insns[] = { 1058 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1059 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1060 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1061 BPF_STMT(BPF_RET+BPF_A, 0) 1062 }; 1063 1064 bpfjit_func_t code; 1065 uint8_t pkt[1]; /* the program doesn't read any data */ 1066 1067 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1068 1069 ATF_CHECK(bpf_validate(insns, insn_count)); 1070 1071 code = bpfjit_generate_code(NULL, insns, insn_count); 1072 ATF_REQUIRE(code != NULL); 1073 1074 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000); 1075 1076 bpfjit_free_code(code); 1077 } 1078 1079 ATF_TC(bpfjit_alu_lsh0_x); 1080 ATF_TC_HEAD(bpfjit_alu_lsh0_x, tc) 1081 { 1082 atf_tc_set_md_var(tc, "descr", 1083 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X with k=0"); 1084 } 1085 1086 ATF_TC_BODY(bpfjit_alu_lsh0_x, tc) 1087 { 1088 static struct bpf_insn insns[] = { 1089 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1090 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1091 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1092 BPF_STMT(BPF_RET+BPF_A, 0) 1093 }; 1094 1095 bpfjit_func_t code; 1096 uint8_t pkt[1]; /* the program doesn't read any data */ 1097 1098 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1099 1100 ATF_CHECK(bpf_validate(insns, insn_count)); 1101 1102 code = bpfjit_generate_code(NULL, insns, insn_count); 1103 ATF_REQUIRE(code != NULL); 1104 1105 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1106 1107 bpfjit_free_code(code); 1108 } 1109 1110 ATF_TC(bpfjit_alu_rsh_x); 1111 ATF_TC_HEAD(bpfjit_alu_rsh_x, tc) 1112 { 1113 atf_tc_set_md_var(tc, "descr", 1114 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X"); 1115 } 1116 1117 ATF_TC_BODY(bpfjit_alu_rsh_x, tc) 1118 { 1119 static struct bpf_insn insns[] = { 1120 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1121 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1122 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1123 BPF_STMT(BPF_RET+BPF_A, 0) 1124 }; 1125 1126 bpfjit_func_t code; 1127 uint8_t pkt[1]; /* the program doesn't read any data */ 1128 1129 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1130 1131 ATF_CHECK(bpf_validate(insns, insn_count)); 1132 1133 code = bpfjit_generate_code(NULL, insns, insn_count); 1134 ATF_REQUIRE(code != NULL); 1135 1136 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead); 1137 1138 bpfjit_free_code(code); 1139 } 1140 1141 ATF_TC(bpfjit_alu_rsh0_x); 1142 ATF_TC_HEAD(bpfjit_alu_rsh0_x, tc) 1143 { 1144 atf_tc_set_md_var(tc, "descr", 1145 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X with k=0"); 1146 } 1147 1148 ATF_TC_BODY(bpfjit_alu_rsh0_x, tc) 1149 { 1150 static struct bpf_insn insns[] = { 1151 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1152 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1153 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1154 BPF_STMT(BPF_RET+BPF_A, 0) 1155 }; 1156 1157 bpfjit_func_t code; 1158 uint8_t pkt[1]; /* the program doesn't read any data */ 1159 1160 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1161 1162 ATF_CHECK(bpf_validate(insns, insn_count)); 1163 1164 code = bpfjit_generate_code(NULL, insns, insn_count); 1165 ATF_REQUIRE(code != NULL); 1166 1167 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1168 1169 bpfjit_free_code(code); 1170 } 1171 1172 ATF_TC(bpfjit_alu_modulo_x); 1173 ATF_TC_HEAD(bpfjit_alu_modulo_x, tc) 1174 { 1175 atf_tc_set_md_var(tc, "descr", 1176 "Test JIT compilation of modulo logic of BPF_ALU+BPF_X operations"); 1177 } 1178 1179 ATF_TC_BODY(bpfjit_alu_modulo_x, tc) 1180 { 1181 static struct bpf_insn insns[] = { 1182 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1183 1184 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 1185 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0fffff77)), 1186 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1187 1188 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 1189 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 1), 1190 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1191 1192 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 1193 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdddddddd)), 1194 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 1195 1196 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 1197 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffffff)), 1198 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 1199 1200 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 1201 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0000030c)), 1202 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1203 1204 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 1205 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1206 1207 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 1208 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffff0f)), 1209 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 1210 1211 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 1212 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 1213 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 3), 1214 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1215 1216 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 1217 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x7fffff77)), 1218 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1219 1220 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 1221 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 1222 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdead)), 1223 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1224 1225 BPF_STMT(BPF_RET+BPF_A, 0) 1226 }; 1227 1228 bpfjit_func_t code; 1229 uint8_t pkt[1]; /* the program doesn't read any data */ 1230 1231 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1232 1233 ATF_CHECK(bpf_validate(insns, insn_count)); 1234 1235 code = bpfjit_generate_code(NULL, insns, insn_count); 1236 ATF_REQUIRE(code != NULL); 1237 1238 ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 1239 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994)); 1240 1241 1242 bpfjit_free_code(code); 1243 } 1244 1245 ATF_TC(bpfjit_alu_neg); 1246 ATF_TC_HEAD(bpfjit_alu_neg, tc) 1247 { 1248 atf_tc_set_md_var(tc, "descr", 1249 "Test JIT compilation of BPF_ALU+BPF_NEG"); 1250 } 1251 1252 ATF_TC_BODY(bpfjit_alu_neg, tc) 1253 { 1254 static struct bpf_insn insns[] = { 1255 BPF_STMT(BPF_LD+BPF_IMM, 777), 1256 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1257 BPF_STMT(BPF_RET+BPF_A, 0) 1258 }; 1259 1260 bpfjit_func_t code; 1261 uint8_t pkt[1]; /* the program doesn't read any data */ 1262 1263 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1264 1265 ATF_CHECK(bpf_validate(insns, insn_count)); 1266 1267 code = bpfjit_generate_code(NULL, insns, insn_count); 1268 ATF_REQUIRE(code != NULL); 1269 1270 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0u-777u); 1271 1272 bpfjit_free_code(code); 1273 } 1274 1275 ATF_TC(bpfjit_jmp_ja); 1276 ATF_TC_HEAD(bpfjit_jmp_ja, tc) 1277 { 1278 atf_tc_set_md_var(tc, "descr", 1279 "Test JIT compilation of BPF_JMP+BPF_JA"); 1280 } 1281 1282 ATF_TC_BODY(bpfjit_jmp_ja, tc) 1283 { 1284 static struct bpf_insn insns[] = { 1285 BPF_STMT(BPF_JMP+BPF_JA, 1), 1286 BPF_STMT(BPF_RET+BPF_K, 0), 1287 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1288 BPF_STMT(BPF_RET+BPF_K, 1), 1289 BPF_STMT(BPF_RET+BPF_K, 2), 1290 BPF_STMT(BPF_RET+BPF_K, 3), 1291 }; 1292 1293 bpfjit_func_t code; 1294 uint8_t pkt[1]; /* the program doesn't read any data */ 1295 1296 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1297 1298 ATF_CHECK(bpf_validate(insns, insn_count)); 1299 1300 code = bpfjit_generate_code(NULL, insns, insn_count); 1301 ATF_REQUIRE(code != NULL); 1302 1303 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 1304 1305 bpfjit_free_code(code); 1306 } 1307 1308 ATF_TC(bpfjit_jmp_jgt_k); 1309 ATF_TC_HEAD(bpfjit_jmp_jgt_k, tc) 1310 { 1311 atf_tc_set_md_var(tc, "descr", 1312 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_K"); 1313 } 1314 1315 ATF_TC_BODY(bpfjit_jmp_jgt_k, tc) 1316 { 1317 static struct bpf_insn insns[] = { 1318 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1319 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 7, 0, 1), 1320 BPF_STMT(BPF_RET+BPF_K, 0), 1321 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 2, 2, 0), 1322 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 9, 0, 0), 1323 BPF_STMT(BPF_RET+BPF_K, 1), 1324 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 4, 1, 1), 1325 BPF_STMT(BPF_RET+BPF_K, 2), 1326 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 2, 3), 1327 BPF_STMT(BPF_RET+BPF_K, 3), 1328 BPF_STMT(BPF_RET+BPF_K, 4), 1329 BPF_STMT(BPF_RET+BPF_K, 5), 1330 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 5, 3, 1), 1331 BPF_STMT(BPF_RET+BPF_K, 6), 1332 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 0, 0, 0), 1333 BPF_STMT(BPF_RET+BPF_K, 7), 1334 BPF_STMT(BPF_RET+BPF_K, 8) 1335 }; 1336 1337 bpfjit_func_t code; 1338 uint8_t pkt[8]; /* the program doesn't read any data */ 1339 1340 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1341 1342 ATF_CHECK(bpf_validate(insns, insn_count)); 1343 1344 code = bpfjit_generate_code(NULL, insns, insn_count); 1345 ATF_REQUIRE(code != NULL); 1346 1347 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1348 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1349 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 1350 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1351 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1352 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1353 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1354 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1355 1356 bpfjit_free_code(code); 1357 } 1358 1359 ATF_TC(bpfjit_jmp_jge_k); 1360 ATF_TC_HEAD(bpfjit_jmp_jge_k, tc) 1361 { 1362 atf_tc_set_md_var(tc, "descr", 1363 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_K"); 1364 } 1365 1366 ATF_TC_BODY(bpfjit_jmp_jge_k, tc) 1367 { 1368 static struct bpf_insn insns[] = { 1369 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1370 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 8, 0, 1), 1371 BPF_STMT(BPF_RET+BPF_K, 0), 1372 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 3, 2, 0), 1373 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 9, 0, 0), 1374 BPF_STMT(BPF_RET+BPF_K, 1), 1375 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 5, 1, 1), 1376 BPF_STMT(BPF_RET+BPF_K, 2), 1377 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 2, 3), 1378 BPF_STMT(BPF_RET+BPF_K, 3), 1379 BPF_STMT(BPF_RET+BPF_K, 4), 1380 BPF_STMT(BPF_RET+BPF_K, 5), 1381 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 6, 3, 1), 1382 BPF_STMT(BPF_RET+BPF_K, 6), 1383 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 1, 0, 0), 1384 BPF_STMT(BPF_RET+BPF_K, 7), 1385 BPF_STMT(BPF_RET+BPF_K, 8) 1386 }; 1387 1388 bpfjit_func_t code; 1389 uint8_t pkt[8]; /* the program doesn't read any data */ 1390 1391 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1392 1393 ATF_CHECK(bpf_validate(insns, insn_count)); 1394 1395 code = bpfjit_generate_code(NULL, insns, insn_count); 1396 ATF_REQUIRE(code != NULL); 1397 1398 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1399 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1400 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 1401 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1402 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1403 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1404 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1405 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1406 1407 bpfjit_free_code(code); 1408 } 1409 1410 ATF_TC(bpfjit_jmp_jeq_k); 1411 ATF_TC_HEAD(bpfjit_jmp_jeq_k, tc) 1412 { 1413 atf_tc_set_md_var(tc, "descr", 1414 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_K"); 1415 } 1416 1417 ATF_TC_BODY(bpfjit_jmp_jeq_k, tc) 1418 { 1419 static struct bpf_insn insns[] = { 1420 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1421 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 1), 1422 BPF_STMT(BPF_RET+BPF_K, 0), 1423 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 1, 0), 1424 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 9, 1, 1), 1425 BPF_STMT(BPF_RET+BPF_K, 1), 1426 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 5, 1, 1), 1427 BPF_STMT(BPF_RET+BPF_K, 2), 1428 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 7, 2, 3), 1429 BPF_STMT(BPF_RET+BPF_K, 3), 1430 BPF_STMT(BPF_RET+BPF_K, 4), 1431 BPF_STMT(BPF_RET+BPF_K, 5), 1432 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 3, 1), 1433 BPF_STMT(BPF_RET+BPF_K, 6), 1434 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 1, 0, 0), 1435 BPF_STMT(BPF_RET+BPF_K, 7), 1436 BPF_STMT(BPF_RET+BPF_K, 8) 1437 }; 1438 1439 bpfjit_func_t code; 1440 uint8_t pkt[8]; /* the program doesn't read any data */ 1441 1442 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1443 1444 ATF_CHECK(bpf_validate(insns, insn_count)); 1445 1446 code = bpfjit_generate_code(NULL, insns, insn_count); 1447 ATF_REQUIRE(code != NULL); 1448 1449 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 1450 ATF_CHECK(jitcall(code, pkt, 2, 2) == 7); 1451 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 1452 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1453 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1454 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1455 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1456 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1457 1458 bpfjit_free_code(code); 1459 } 1460 1461 ATF_TC(bpfjit_jmp_jset_k); 1462 ATF_TC_HEAD(bpfjit_jmp_jset_k, tc) 1463 { 1464 atf_tc_set_md_var(tc, "descr", 1465 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_K"); 1466 } 1467 1468 ATF_TC_BODY(bpfjit_jmp_jset_k, tc) 1469 { 1470 static struct bpf_insn insns[] = { 1471 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1472 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 8, 0, 1), 1473 BPF_STMT(BPF_RET+BPF_K, 0), 1474 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 4, 2, 0), 1475 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 3, 0, 0), 1476 BPF_STMT(BPF_RET+BPF_K, 1), 1477 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 1, 1), 1478 BPF_STMT(BPF_RET+BPF_K, 2), 1479 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 1, 2, 3), 1480 BPF_STMT(BPF_RET+BPF_K, 3), 1481 BPF_STMT(BPF_RET+BPF_K, 4), 1482 BPF_STMT(BPF_RET+BPF_K, 5), 1483 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 3, 1), 1484 BPF_STMT(BPF_RET+BPF_K, 6), 1485 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 7, 0, 0), 1486 BPF_STMT(BPF_RET+BPF_K, 7), 1487 BPF_STMT(BPF_RET+BPF_K, 8) 1488 }; 1489 1490 bpfjit_func_t code; 1491 uint8_t pkt[8]; /* the program doesn't read any data */ 1492 1493 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1494 1495 ATF_CHECK(bpf_validate(insns, insn_count)); 1496 1497 code = bpfjit_generate_code(NULL, insns, insn_count); 1498 ATF_REQUIRE(code != NULL); 1499 1500 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1501 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1502 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 1503 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1504 ATF_CHECK(jitcall(code, pkt, 5, 5) == 5); 1505 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1506 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1507 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1508 1509 bpfjit_free_code(code); 1510 } 1511 1512 ATF_TC(bpfjit_jmp_modulo_k); 1513 ATF_TC_HEAD(bpfjit_jmp_modulo_k, tc) 1514 { 1515 atf_tc_set_md_var(tc, "descr", 1516 "Test JIT compilation of modulo logic of BPF_JMP+BPF_K operations"); 1517 } 1518 1519 ATF_TC_BODY(bpfjit_jmp_modulo_k, tc) 1520 { 1521 static struct bpf_insn insns[] = { 1522 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1523 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 1524 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 1, 0), 1525 BPF_STMT(BPF_RET+BPF_K, 0), 1526 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 0, 1), 1527 BPF_STMT(BPF_RET+BPF_K, 1), 1528 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 0, 1), 1529 BPF_STMT(BPF_RET+BPF_K, 2), 1530 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 0, 3), 1531 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 2, 0), 1532 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 1, 0), 1533 BPF_STMT(BPF_JMP+BPF_JA, 1), 1534 BPF_STMT(BPF_RET+BPF_K, 3), 1535 1536 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 1537 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 1538 1539 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 1, 0), 1540 BPF_STMT(BPF_RET+BPF_K, 4), 1541 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 0, 1), 1542 BPF_STMT(BPF_RET+BPF_K, 5), 1543 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 0, 1), 1544 BPF_STMT(BPF_RET+BPF_K, 6), 1545 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 0, 3), 1546 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 2, 0), 1547 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 1, 0), 1548 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1549 BPF_STMT(BPF_RET+BPF_K, 7) 1550 }; 1551 1552 bpfjit_func_t code; 1553 uint8_t pkt[1]; /* the program doesn't read any data */ 1554 1555 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1556 1557 ATF_CHECK(bpf_validate(insns, insn_count)); 1558 1559 code = bpfjit_generate_code(NULL, insns, insn_count); 1560 ATF_REQUIRE(code != NULL); 1561 1562 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 1563 1564 bpfjit_free_code(code); 1565 } 1566 1567 ATF_TC(bpfjit_jmp_jgt_x); 1568 ATF_TC_HEAD(bpfjit_jmp_jgt_x, tc) 1569 { 1570 atf_tc_set_md_var(tc, "descr", 1571 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_X"); 1572 } 1573 1574 ATF_TC_BODY(bpfjit_jmp_jgt_x, tc) 1575 { 1576 static struct bpf_insn insns[] = { 1577 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1578 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1579 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1580 BPF_STMT(BPF_RET+BPF_K, 0), 1581 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1582 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1583 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1584 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 1585 BPF_STMT(BPF_RET+BPF_K, 1), 1586 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1587 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 1, 1), 1588 BPF_STMT(BPF_RET+BPF_K, 2), 1589 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1590 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 2, 3), 1591 BPF_STMT(BPF_RET+BPF_K, 3), 1592 BPF_STMT(BPF_RET+BPF_K, 4), 1593 BPF_STMT(BPF_RET+BPF_K, 5), 1594 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1595 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 4, 1), 1596 BPF_STMT(BPF_RET+BPF_K, 6), 1597 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1598 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 1599 BPF_STMT(BPF_RET+BPF_K, 7), 1600 BPF_STMT(BPF_RET+BPF_K, 8) 1601 }; 1602 1603 bpfjit_func_t code; 1604 uint8_t pkt[8]; /* the program doesn't read any data */ 1605 1606 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1607 1608 ATF_CHECK(bpf_validate(insns, insn_count)); 1609 1610 code = bpfjit_generate_code(NULL, insns, insn_count); 1611 ATF_REQUIRE(code != NULL); 1612 1613 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1614 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1615 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 1616 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1617 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1618 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1619 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1620 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1621 1622 bpfjit_free_code(code); 1623 } 1624 1625 ATF_TC(bpfjit_jmp_jge_x); 1626 ATF_TC_HEAD(bpfjit_jmp_jge_x, tc) 1627 { 1628 atf_tc_set_md_var(tc, "descr", 1629 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_X"); 1630 } 1631 1632 ATF_TC_BODY(bpfjit_jmp_jge_x, tc) 1633 { 1634 static struct bpf_insn insns[] = { 1635 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1636 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1637 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1638 BPF_STMT(BPF_RET+BPF_K, 0), 1639 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 1640 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 3, 0), 1641 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1642 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 1643 BPF_STMT(BPF_RET+BPF_K, 1), 1644 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1645 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 1), 1646 BPF_STMT(BPF_RET+BPF_K, 2), 1647 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1648 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 2, 3), 1649 BPF_STMT(BPF_RET+BPF_K, 3), 1650 BPF_STMT(BPF_RET+BPF_K, 4), 1651 BPF_STMT(BPF_RET+BPF_K, 5), 1652 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1653 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 4, 1), 1654 BPF_STMT(BPF_RET+BPF_K, 6), 1655 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1656 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 1657 BPF_STMT(BPF_RET+BPF_K, 7), 1658 BPF_STMT(BPF_RET+BPF_K, 8) 1659 }; 1660 1661 bpfjit_func_t code; 1662 uint8_t pkt[8]; /* the program doesn't read any data */ 1663 1664 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1665 1666 ATF_CHECK(bpf_validate(insns, insn_count)); 1667 1668 code = bpfjit_generate_code(NULL, insns, insn_count); 1669 ATF_REQUIRE(code != NULL); 1670 1671 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1672 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1673 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 1674 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1675 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1676 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1677 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1678 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1679 1680 bpfjit_free_code(code); 1681 } 1682 1683 ATF_TC(bpfjit_jmp_jeq_x); 1684 ATF_TC_HEAD(bpfjit_jmp_jeq_x, tc) 1685 { 1686 atf_tc_set_md_var(tc, "descr", 1687 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_X"); 1688 } 1689 1690 ATF_TC_BODY(bpfjit_jmp_jeq_x, tc) 1691 { 1692 static struct bpf_insn insns[] = { 1693 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1694 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1695 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1), 1696 BPF_STMT(BPF_RET+BPF_K, 0), 1697 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 1698 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 0), 1699 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1700 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 1701 BPF_STMT(BPF_RET+BPF_K, 1), 1702 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1703 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 1704 BPF_STMT(BPF_RET+BPF_K, 2), 1705 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1706 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 3), 1707 BPF_STMT(BPF_RET+BPF_K, 3), 1708 BPF_STMT(BPF_RET+BPF_K, 4), 1709 BPF_STMT(BPF_RET+BPF_K, 5), 1710 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1711 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 3, 1), 1712 BPF_STMT(BPF_RET+BPF_K, 6), 1713 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 1, 0, 0), 1714 BPF_STMT(BPF_RET+BPF_K, 7), 1715 BPF_STMT(BPF_RET+BPF_K, 8) 1716 }; 1717 1718 bpfjit_func_t code; 1719 uint8_t pkt[8]; /* the program doesn't read any data */ 1720 1721 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1722 1723 ATF_CHECK(bpf_validate(insns, insn_count)); 1724 1725 code = bpfjit_generate_code(NULL, insns, insn_count); 1726 ATF_REQUIRE(code != NULL); 1727 1728 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 1729 ATF_CHECK(jitcall(code, pkt, 2, 2) == 7); 1730 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 1731 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1732 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 1733 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1734 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1735 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1736 1737 bpfjit_free_code(code); 1738 } 1739 1740 ATF_TC(bpfjit_jmp_jset_x); 1741 ATF_TC_HEAD(bpfjit_jmp_jset_x, tc) 1742 { 1743 atf_tc_set_md_var(tc, "descr", 1744 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_X"); 1745 } 1746 1747 ATF_TC_BODY(bpfjit_jmp_jset_x, tc) 1748 { 1749 static struct bpf_insn insns[] = { 1750 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1751 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1752 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 1), 1753 BPF_STMT(BPF_RET+BPF_K, 0), 1754 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1755 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 0), 1756 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 3, 0, 0), 1757 BPF_STMT(BPF_RET+BPF_K, 1), 1758 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1759 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 1, 1), 1760 BPF_STMT(BPF_RET+BPF_K, 2), 1761 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1762 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 3), 1763 BPF_STMT(BPF_RET+BPF_K, 3), 1764 BPF_STMT(BPF_RET+BPF_K, 4), 1765 BPF_STMT(BPF_RET+BPF_K, 5), 1766 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1767 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 4, 1), 1768 BPF_STMT(BPF_RET+BPF_K, 6), 1769 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1770 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 0), 1771 BPF_STMT(BPF_RET+BPF_K, 7), 1772 BPF_STMT(BPF_RET+BPF_K, 8) 1773 }; 1774 1775 bpfjit_func_t code; 1776 uint8_t pkt[8]; /* the program doesn't read any data */ 1777 1778 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1779 1780 ATF_CHECK(bpf_validate(insns, insn_count)); 1781 1782 code = bpfjit_generate_code(NULL, insns, insn_count); 1783 ATF_REQUIRE(code != NULL); 1784 1785 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1786 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 1787 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 1788 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 1789 ATF_CHECK(jitcall(code, pkt, 5, 5) == 5); 1790 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 1791 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 1792 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 1793 1794 bpfjit_free_code(code); 1795 } 1796 1797 ATF_TC(bpfjit_jmp_modulo_x); 1798 ATF_TC_HEAD(bpfjit_jmp_modulo_x, tc) 1799 { 1800 atf_tc_set_md_var(tc, "descr", 1801 "Test JIT compilation of modulo logic of BPF_JMP+BPF_X operations"); 1802 } 1803 1804 ATF_TC_BODY(bpfjit_jmp_modulo_x, tc) 1805 { 1806 static struct bpf_insn insns[] = { 1807 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1808 /* FFFFF770 << 4 = FFFFF770 */ 1809 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 1810 1811 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 1812 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 1813 BPF_STMT(BPF_RET+BPF_K, 0), 1814 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1815 BPF_STMT(BPF_RET+BPF_K, 1), 1816 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 1817 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1818 BPF_STMT(BPF_RET+BPF_K, 2), 1819 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 1820 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 1821 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1822 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 1823 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 1824 BPF_STMT(BPF_JMP+BPF_JA, 1), 1825 BPF_STMT(BPF_RET+BPF_K, 3), 1826 1827 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 1828 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 1829 1830 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 1831 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 1832 BPF_STMT(BPF_RET+BPF_K, 4), 1833 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1834 BPF_STMT(BPF_RET+BPF_K, 5), 1835 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 1836 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1837 BPF_STMT(BPF_RET+BPF_K, 6), 1838 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 1839 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 1840 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1841 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 1842 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 1843 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1844 BPF_STMT(BPF_RET+BPF_K, 7) 1845 }; 1846 1847 bpfjit_func_t code; 1848 uint8_t pkt[1]; /* the program doesn't read any data */ 1849 1850 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1851 1852 ATF_CHECK(bpf_validate(insns, insn_count)); 1853 1854 code = bpfjit_generate_code(NULL, insns, insn_count); 1855 ATF_REQUIRE(code != NULL); 1856 1857 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 1858 1859 bpfjit_free_code(code); 1860 } 1861 1862 ATF_TC(bpfjit_ld_abs); 1863 ATF_TC_HEAD(bpfjit_ld_abs, tc) 1864 { 1865 atf_tc_set_md_var(tc, "descr", 1866 "Test JIT compilation of BPF_LD+BPF_ABS"); 1867 } 1868 1869 ATF_TC_BODY(bpfjit_ld_abs, tc) 1870 { 1871 static struct bpf_insn insns[3][2] = { 1872 { 1873 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 1874 BPF_STMT(BPF_RET+BPF_A, 0) 1875 }, 1876 { 1877 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 5), 1878 BPF_STMT(BPF_RET+BPF_A, 0) 1879 }, 1880 { 1881 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 5), 1882 BPF_STMT(BPF_RET+BPF_A, 0) 1883 } 1884 }; 1885 1886 static size_t lengths[3] = { 1, 2, 4 }; 1887 static unsigned int expected[3] = { 0xde, 0xdead, 0xdeadbeef }; 1888 1889 size_t i, l; 1890 uint8_t *pkt = deadbeef_at_5; 1891 size_t pktsize = sizeof(deadbeef_at_5); 1892 1893 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 1894 1895 for (i = 0; i < 3; i++) { 1896 bpfjit_func_t code; 1897 1898 ATF_CHECK(bpf_validate(insns[i], insn_count)); 1899 1900 code = bpfjit_generate_code(NULL, insns[i], insn_count); 1901 ATF_REQUIRE(code != NULL); 1902 1903 for (l = 0; l < 5 + lengths[i]; l++) { 1904 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 1905 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 1906 } 1907 1908 l = 5 + lengths[i]; 1909 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 1910 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 1911 1912 l = pktsize; 1913 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 1914 1915 bpfjit_free_code(code); 1916 } 1917 } 1918 1919 ATF_TC(bpfjit_ld_abs_k_overflow); 1920 ATF_TC_HEAD(bpfjit_ld_abs_k_overflow, tc) 1921 { 1922 atf_tc_set_md_var(tc, "descr", 1923 "Test JIT compilation of BPF_LD+BPF_ABS with overflow in k+4"); 1924 } 1925 1926 ATF_TC_BODY(bpfjit_ld_abs_k_overflow, tc) 1927 { 1928 static struct bpf_insn insns[12][3] = { 1929 { 1930 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 1931 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1932 BPF_STMT(BPF_RET+BPF_K, 1) 1933 }, 1934 { 1935 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 1936 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1937 BPF_STMT(BPF_RET+BPF_K, 1) 1938 }, 1939 { 1940 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 1941 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1942 BPF_STMT(BPF_RET+BPF_K, 1) 1943 }, 1944 { 1945 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 1946 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1947 BPF_STMT(BPF_RET+BPF_K, 1) 1948 }, 1949 { 1950 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 1951 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1952 BPF_STMT(BPF_RET+BPF_K, 1) 1953 }, 1954 { 1955 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 1956 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1957 BPF_STMT(BPF_RET+BPF_K, 1) 1958 }, 1959 { 1960 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1961 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 1962 BPF_STMT(BPF_RET+BPF_K, 1) 1963 }, 1964 { 1965 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1966 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 1967 BPF_STMT(BPF_RET+BPF_K, 1) 1968 }, 1969 { 1970 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1971 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 1972 BPF_STMT(BPF_RET+BPF_K, 1) 1973 }, 1974 { 1975 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1976 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 1977 BPF_STMT(BPF_RET+BPF_K, 1) 1978 }, 1979 { 1980 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1981 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 1982 BPF_STMT(BPF_RET+BPF_K, 1) 1983 }, 1984 { 1985 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1986 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 1987 BPF_STMT(BPF_RET+BPF_K, 1) 1988 } 1989 }; 1990 1991 int i; 1992 uint8_t pkt[8] = { 0 }; 1993 1994 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 1995 1996 for (i = 0; i < 3; i++) { 1997 bpfjit_func_t code; 1998 1999 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2000 2001 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2002 ATF_REQUIRE(code != NULL); 2003 2004 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2005 2006 bpfjit_free_code(code); 2007 } 2008 } 2009 2010 ATF_TC(bpfjit_ld_ind); 2011 ATF_TC_HEAD(bpfjit_ld_ind, tc) 2012 { 2013 atf_tc_set_md_var(tc, "descr", 2014 "Test JIT compilation of BPF_LD+BPF_IND"); 2015 } 2016 2017 ATF_TC_BODY(bpfjit_ld_ind, tc) 2018 { 2019 static struct bpf_insn insns[6][3] = { 2020 { 2021 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2022 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2023 BPF_STMT(BPF_RET+BPF_A, 0) 2024 }, 2025 { 2026 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2027 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), 2028 BPF_STMT(BPF_RET+BPF_A, 0) 2029 }, 2030 { 2031 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2032 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2), 2033 BPF_STMT(BPF_RET+BPF_A, 0) 2034 }, 2035 { 2036 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2037 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2038 BPF_STMT(BPF_RET+BPF_A, 0) 2039 }, 2040 { 2041 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2042 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 2043 BPF_STMT(BPF_RET+BPF_A, 0) 2044 }, 2045 { 2046 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2047 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), 2048 BPF_STMT(BPF_RET+BPF_A, 0) 2049 } 2050 }; 2051 2052 static size_t lengths[6] = { 1, 2, 4, 1, 2, 4 }; 2053 2054 static unsigned int expected[6] = { 2055 0xde, 0xdead, 0xdeadbeef, 2056 0xde, 0xdead, 0xdeadbeef 2057 }; 2058 2059 size_t i, l; 2060 uint8_t *pkt = deadbeef_at_5; 2061 size_t pktsize = sizeof(deadbeef_at_5); 2062 2063 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2064 2065 for (i = 0; i < 3; i++) { 2066 bpfjit_func_t code; 2067 2068 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2069 2070 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2071 ATF_REQUIRE(code != NULL); 2072 2073 for (l = 0; l < 5 + lengths[i]; l++) { 2074 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 2075 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 2076 } 2077 2078 l = 5 + lengths[i]; 2079 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2080 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 2081 2082 l = pktsize; 2083 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2084 2085 bpfjit_free_code(code); 2086 } 2087 } 2088 2089 ATF_TC(bpfjit_ld_ind_k_overflow); 2090 ATF_TC_HEAD(bpfjit_ld_ind_k_overflow, tc) 2091 { 2092 atf_tc_set_md_var(tc, "descr", 2093 "Test JIT compilation of BPF_LD+BPF_IND with overflow in k+4"); 2094 } 2095 2096 ATF_TC_BODY(bpfjit_ld_ind_k_overflow, tc) 2097 { 2098 static struct bpf_insn insns[12][3] = { 2099 { 2100 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2101 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2102 BPF_STMT(BPF_RET+BPF_K, 1) 2103 }, 2104 { 2105 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2106 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2107 BPF_STMT(BPF_RET+BPF_K, 1) 2108 }, 2109 { 2110 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2111 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2112 BPF_STMT(BPF_RET+BPF_K, 1) 2113 }, 2114 { 2115 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2116 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2117 BPF_STMT(BPF_RET+BPF_K, 1) 2118 }, 2119 { 2120 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2121 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2122 BPF_STMT(BPF_RET+BPF_K, 1) 2123 }, 2124 { 2125 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2126 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2127 BPF_STMT(BPF_RET+BPF_K, 1) 2128 }, 2129 { 2130 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2131 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2132 BPF_STMT(BPF_RET+BPF_K, 1) 2133 }, 2134 { 2135 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2136 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2137 BPF_STMT(BPF_RET+BPF_K, 1) 2138 }, 2139 { 2140 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2141 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2142 BPF_STMT(BPF_RET+BPF_K, 1) 2143 }, 2144 { 2145 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2146 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2147 BPF_STMT(BPF_RET+BPF_K, 1) 2148 }, 2149 { 2150 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2151 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2152 BPF_STMT(BPF_RET+BPF_K, 1) 2153 }, 2154 { 2155 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2156 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2157 BPF_STMT(BPF_RET+BPF_K, 1) 2158 } 2159 }; 2160 2161 int i; 2162 uint8_t pkt[8] = { 0 }; 2163 2164 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2165 2166 for (i = 0; i < 3; i++) { 2167 bpfjit_func_t code; 2168 2169 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2170 2171 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2172 ATF_REQUIRE(code != NULL); 2173 2174 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2175 2176 bpfjit_free_code(code); 2177 } 2178 } 2179 2180 ATF_TC(bpfjit_ld_ind_x_overflow1); 2181 ATF_TC_HEAD(bpfjit_ld_ind_x_overflow1, tc) 2182 { 2183 atf_tc_set_md_var(tc, "descr", 2184 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2185 } 2186 2187 ATF_TC_BODY(bpfjit_ld_ind_x_overflow1, tc) 2188 { 2189 static struct bpf_insn insns[] = { 2190 BPF_STMT(BPF_LD+BPF_LEN, 0), 2191 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2192 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2193 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2194 BPF_STMT(BPF_RET+BPF_A, 0) 2195 }; 2196 2197 size_t i; 2198 bpfjit_func_t code; 2199 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2200 2201 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2202 2203 ATF_CHECK(bpf_validate(insns, insn_count)); 2204 2205 code = bpfjit_generate_code(NULL, insns, insn_count); 2206 ATF_REQUIRE(code != NULL); 2207 2208 for (i = 1; i <= sizeof(pkt); i++) { 2209 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2210 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2211 } 2212 2213 bpfjit_free_code(code); 2214 } 2215 2216 ATF_TC(bpfjit_ld_ind_x_overflow2); 2217 ATF_TC_HEAD(bpfjit_ld_ind_x_overflow2, tc) 2218 { 2219 atf_tc_set_md_var(tc, "descr", 2220 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2221 } 2222 2223 ATF_TC_BODY(bpfjit_ld_ind_x_overflow2, tc) 2224 { 2225 static struct bpf_insn insns[] = { 2226 BPF_STMT(BPF_LD+BPF_LEN, 0), 2227 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2228 BPF_STMT(BPF_ST, 3), 2229 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2230 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2231 BPF_STMT(BPF_RET+BPF_A, 0) 2232 }; 2233 2234 size_t i; 2235 bpfjit_func_t code; 2236 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2237 2238 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2239 2240 ATF_CHECK(bpf_validate(insns, insn_count)); 2241 2242 code = bpfjit_generate_code(NULL, insns, insn_count); 2243 ATF_REQUIRE(code != NULL); 2244 2245 for (i = 1; i <= sizeof(pkt); i++) { 2246 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2247 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2248 } 2249 2250 bpfjit_free_code(code); 2251 } 2252 2253 ATF_TC(bpfjit_ld_len); 2254 ATF_TC_HEAD(bpfjit_ld_len, tc) 2255 { 2256 atf_tc_set_md_var(tc, "descr", 2257 "Test JIT compilation of BPF_LD+BPF_W+BPF_LEN"); 2258 } 2259 2260 ATF_TC_BODY(bpfjit_ld_len, tc) 2261 { 2262 static struct bpf_insn insns[] = { 2263 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2264 BPF_STMT(BPF_RET+BPF_A, 0) 2265 }; 2266 2267 size_t i; 2268 bpfjit_func_t code; 2269 uint8_t pkt[32]; /* the program doesn't read any data */ 2270 2271 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2272 2273 ATF_CHECK(bpf_validate(insns, insn_count)); 2274 2275 code = bpfjit_generate_code(NULL, insns, insn_count); 2276 ATF_REQUIRE(code != NULL); 2277 2278 for (i = 0; i < sizeof(pkt); i++) 2279 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 2280 2281 bpfjit_free_code(code); 2282 } 2283 2284 ATF_TC(bpfjit_ld_imm); 2285 ATF_TC_HEAD(bpfjit_ld_imm, tc) 2286 { 2287 atf_tc_set_md_var(tc, "descr", 2288 "Test JIT compilation of BPF_LD+BPF_IMM"); 2289 } 2290 2291 ATF_TC_BODY(bpfjit_ld_imm, tc) 2292 { 2293 static struct bpf_insn insns[] = { 2294 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX), 2295 BPF_STMT(BPF_RET+BPF_A, 0) 2296 }; 2297 2298 bpfjit_func_t code; 2299 uint8_t pkt[1]; /* the program doesn't read any data */ 2300 2301 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2302 2303 ATF_CHECK(bpf_validate(insns, insn_count)); 2304 2305 code = bpfjit_generate_code(NULL, insns, insn_count); 2306 ATF_REQUIRE(code != NULL); 2307 2308 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2309 2310 bpfjit_free_code(code); 2311 } 2312 2313 ATF_TC(bpfjit_ldx_imm1); 2314 ATF_TC_HEAD(bpfjit_ldx_imm1, tc) 2315 { 2316 atf_tc_set_md_var(tc, "descr", 2317 "Test JIT compilation of BPF_LDX+BPF_IMM"); 2318 } 2319 2320 ATF_TC_BODY(bpfjit_ldx_imm1, tc) 2321 { 2322 static struct bpf_insn insns[] = { 2323 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX - 5), 2324 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2325 BPF_STMT(BPF_RET+BPF_A, 0) 2326 }; 2327 2328 bpfjit_func_t code; 2329 uint8_t pkt[1]; /* the program doesn't read any data */ 2330 2331 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2332 2333 ATF_CHECK(bpf_validate(insns, insn_count)); 2334 2335 code = bpfjit_generate_code(NULL, insns, insn_count); 2336 ATF_REQUIRE(code != NULL); 2337 2338 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX - 5); 2339 2340 bpfjit_free_code(code); 2341 } 2342 2343 ATF_TC(bpfjit_ldx_imm2); 2344 ATF_TC_HEAD(bpfjit_ldx_imm2, tc) 2345 { 2346 atf_tc_set_md_var(tc, "descr", 2347 "Test JIT compilation of BPF_LDX+BPF_IMM"); 2348 } 2349 2350 ATF_TC_BODY(bpfjit_ldx_imm2, tc) 2351 { 2352 static struct bpf_insn insns[] = { 2353 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2354 BPF_STMT(BPF_LD+BPF_IMM, 5), 2355 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2356 BPF_STMT(BPF_RET+BPF_K, 7), 2357 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 2358 }; 2359 2360 bpfjit_func_t code; 2361 uint8_t pkt[1]; /* the program doesn't read any data */ 2362 2363 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2364 2365 ATF_CHECK(bpf_validate(insns, insn_count)); 2366 2367 code = bpfjit_generate_code(NULL, insns, insn_count); 2368 ATF_REQUIRE(code != NULL); 2369 2370 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2371 2372 bpfjit_free_code(code); 2373 } 2374 2375 ATF_TC(bpfjit_ldx_len1); 2376 ATF_TC_HEAD(bpfjit_ldx_len1, tc) 2377 { 2378 atf_tc_set_md_var(tc, "descr", 2379 "Test JIT compilation of BPF_LDX+BPF_LEN"); 2380 } 2381 2382 ATF_TC_BODY(bpfjit_ldx_len1, tc) 2383 { 2384 static struct bpf_insn insns[] = { 2385 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2386 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2387 BPF_STMT(BPF_RET+BPF_A, 0) 2388 }; 2389 2390 size_t i; 2391 bpfjit_func_t code; 2392 uint8_t pkt[5]; /* the program doesn't read any data */ 2393 2394 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2395 2396 ATF_CHECK(bpf_validate(insns, insn_count)); 2397 2398 code = bpfjit_generate_code(NULL, insns, insn_count); 2399 ATF_REQUIRE(code != NULL); 2400 2401 for (i = 1; i < sizeof(pkt); i++) { 2402 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 2403 ATF_CHECK(jitcall(code, pkt, i + 1, i) == i + 1); 2404 } 2405 2406 bpfjit_free_code(code); 2407 } 2408 2409 ATF_TC(bpfjit_ldx_len2); 2410 ATF_TC_HEAD(bpfjit_ldx_len2, tc) 2411 { 2412 atf_tc_set_md_var(tc, "descr", 2413 "Test JIT compilation of BPF_LDX+BPF_LEN"); 2414 } 2415 2416 ATF_TC_BODY(bpfjit_ldx_len2, tc) 2417 { 2418 static struct bpf_insn insns[] = { 2419 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2420 BPF_STMT(BPF_LD+BPF_IMM, 5), 2421 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2422 BPF_STMT(BPF_RET+BPF_K, 7), 2423 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 2424 }; 2425 2426 bpfjit_func_t code; 2427 uint8_t pkt[5]; /* the program doesn't read any data */ 2428 2429 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2430 2431 ATF_CHECK(bpf_validate(insns, insn_count)); 2432 2433 code = bpfjit_generate_code(NULL, insns, insn_count); 2434 ATF_REQUIRE(code != NULL); 2435 2436 ATF_CHECK(jitcall(code, pkt, 5, 1) == UINT32_MAX); 2437 ATF_CHECK(jitcall(code, pkt, 6, 5) == 7); 2438 2439 bpfjit_free_code(code); 2440 } 2441 2442 ATF_TC(bpfjit_ldx_msh); 2443 ATF_TC_HEAD(bpfjit_ldx_msh, tc) 2444 { 2445 atf_tc_set_md_var(tc, "descr", 2446 "Test JIT compilation of BPF_LDX+BPF_MSH"); 2447 } 2448 2449 ATF_TC_BODY(bpfjit_ldx_msh, tc) 2450 { 2451 static struct bpf_insn insns[] = { 2452 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), 2453 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2454 BPF_STMT(BPF_RET+BPF_A, 0) 2455 }; 2456 2457 bpfjit_func_t code; 2458 uint8_t pkt[2] = { 0, 0x7a }; 2459 2460 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2461 2462 ATF_CHECK(bpf_validate(insns, insn_count)); 2463 2464 code = bpfjit_generate_code(NULL, insns, insn_count); 2465 ATF_REQUIRE(code != NULL); 2466 2467 ATF_CHECK(jitcall(code, pkt, 2, 2) == 40); 2468 2469 bpfjit_free_code(code); 2470 } 2471 2472 ATF_TC(bpfjit_misc_tax); 2473 ATF_TC_HEAD(bpfjit_misc_tax, tc) 2474 { 2475 atf_tc_set_md_var(tc, "descr", 2476 "Test JIT compilation of BPF_MISC+BPF_TAX"); 2477 } 2478 2479 ATF_TC_BODY(bpfjit_misc_tax, tc) 2480 { 2481 static struct bpf_insn insns[] = { 2482 BPF_STMT(BPF_LD+BPF_IMM, 3), 2483 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2484 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2485 BPF_STMT(BPF_RET+BPF_A, 0) 2486 }; 2487 2488 bpfjit_func_t code; 2489 uint8_t pkt[] = { 0, 11, 22, 33, 44, 55 }; 2490 2491 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2492 2493 ATF_CHECK(bpf_validate(insns, insn_count)); 2494 2495 code = bpfjit_generate_code(NULL, insns, insn_count); 2496 ATF_REQUIRE(code != NULL); 2497 2498 ATF_CHECK(jitcall(code, pkt, sizeof(pkt), sizeof(pkt)) == 55); 2499 2500 bpfjit_free_code(code); 2501 } 2502 2503 ATF_TC(bpfjit_misc_txa); 2504 ATF_TC_HEAD(bpfjit_misc_txa, tc) 2505 { 2506 atf_tc_set_md_var(tc, "descr", 2507 "Test JIT compilation of BPF_MISC+BPF_TXA"); 2508 } 2509 2510 ATF_TC_BODY(bpfjit_misc_txa, tc) 2511 { 2512 static struct bpf_insn insns[] = { 2513 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 391), 2514 BPF_STMT(BPF_MISC+BPF_TXA, 0), 2515 BPF_STMT(BPF_RET+BPF_A, 0) 2516 }; 2517 2518 bpfjit_func_t code; 2519 uint8_t pkt[1]; /* the program doesn't read any data */ 2520 2521 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2522 2523 ATF_CHECK(bpf_validate(insns, insn_count)); 2524 2525 code = bpfjit_generate_code(NULL, insns, insn_count); 2526 ATF_REQUIRE(code != NULL); 2527 2528 ATF_CHECK(jitcall(code, pkt, 1, 1) == 391); 2529 2530 bpfjit_free_code(code); 2531 } 2532 2533 ATF_TC(bpfjit_st1); 2534 ATF_TC_HEAD(bpfjit_st1, tc) 2535 { 2536 atf_tc_set_md_var(tc, "descr", 2537 "Test JIT compilation of BPF_ST"); 2538 } 2539 2540 ATF_TC_BODY(bpfjit_st1, tc) 2541 { 2542 static struct bpf_insn insns[] = { 2543 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2544 BPF_STMT(BPF_ST, 0), 2545 BPF_STMT(BPF_LD+BPF_MEM, 0), 2546 BPF_STMT(BPF_RET+BPF_A, 0) 2547 }; 2548 2549 size_t i; 2550 bpfjit_func_t code; 2551 uint8_t pkt[16]; /* the program doesn't read any data */ 2552 2553 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2554 2555 ATF_CHECK(bpf_validate(insns, insn_count)); 2556 2557 code = bpfjit_generate_code(NULL, insns, insn_count); 2558 ATF_REQUIRE(code != NULL); 2559 2560 for (i = 1; i <= sizeof(pkt); i++) 2561 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 2562 2563 bpfjit_free_code(code); 2564 } 2565 2566 ATF_TC(bpfjit_st2); 2567 ATF_TC_HEAD(bpfjit_st2, tc) 2568 { 2569 atf_tc_set_md_var(tc, "descr", 2570 "Test JIT compilation of BPF_ST"); 2571 } 2572 2573 ATF_TC_BODY(bpfjit_st2, tc) 2574 { 2575 static struct bpf_insn insns[] = { 2576 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2577 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2578 BPF_STMT(BPF_LD+BPF_MEM, 0), 2579 BPF_STMT(BPF_RET+BPF_A, 0) 2580 }; 2581 2582 bpfjit_func_t code; 2583 uint8_t pkt[1]; /* the program doesn't read any data */ 2584 2585 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2586 2587 ATF_CHECK(bpf_validate(insns, insn_count)); 2588 2589 code = bpfjit_generate_code(NULL, insns, insn_count); 2590 ATF_REQUIRE(code != NULL); 2591 2592 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 2593 2594 bpfjit_free_code(code); 2595 } 2596 2597 ATF_TC(bpfjit_st3); 2598 ATF_TC_HEAD(bpfjit_st3, tc) 2599 { 2600 atf_tc_set_md_var(tc, "descr", 2601 "Test JIT compilation of BPF_ST"); 2602 } 2603 2604 ATF_TC_BODY(bpfjit_st3, tc) 2605 { 2606 static struct bpf_insn insns[] = { 2607 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2608 BPF_STMT(BPF_ST, 0), 2609 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 2610 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2611 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 2612 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 2613 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 2614 BPF_STMT(BPF_RET+BPF_A, 0), 2615 BPF_STMT(BPF_LD+BPF_MEM, 0), 2616 BPF_STMT(BPF_RET+BPF_A, 0) 2617 }; 2618 2619 bpfjit_func_t code; 2620 uint8_t pkt[2]; /* the program doesn't read any data */ 2621 2622 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2623 2624 ATF_REQUIRE(BPF_MEMWORDS > 1); 2625 2626 ATF_CHECK(bpf_validate(insns, insn_count)); 2627 2628 code = bpfjit_generate_code(NULL, insns, insn_count); 2629 ATF_REQUIRE(code != NULL); 2630 2631 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2632 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 2633 2634 bpfjit_free_code(code); 2635 } 2636 2637 ATF_TC(bpfjit_st4); 2638 ATF_TC_HEAD(bpfjit_st4, tc) 2639 { 2640 atf_tc_set_md_var(tc, "descr", 2641 "Test JIT compilation of BPF_ST"); 2642 } 2643 2644 ATF_TC_BODY(bpfjit_st4, tc) 2645 { 2646 static struct bpf_insn insns[] = { 2647 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2648 BPF_STMT(BPF_ST, 5), 2649 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 2650 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2651 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 2652 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 2653 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 2654 BPF_STMT(BPF_RET+BPF_A, 0), 2655 BPF_STMT(BPF_LD+BPF_MEM, 5), 2656 BPF_STMT(BPF_RET+BPF_A, 0) 2657 }; 2658 2659 bpfjit_func_t code; 2660 uint8_t pkt[2]; /* the program doesn't read any data */ 2661 2662 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2663 2664 ATF_REQUIRE(BPF_MEMWORDS > 6); 2665 2666 ATF_CHECK(bpf_validate(insns, insn_count)); 2667 2668 code = bpfjit_generate_code(NULL, insns, insn_count); 2669 ATF_REQUIRE(code != NULL); 2670 2671 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2672 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 2673 2674 bpfjit_free_code(code); 2675 } 2676 2677 ATF_TC(bpfjit_st5); 2678 ATF_TC_HEAD(bpfjit_st5, tc) 2679 { 2680 atf_tc_set_md_var(tc, "descr", 2681 "Test JIT compilation of BPF_ST"); 2682 } 2683 2684 ATF_TC_BODY(bpfjit_st5, tc) 2685 { 2686 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 2687 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2688 2689 size_t k; 2690 bpfjit_func_t code; 2691 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 2692 2693 memset(insns, 0, sizeof(insns)); 2694 2695 /* for each k do M[k] = k */ 2696 for (k = 0; k < BPF_MEMWORDS; k++) { 2697 insns[2*k].code = BPF_LD+BPF_IMM; 2698 insns[2*k].k = 3*k; 2699 insns[2*k+1].code = BPF_ST; 2700 insns[2*k+1].k = k; 2701 } 2702 2703 /* load wirelen into A */ 2704 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 2705 2706 /* for each k, if (A == k + 1) return M[k] */ 2707 for (k = 0; k < BPF_MEMWORDS; k++) { 2708 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 2709 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 2710 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 2711 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 2712 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 2713 insns[2*BPF_MEMWORDS+3*k+2].k = k; 2714 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 2715 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 2716 } 2717 2718 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 2719 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 2720 2721 ATF_CHECK(bpf_validate(insns, insn_count)); 2722 2723 code = bpfjit_generate_code(NULL, insns, insn_count); 2724 ATF_REQUIRE(code != NULL); 2725 2726 for (k = 1; k <= sizeof(pkt); k++) 2727 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 2728 2729 bpfjit_free_code(code); 2730 } 2731 2732 ATF_TC(bpfjit_stx1); 2733 ATF_TC_HEAD(bpfjit_stx1, tc) 2734 { 2735 atf_tc_set_md_var(tc, "descr", 2736 "Test JIT compilation of BPF_STX"); 2737 } 2738 2739 ATF_TC_BODY(bpfjit_stx1, tc) 2740 { 2741 static struct bpf_insn insns[] = { 2742 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2743 BPF_STMT(BPF_STX, 0), 2744 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 2745 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2746 BPF_STMT(BPF_RET+BPF_A, 0) 2747 }; 2748 2749 size_t i; 2750 bpfjit_func_t code; 2751 uint8_t pkt[16]; /* the program doesn't read any data */ 2752 2753 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2754 2755 ATF_CHECK(bpf_validate(insns, insn_count)); 2756 2757 code = bpfjit_generate_code(NULL, insns, insn_count); 2758 ATF_REQUIRE(code != NULL); 2759 2760 for (i = 1; i <= sizeof(pkt); i++) 2761 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 2762 2763 bpfjit_free_code(code); 2764 } 2765 2766 ATF_TC(bpfjit_stx2); 2767 ATF_TC_HEAD(bpfjit_stx2, tc) 2768 { 2769 atf_tc_set_md_var(tc, "descr", 2770 "Test JIT compilation of BPF_STX"); 2771 } 2772 2773 ATF_TC_BODY(bpfjit_stx2, tc) 2774 { 2775 static struct bpf_insn insns[] = { 2776 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2777 BPF_STMT(BPF_STX, BPF_MEMWORDS-1), 2778 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 2779 BPF_STMT(BPF_MISC+BPF_TXA, 0), 2780 BPF_STMT(BPF_RET+BPF_A, 0) 2781 }; 2782 2783 bpfjit_func_t code; 2784 uint8_t pkt[1]; /* the program doesn't read any data */ 2785 2786 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2787 2788 ATF_CHECK(bpf_validate(insns, insn_count)); 2789 2790 code = bpfjit_generate_code(NULL, insns, insn_count); 2791 ATF_REQUIRE(code != NULL); 2792 2793 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 2794 2795 bpfjit_free_code(code); 2796 } 2797 2798 ATF_TC(bpfjit_stx3); 2799 ATF_TC_HEAD(bpfjit_stx3, tc) 2800 { 2801 atf_tc_set_md_var(tc, "descr", 2802 "Test JIT compilation of BPF_STX"); 2803 } 2804 2805 ATF_TC_BODY(bpfjit_stx3, tc) 2806 { 2807 static struct bpf_insn insns[] = { 2808 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2809 BPF_STMT(BPF_STX, 5), 2810 BPF_STMT(BPF_STX, 2), 2811 BPF_STMT(BPF_STX, 3), 2812 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 1), 2813 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2814 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 2), 2815 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2816 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2817 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2818 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 5), 2819 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2820 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 6), 2821 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2822 BPF_STMT(BPF_RET+BPF_A, 0) 2823 }; 2824 2825 size_t i; 2826 bpfjit_func_t code; 2827 uint8_t pkt[16]; /* the program doesn't read any data */ 2828 2829 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2830 2831 ATF_CHECK(bpf_validate(insns, insn_count)); 2832 2833 code = bpfjit_generate_code(NULL, insns, insn_count); 2834 ATF_REQUIRE(code != NULL); 2835 2836 for (i = 1; i <= sizeof(pkt); i++) 2837 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == 3 * i); 2838 2839 bpfjit_free_code(code); 2840 } 2841 2842 ATF_TC(bpfjit_stx4); 2843 ATF_TC_HEAD(bpfjit_stx4, tc) 2844 { 2845 atf_tc_set_md_var(tc, "descr", 2846 "Test JIT compilation of BPF_STX"); 2847 } 2848 2849 ATF_TC_BODY(bpfjit_stx4, tc) 2850 { 2851 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 2852 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2853 2854 size_t k; 2855 bpfjit_func_t code; 2856 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 2857 2858 memset(insns, 0, sizeof(insns)); 2859 2860 /* for each k do M[k] = k */ 2861 for (k = 0; k < BPF_MEMWORDS; k++) { 2862 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM; 2863 insns[2*k].k = 3*k; 2864 insns[2*k+1].code = BPF_STX; 2865 insns[2*k+1].k = k; 2866 } 2867 2868 /* load wirelen into A */ 2869 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 2870 2871 /* for each k, if (A == k + 1) return M[k] */ 2872 for (k = 0; k < BPF_MEMWORDS; k++) { 2873 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 2874 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 2875 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 2876 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 2877 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 2878 insns[2*BPF_MEMWORDS+3*k+2].k = k; 2879 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 2880 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 2881 } 2882 2883 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 2884 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 2885 2886 ATF_CHECK(bpf_validate(insns, insn_count)); 2887 2888 code = bpfjit_generate_code(NULL, insns, insn_count); 2889 ATF_REQUIRE(code != NULL); 2890 2891 for (k = 1; k <= sizeof(pkt); k++) 2892 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 2893 2894 bpfjit_free_code(code); 2895 } 2896 2897 ATF_TC(bpfjit_opt_ld_abs_1); 2898 ATF_TC_HEAD(bpfjit_opt_ld_abs_1, tc) 2899 { 2900 atf_tc_set_md_var(tc, "descr", 2901 "Test JIT compilation with length optimization " 2902 "applied to BPF_LD+BPF_ABS"); 2903 } 2904 2905 ATF_TC_BODY(bpfjit_opt_ld_abs_1, tc) 2906 { 2907 static struct bpf_insn insns[] = { 2908 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 2909 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 2910 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 2911 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 2912 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2913 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 2914 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 2915 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2916 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 2917 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2918 BPF_STMT(BPF_RET+BPF_K, 0), 2919 }; 2920 2921 size_t i, j; 2922 bpfjit_func_t code; 2923 uint8_t pkt[2][34] = { 2924 { 2925 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2926 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2927 0x80, 0x03, 0x70, 0x0f, 2928 0x80, 0x03, 0x70, 0x23 2929 }, 2930 { 2931 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2932 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2933 0x80, 0x03, 0x70, 0x23, 2934 0x80, 0x03, 0x70, 0x0f 2935 } 2936 }; 2937 2938 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2939 2940 ATF_CHECK(bpf_validate(insns, insn_count)); 2941 2942 code = bpfjit_generate_code(NULL, insns, insn_count); 2943 ATF_REQUIRE(code != NULL); 2944 2945 for (i = 0; i < 2; i++) { 2946 for (j = 1; j < sizeof(pkt[i]); j++) 2947 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 2948 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 2949 } 2950 2951 bpfjit_free_code(code); 2952 } 2953 2954 ATF_TC(bpfjit_opt_ld_abs_2); 2955 ATF_TC_HEAD(bpfjit_opt_ld_abs_2, tc) 2956 { 2957 atf_tc_set_md_var(tc, "descr", 2958 "Test JIT compilation with length optimization " 2959 "applied to BPF_LD+BPF_ABS"); 2960 } 2961 2962 ATF_TC_BODY(bpfjit_opt_ld_abs_2, tc) 2963 { 2964 static struct bpf_insn insns[] = { 2965 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 2966 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 2967 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2968 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 2969 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 2970 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2971 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 2972 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 2973 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 2974 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2975 BPF_STMT(BPF_RET+BPF_K, 0), 2976 }; 2977 2978 size_t i, j; 2979 bpfjit_func_t code; 2980 uint8_t pkt[2][34] = { 2981 { 2982 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2983 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2984 0x80, 0x03, 0x70, 0x0f, 2985 0x80, 0x03, 0x70, 0x23 2986 }, 2987 { 2988 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2989 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2990 0x80, 0x03, 0x70, 0x23, 2991 0x80, 0x03, 0x70, 0x0f 2992 } 2993 }; 2994 2995 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2996 2997 ATF_CHECK(bpf_validate(insns, insn_count)); 2998 2999 code = bpfjit_generate_code(NULL, insns, insn_count); 3000 ATF_REQUIRE(code != NULL); 3001 3002 for (i = 0; i < 2; i++) { 3003 for (j = 1; j < sizeof(pkt[i]); j++) 3004 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3005 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3006 } 3007 3008 bpfjit_free_code(code); 3009 } 3010 3011 ATF_TC(bpfjit_opt_ld_abs_3); 3012 ATF_TC_HEAD(bpfjit_opt_ld_abs_3, tc) 3013 { 3014 atf_tc_set_md_var(tc, "descr", 3015 "Test JIT compilation with length optimization " 3016 "applied to BPF_LD+BPF_ABS"); 3017 } 3018 3019 ATF_TC_BODY(bpfjit_opt_ld_abs_3, tc) 3020 { 3021 static struct bpf_insn insns[] = { 3022 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3023 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3024 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3025 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 6), 3026 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 5), 3027 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3028 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3029 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3030 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3031 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3032 BPF_STMT(BPF_RET+BPF_K, 0), 3033 }; 3034 3035 size_t i, j; 3036 bpfjit_func_t code; 3037 uint8_t pkt[2][34] = { 3038 { 3039 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3040 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3041 0x80, 0x03, 0x70, 0x0f, 3042 0x80, 0x03, 0x70, 0x23 3043 }, 3044 { 3045 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3046 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3047 0x80, 0x03, 0x70, 0x23, 3048 0x80, 0x03, 0x70, 0x0f 3049 } 3050 }; 3051 3052 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3053 3054 ATF_CHECK(bpf_validate(insns, insn_count)); 3055 3056 code = bpfjit_generate_code(NULL, insns, insn_count); 3057 ATF_REQUIRE(code != NULL); 3058 3059 for (i = 0; i < 2; i++) { 3060 for (j = 1; j < sizeof(pkt[i]); j++) 3061 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3062 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3063 } 3064 3065 bpfjit_free_code(code); 3066 } 3067 3068 ATF_TC(bpfjit_opt_ld_ind_1); 3069 ATF_TC_HEAD(bpfjit_opt_ld_ind_1, tc) 3070 { 3071 atf_tc_set_md_var(tc, "descr", 3072 "Test JIT compilation with length optimization " 3073 "applied to BPF_LD+BPF_IND"); 3074 } 3075 3076 ATF_TC_BODY(bpfjit_opt_ld_ind_1, tc) 3077 { 3078 static struct bpf_insn insns[] = { 3079 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 12), 3080 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 3081 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3082 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 14), 3083 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3084 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3085 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3086 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3087 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3088 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3089 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3090 BPF_STMT(BPF_RET+BPF_K, 0), 3091 }; 3092 3093 size_t i, j; 3094 bpfjit_func_t code; 3095 uint8_t pkt[2][34] = { 3096 { 3097 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3098 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3099 0x80, 0x03, 0x70, 0x0f, 3100 0x80, 0x03, 0x70, 0x23 3101 }, 3102 { 3103 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3104 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3105 0x80, 0x03, 0x70, 0x23, 3106 0x80, 0x03, 0x70, 0x0f 3107 } 3108 }; 3109 3110 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3111 3112 ATF_CHECK(bpf_validate(insns, insn_count)); 3113 3114 code = bpfjit_generate_code(NULL, insns, insn_count); 3115 ATF_REQUIRE(code != NULL); 3116 3117 for (i = 0; i < 2; i++) { 3118 for (j = 1; j < sizeof(pkt[i]); j++) 3119 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3120 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3121 } 3122 3123 bpfjit_free_code(code); 3124 } 3125 3126 ATF_TC(bpfjit_opt_ld_ind_2); 3127 ATF_TC_HEAD(bpfjit_opt_ld_ind_2, tc) 3128 { 3129 atf_tc_set_md_var(tc, "descr", 3130 "Test JIT compilation with length optimization " 3131 "applied to BPF_LD+BPF_IND"); 3132 } 3133 3134 ATF_TC_BODY(bpfjit_opt_ld_ind_2, tc) 3135 { 3136 static struct bpf_insn insns[] = { 3137 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3138 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 26), 3139 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3140 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3141 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3142 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3143 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3144 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3145 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3146 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3147 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3148 BPF_STMT(BPF_RET+BPF_K, 0), 3149 }; 3150 3151 size_t i, j; 3152 bpfjit_func_t code; 3153 uint8_t pkt[2][34] = { 3154 { 3155 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3156 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3157 0x80, 0x03, 0x70, 0x0f, 3158 0x80, 0x03, 0x70, 0x23 3159 }, 3160 { 3161 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3162 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3163 0x80, 0x03, 0x70, 0x23, 3164 0x80, 0x03, 0x70, 0x0f 3165 } 3166 }; 3167 3168 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3169 3170 ATF_CHECK(bpf_validate(insns, insn_count)); 3171 3172 code = bpfjit_generate_code(NULL, insns, insn_count); 3173 ATF_REQUIRE(code != NULL); 3174 3175 for (i = 0; i < 2; i++) { 3176 for (j = 1; j < sizeof(pkt[i]); j++) 3177 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3178 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3179 } 3180 3181 bpfjit_free_code(code); 3182 } 3183 3184 ATF_TC(bpfjit_opt_ld_ind_3); 3185 ATF_TC_HEAD(bpfjit_opt_ld_ind_3, tc) 3186 { 3187 atf_tc_set_md_var(tc, "descr", 3188 "Test JIT compilation with length optimization " 3189 "applied to BPF_LD+BPF_IND"); 3190 } 3191 3192 ATF_TC_BODY(bpfjit_opt_ld_ind_3, tc) 3193 { 3194 static struct bpf_insn insns[] = { 3195 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 15), 3196 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3197 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3198 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3199 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3200 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3201 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3202 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3203 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3204 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3205 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3206 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3207 BPF_STMT(BPF_RET+BPF_K, 0), 3208 }; 3209 3210 size_t i, j; 3211 bpfjit_func_t code; 3212 uint8_t pkt[2][34] = { 3213 { 3214 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3215 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3216 0x80, 0x03, 0x70, 0x0f, 3217 0x80, 0x03, 0x70, 0x23 3218 }, 3219 { 3220 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3221 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3222 0x80, 0x03, 0x70, 0x23, 3223 0x80, 0x03, 0x70, 0x0f 3224 } 3225 }; 3226 3227 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3228 3229 ATF_CHECK(bpf_validate(insns, insn_count)); 3230 3231 code = bpfjit_generate_code(NULL, insns, insn_count); 3232 ATF_REQUIRE(code != NULL); 3233 3234 for (i = 0; i < 2; i++) { 3235 for (j = 1; j < sizeof(pkt[i]); j++) 3236 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3237 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3238 } 3239 3240 bpfjit_free_code(code); 3241 } 3242 3243 ATF_TC(bpfjit_opt_ld_ind_4); 3244 ATF_TC_HEAD(bpfjit_opt_ld_ind_4, tc) 3245 { 3246 atf_tc_set_md_var(tc, "descr", 3247 "Test JIT compilation with length optimization " 3248 "applied to BPF_LD+BPF_IND"); 3249 } 3250 3251 ATF_TC_BODY(bpfjit_opt_ld_ind_4, tc) 3252 { 3253 static struct bpf_insn insns[] = { 3254 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 11), 3255 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 19), 3256 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3257 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3258 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3259 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3260 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3261 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3262 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3263 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3264 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3265 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3266 BPF_STMT(BPF_RET+BPF_K, 0), 3267 }; 3268 3269 size_t i, j; 3270 bpfjit_func_t code; 3271 uint8_t pkt[2][34] = { 3272 { 3273 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3274 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3275 0x80, 0x03, 0x70, 0x0f, 3276 0x80, 0x03, 0x70, 0x23 3277 }, 3278 { 3279 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3280 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3281 0x80, 0x03, 0x70, 0x23, 3282 0x80, 0x03, 0x70, 0x0f 3283 } 3284 }; 3285 3286 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3287 3288 ATF_CHECK(bpf_validate(insns, insn_count)); 3289 3290 code = bpfjit_generate_code(NULL, insns, insn_count); 3291 ATF_REQUIRE(code != NULL); 3292 3293 for (i = 0; i < 2; i++) { 3294 for (j = 1; j < sizeof(pkt[i]); j++) 3295 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3296 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3297 } 3298 3299 bpfjit_free_code(code); 3300 } 3301 3302 ATF_TC(bpfjit_abc_ja); 3303 ATF_TC_HEAD(bpfjit_abc_ja, tc) 3304 { 3305 atf_tc_set_md_var(tc, "descr", 3306 "Test ABC optimization with a single BPF_JMP+BPF_JA"); 3307 } 3308 3309 ATF_TC_BODY(bpfjit_abc_ja, tc) 3310 { 3311 static struct bpf_insn insns[] = { 3312 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 3313 BPF_STMT(BPF_JMP+BPF_JA, 2), 3314 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, UINT32_MAX - 1), 3315 BPF_STMT(BPF_RET+BPF_K, 0), 3316 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2), /* min. length 6 */ 3317 BPF_STMT(BPF_RET+BPF_A, 0), 3318 BPF_STMT(BPF_RET+BPF_K, 1), 3319 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 3320 BPF_STMT(BPF_RET+BPF_K, 2), 3321 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 3322 BPF_STMT(BPF_RET+BPF_K, 3), 3323 }; 3324 3325 bpfjit_func_t code; 3326 uint8_t pkt[6] = {0, 0, /* UINT32_MAX: */ 255, 255, 255, 255}; 3327 3328 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3329 3330 ATF_CHECK(bpf_validate(insns, insn_count)); 3331 3332 code = bpfjit_generate_code(NULL, insns, insn_count); 3333 ATF_REQUIRE(code != NULL); 3334 3335 ATF_CHECK(jitcall(code, pkt, 0, 0) == 0); 3336 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3337 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3338 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3339 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3340 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3341 ATF_CHECK(jitcall(code, pkt, 6, 6) == UINT32_MAX); 3342 3343 bpfjit_free_code(code); 3344 } 3345 3346 ATF_TC(bpfjit_abc_ja_over); 3347 ATF_TC_HEAD(bpfjit_abc_ja_over, tc) 3348 { 3349 atf_tc_set_md_var(tc, "descr", 3350 "Test ABC optimization when BPF_JMP+BPF_JA jumps over all loads"); 3351 } 3352 3353 ATF_TC_BODY(bpfjit_abc_ja_over, tc) 3354 { 3355 static struct bpf_insn insns[] = { 3356 BPF_STMT(BPF_JMP+BPF_JA, 2), 3357 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), 3358 BPF_STMT(BPF_RET+BPF_K, 0), 3359 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3360 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), 3361 BPF_STMT(BPF_RET+BPF_K, 1), 3362 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 3363 BPF_STMT(BPF_RET+BPF_K, 2), 3364 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 3365 BPF_STMT(BPF_RET+BPF_K, 3), 3366 }; 3367 3368 bpfjit_func_t code; 3369 uint8_t pkt[1]; /* the program doesn't read any data */ 3370 3371 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3372 3373 ATF_CHECK(bpf_validate(insns, insn_count)); 3374 3375 code = bpfjit_generate_code(NULL, insns, insn_count); 3376 ATF_REQUIRE(code != NULL); 3377 3378 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 3379 3380 bpfjit_free_code(code); 3381 } 3382 3383 ATF_TC(bpfjit_abc_ld_chain); 3384 ATF_TC_HEAD(bpfjit_abc_ld_chain, tc) 3385 { 3386 atf_tc_set_md_var(tc, "descr", 3387 "Test ABC optimization of a chain of BPF_LD instructions " 3388 "with exits leading to a single BPF_RET"); 3389 } 3390 3391 ATF_TC_BODY(bpfjit_abc_ld_chain, tc) 3392 { 3393 static struct bpf_insn insns[] = { 3394 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 3395 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 4), 3396 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* min. length 6 */ 3397 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 0, 2), 3398 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 6), /* min. length 10 */ 3399 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 0, 1), 3400 BPF_STMT(BPF_RET+BPF_K, 123456789), 3401 BPF_STMT(BPF_RET+BPF_K, 987654321), 3402 }; 3403 3404 bpfjit_func_t code; 3405 uint8_t pkt[10] = {}; 3406 3407 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3408 3409 ATF_CHECK(bpf_validate(insns, insn_count)); 3410 3411 code = bpfjit_generate_code(NULL, insns, insn_count); 3412 ATF_REQUIRE(code != NULL); 3413 3414 /* Packet is too short. */ 3415 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3416 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3417 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3418 3419 /* !(pkt[3] == 8) => return 123456789 */ 3420 ATF_CHECK(jitcall(code, pkt, 4, 4) == 123456789); 3421 ATF_CHECK(jitcall(code, pkt, 5, 5) == 123456789); 3422 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 3423 ATF_CHECK(jitcall(code, pkt, 7, 7) == 123456789); 3424 ATF_CHECK(jitcall(code, pkt, 8, 8) == 123456789); 3425 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 3426 3427 /* !(pkt[4:2] >= 7) => too short or return 123456789 */ 3428 pkt[3] = 8; 3429 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3430 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3431 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3432 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3433 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3434 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 3435 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 3436 3437 /* !(pkt[6:4] > 6) => too short or return 987654321 */ 3438 pkt[4] = pkt[5] = 1; 3439 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3440 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3441 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3442 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3443 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3444 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3445 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3446 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3447 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3448 ATF_CHECK(jitcall(code, pkt, 10, 10) == 987654321); 3449 3450 /* (pkt[6:4] > 6) => too short or return 123456789 */ 3451 pkt[6] = pkt[7] = pkt[8] = pkt[9] = 1; 3452 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3453 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3454 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3455 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3456 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3457 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3458 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3459 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3460 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3461 ATF_CHECK(jitcall(code, pkt, 10, 10) == 123456789); 3462 3463 bpfjit_free_code(code); 3464 } 3465 3466 ATF_TC(bpfjit_examples_1); 3467 ATF_TC_HEAD(bpfjit_examples_1, tc) 3468 { 3469 atf_tc_set_md_var(tc, "descr", 3470 "Test the first example from bpf(4) - " 3471 "accept Reverse ARP requests"); 3472 } 3473 3474 ATF_TC_BODY(bpfjit_examples_1, tc) 3475 { 3476 /* 3477 * The following filter is taken from the Reverse ARP 3478 * Daemon. It accepts only Reverse ARP requests. 3479 */ 3480 struct bpf_insn insns[] = { 3481 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3482 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8035, 0, 3), 3483 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 3484 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 0, 1), 3485 BPF_STMT(BPF_RET+BPF_K, 42), 3486 BPF_STMT(BPF_RET+BPF_K, 0), 3487 }; 3488 3489 bpfjit_func_t code; 3490 uint8_t pkt[22] = {}; 3491 3492 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3493 3494 ATF_CHECK(bpf_validate(insns, insn_count)); 3495 3496 code = bpfjit_generate_code(NULL, insns, insn_count); 3497 ATF_REQUIRE(code != NULL); 3498 3499 /* Packet is too short. */ 3500 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3501 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3502 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3503 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3504 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3505 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3506 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3507 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3508 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3509 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3510 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3511 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3512 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3513 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3514 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3515 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3516 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3517 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3518 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3519 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3520 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3521 3522 /* The packet doesn't match. */ 3523 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3524 3525 /* Still no match after setting the protocol field. */ 3526 pkt[12] = 0x80; pkt[13] = 0x35; 3527 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3528 3529 /* Set RARP message type. */ 3530 pkt[21] = 3; 3531 ATF_CHECK(jitcall(code, pkt, 22, 22) == 42); 3532 3533 /* Packet is too short. */ 3534 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3535 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3536 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3537 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3538 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3539 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3540 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3541 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3542 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3543 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3544 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3545 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3546 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3547 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3548 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3549 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3550 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3551 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3552 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3553 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3554 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3555 3556 /* Change RARP message type. */ 3557 pkt[20] = 3; 3558 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3559 3560 bpfjit_free_code(code); 3561 } 3562 3563 ATF_TC(bpfjit_examples_2); 3564 ATF_TC_HEAD(bpfjit_examples_2, tc) 3565 { 3566 atf_tc_set_md_var(tc, "descr", 3567 "Test the second example from bpf(4) - " 3568 "accept IP packets between two specified hosts"); 3569 } 3570 3571 ATF_TC_BODY(bpfjit_examples_2, tc) 3572 { 3573 /* 3574 * This filter accepts only IP packets between host 128.3.112.15 3575 * and 128.3.112.35. 3576 */ 3577 static struct bpf_insn insns[] = { 3578 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3579 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 8), 3580 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3581 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3582 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3583 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3584 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3585 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3586 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3587 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3588 BPF_STMT(BPF_RET+BPF_K, 0), 3589 }; 3590 3591 bpfjit_func_t code; 3592 uint8_t pkt[34] = {}; 3593 3594 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3595 3596 ATF_CHECK(bpf_validate(insns, insn_count)); 3597 3598 code = bpfjit_generate_code(NULL, insns, insn_count); 3599 ATF_REQUIRE(code != NULL); 3600 3601 /* Packet is too short. */ 3602 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3603 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3604 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3605 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3606 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3607 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3608 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3609 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3610 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3611 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3612 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3613 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3614 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3615 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3616 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3617 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3618 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3619 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3620 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3621 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3622 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3623 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3624 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 3625 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 3626 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 3627 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 3628 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 3629 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 3630 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 3631 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3632 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 3633 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 3634 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 3635 3636 /* The packet doesn't match. */ 3637 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 3638 3639 /* Still no match after setting the protocol field. */ 3640 pkt[12] = 8; 3641 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 3642 3643 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 15; 3644 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 3645 3646 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 35; 3647 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 3648 3649 /* Swap the ip addresses. */ 3650 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 35; 3651 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 3652 3653 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 15; 3654 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 3655 3656 /* Packet is too short. */ 3657 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3658 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3659 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3660 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3661 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3662 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3663 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3664 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3665 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3666 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3667 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3668 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3669 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3670 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3671 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3672 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3673 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3674 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3675 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3676 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3677 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3678 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3679 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 3680 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 3681 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 3682 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 3683 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 3684 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 3685 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 3686 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3687 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 3688 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 3689 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 3690 3691 /* Change the protocol field. */ 3692 pkt[13] = 8; 3693 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 3694 3695 bpfjit_free_code(code); 3696 } 3697 3698 ATF_TC(bpfjit_examples_3); 3699 ATF_TC_HEAD(bpfjit_examples_3, tc) 3700 { 3701 atf_tc_set_md_var(tc, "descr", 3702 "Test the third example from bpf(4) - " 3703 "accept TCP finger packets"); 3704 } 3705 3706 ATF_TC_BODY(bpfjit_examples_3, tc) 3707 { 3708 /* 3709 * This filter returns only TCP finger packets. 3710 */ 3711 struct bpf_insn insns[] = { 3712 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3713 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 10), 3714 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 23), 3715 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 0, 8), 3716 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 3717 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 0x1fff, 6, 0), 3718 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 14), 3719 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 14), 3720 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 2, 0), 3721 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 16), 3722 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 0, 1), 3723 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3724 BPF_STMT(BPF_RET+BPF_K, 0), 3725 }; 3726 3727 bpfjit_func_t code; 3728 uint8_t pkt[30] = {}; 3729 3730 /* Set IP fragment offset to non-zero. */ 3731 pkt[20] = 1; pkt[21] = 1; 3732 3733 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3734 3735 ATF_CHECK(bpf_validate(insns, insn_count)); 3736 3737 code = bpfjit_generate_code(NULL, insns, insn_count); 3738 ATF_REQUIRE(code != NULL); 3739 3740 /* Packet is too short. */ 3741 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3742 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3743 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3744 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3745 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3746 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3747 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3748 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3749 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3750 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3751 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3752 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3753 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3754 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3755 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3756 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3757 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3758 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3759 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3760 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3761 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3762 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3763 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 3764 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 3765 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 3766 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 3767 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 3768 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 3769 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 3770 3771 /* The packet doesn't match. */ 3772 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3773 3774 /* Still no match after setting the protocol field. */ 3775 pkt[12] = 8; 3776 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3777 3778 /* Get one step closer to the match. */ 3779 pkt[23] = 6; 3780 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3781 3782 /* Set IP fragment offset to zero. */ 3783 pkt[20] = 0x20; pkt[21] = 0; 3784 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3785 3786 /* Set IP header length to 12. */ 3787 pkt[14] = 0xd3; 3788 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3789 3790 /* Match one branch of the program. */ 3791 pkt[27] = 79; 3792 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 3793 3794 /* Match the other branch of the program. */ 3795 pkt[29] = 79; pkt[27] = 0; 3796 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 3797 3798 /* Packet is too short. */ 3799 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3800 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3801 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 3802 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 3803 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 3804 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 3805 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 3806 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 3807 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 3808 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 3809 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 3810 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 3811 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 3812 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 3813 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 3814 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 3815 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 3816 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 3817 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 3818 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 3819 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 3820 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 3821 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 3822 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 3823 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 3824 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 3825 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 3826 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 3827 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 3828 3829 /* Set IP header length to 16. Packet is too short. */ 3830 pkt[14] = 4; 3831 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 3832 3833 bpfjit_free_code(code); 3834 } 3835 3836 ATF_TC(bpfjit_cop_no_ctx); 3837 ATF_TC_HEAD(bpfjit_cop_no_ctx, tc) 3838 { 3839 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COP " 3840 "instruction can't be accepted without a context"); 3841 } 3842 3843 ATF_TC_BODY(bpfjit_cop_no_ctx, tc) 3844 { 3845 static struct bpf_insn insns[] = { 3846 BPF_STMT(BPF_MISC+BPF_COP, 0), 3847 BPF_STMT(BPF_RET+BPF_K, 7) 3848 }; 3849 3850 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3851 3852 ATF_CHECK(!bpf_validate(insns, insn_count)); 3853 3854 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 3855 } 3856 3857 ATF_TC(bpfjit_copx_no_ctx); 3858 ATF_TC_HEAD(bpfjit_copx_no_ctx, tc) 3859 { 3860 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COPX " 3861 "instruction can't be accepted without a context"); 3862 } 3863 3864 ATF_TC_BODY(bpfjit_copx_no_ctx, tc) 3865 { 3866 static struct bpf_insn insns[] = { 3867 BPF_STMT(BPF_MISC+BPF_COPX, 0), 3868 BPF_STMT(BPF_RET+BPF_K, 7) 3869 }; 3870 3871 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3872 3873 ATF_CHECK(!bpf_validate(insns, insn_count)); 3874 3875 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 3876 } 3877 3878 ATF_TP_ADD_TCS(tp) 3879 { 3880 3881 ATF_TP_ADD_TC(tp, bpfjit_empty); 3882 ATF_TP_ADD_TC(tp, bpfjit_alu_add_k); 3883 ATF_TP_ADD_TC(tp, bpfjit_alu_sub_k); 3884 ATF_TP_ADD_TC(tp, bpfjit_alu_mul_k); 3885 ATF_TP_ADD_TC(tp, bpfjit_alu_div0_k); 3886 ATF_TP_ADD_TC(tp, bpfjit_alu_div1_k); 3887 ATF_TP_ADD_TC(tp, bpfjit_alu_div2_k); 3888 ATF_TP_ADD_TC(tp, bpfjit_alu_div4_k); 3889 ATF_TP_ADD_TC(tp, bpfjit_alu_div10_k); 3890 ATF_TP_ADD_TC(tp, bpfjit_alu_div10000_k); 3891 ATF_TP_ADD_TC(tp, bpfjit_alu_div7609801_k); 3892 ATF_TP_ADD_TC(tp, bpfjit_alu_div80000000_k); 3893 ATF_TP_ADD_TC(tp, bpfjit_alu_and_k); 3894 ATF_TP_ADD_TC(tp, bpfjit_alu_or_k); 3895 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh_k); 3896 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh0_k); 3897 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh_k); 3898 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh0_k); 3899 ATF_TP_ADD_TC(tp, bpfjit_alu_modulo_k); 3900 ATF_TP_ADD_TC(tp, bpfjit_alu_add_x); 3901 ATF_TP_ADD_TC(tp, bpfjit_alu_sub_x); 3902 ATF_TP_ADD_TC(tp, bpfjit_alu_mul_x); 3903 ATF_TP_ADD_TC(tp, bpfjit_alu_div0_x); 3904 ATF_TP_ADD_TC(tp, bpfjit_alu_div1_x); 3905 ATF_TP_ADD_TC(tp, bpfjit_alu_div2_x); 3906 ATF_TP_ADD_TC(tp, bpfjit_alu_div4_x); 3907 ATF_TP_ADD_TC(tp, bpfjit_alu_div10_x); 3908 ATF_TP_ADD_TC(tp, bpfjit_alu_div10000_x); 3909 ATF_TP_ADD_TC(tp, bpfjit_alu_div7609801_x); 3910 ATF_TP_ADD_TC(tp, bpfjit_alu_div80000000_x); 3911 ATF_TP_ADD_TC(tp, bpfjit_alu_and_x); 3912 ATF_TP_ADD_TC(tp, bpfjit_alu_or_x); 3913 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh_x); 3914 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh0_x); 3915 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh_x); 3916 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh0_x); 3917 ATF_TP_ADD_TC(tp, bpfjit_alu_modulo_x); 3918 ATF_TP_ADD_TC(tp, bpfjit_alu_neg); 3919 ATF_TP_ADD_TC(tp, bpfjit_jmp_ja); 3920 ATF_TP_ADD_TC(tp, bpfjit_jmp_jgt_k); 3921 ATF_TP_ADD_TC(tp, bpfjit_jmp_jge_k); 3922 ATF_TP_ADD_TC(tp, bpfjit_jmp_jeq_k); 3923 ATF_TP_ADD_TC(tp, bpfjit_jmp_jset_k); 3924 ATF_TP_ADD_TC(tp, bpfjit_jmp_modulo_k); 3925 ATF_TP_ADD_TC(tp, bpfjit_jmp_jgt_x); 3926 ATF_TP_ADD_TC(tp, bpfjit_jmp_jge_x); 3927 ATF_TP_ADD_TC(tp, bpfjit_jmp_jeq_x); 3928 ATF_TP_ADD_TC(tp, bpfjit_jmp_jset_x); 3929 ATF_TP_ADD_TC(tp, bpfjit_jmp_modulo_x); 3930 ATF_TP_ADD_TC(tp, bpfjit_ld_abs); 3931 ATF_TP_ADD_TC(tp, bpfjit_ld_abs_k_overflow); 3932 ATF_TP_ADD_TC(tp, bpfjit_ld_ind); 3933 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_k_overflow); 3934 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_x_overflow1); 3935 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_x_overflow2); 3936 ATF_TP_ADD_TC(tp, bpfjit_ld_len); 3937 ATF_TP_ADD_TC(tp, bpfjit_ld_imm); 3938 ATF_TP_ADD_TC(tp, bpfjit_ldx_imm1); 3939 ATF_TP_ADD_TC(tp, bpfjit_ldx_imm2); 3940 ATF_TP_ADD_TC(tp, bpfjit_ldx_len1); 3941 ATF_TP_ADD_TC(tp, bpfjit_ldx_len2); 3942 ATF_TP_ADD_TC(tp, bpfjit_ldx_msh); 3943 ATF_TP_ADD_TC(tp, bpfjit_misc_tax); 3944 ATF_TP_ADD_TC(tp, bpfjit_misc_txa); 3945 ATF_TP_ADD_TC(tp, bpfjit_st1); 3946 ATF_TP_ADD_TC(tp, bpfjit_st2); 3947 ATF_TP_ADD_TC(tp, bpfjit_st3); 3948 ATF_TP_ADD_TC(tp, bpfjit_st4); 3949 ATF_TP_ADD_TC(tp, bpfjit_st5); 3950 ATF_TP_ADD_TC(tp, bpfjit_stx1); 3951 ATF_TP_ADD_TC(tp, bpfjit_stx2); 3952 ATF_TP_ADD_TC(tp, bpfjit_stx3); 3953 ATF_TP_ADD_TC(tp, bpfjit_stx4); 3954 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_1); 3955 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_2); 3956 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_3); 3957 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_1); 3958 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_2); 3959 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_3); 3960 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_4); 3961 ATF_TP_ADD_TC(tp, bpfjit_abc_ja); 3962 ATF_TP_ADD_TC(tp, bpfjit_abc_ja_over); 3963 ATF_TP_ADD_TC(tp, bpfjit_abc_ld_chain); 3964 ATF_TP_ADD_TC(tp, bpfjit_examples_1); 3965 ATF_TP_ADD_TC(tp, bpfjit_examples_2); 3966 ATF_TP_ADD_TC(tp, bpfjit_examples_3); 3967 ATF_TP_ADD_TC(tp, bpfjit_cop_no_ctx); 3968 ATF_TP_ADD_TC(tp, bpfjit_copx_no_ctx); 3969 3970 return atf_no_error(); 3971 } 3972