t_bpfjit.c revision 1.11
1 /* $NetBSD: t_bpfjit.c,v 1.11 2015/02/11 23:33:16 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.11 2015/02/11 23:33:16 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(libbpfjit_empty); 60 ATF_TC_HEAD(libbpfjit_empty, tc) 61 { 62 atf_tc_set_md_var(tc, "descr", 63 "Test that JIT compilation of an empty bpf program fails"); 64 } 65 66 ATF_TC_BODY(libbpfjit_empty, tc) 67 { 68 struct bpf_insn dummy; 69 70 ATF_CHECK(!bpf_validate(&dummy, 0)); 71 ATF_CHECK(bpfjit_generate_code(NULL, &dummy, 0) == NULL); 72 } 73 74 ATF_TC(libbpfjit_ret_k); 75 ATF_TC_HEAD(libbpfjit_ret_k, tc) 76 { 77 atf_tc_set_md_var(tc, "descr", 78 "Test JIT compilation of a trivial bpf program"); 79 } 80 81 ATF_TC_BODY(libbpfjit_ret_k, tc) 82 { 83 static struct bpf_insn insns[] = { 84 BPF_STMT(BPF_RET+BPF_K, 17) 85 }; 86 87 bpfjit_func_t code; 88 uint8_t pkt[1]; /* the program doesn't read any data */ 89 90 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 91 92 ATF_CHECK(bpf_validate(insns, insn_count)); 93 94 code = bpfjit_generate_code(NULL, insns, insn_count); 95 ATF_REQUIRE(code != NULL); 96 97 ATF_CHECK(jitcall(code, pkt, 1, 1) == 17); 98 99 bpfjit_free_code(code); 100 } 101 102 ATF_TC(libbpfjit_bad_ret_k); 103 ATF_TC_HEAD(libbpfjit_bad_ret_k, tc) 104 { 105 atf_tc_set_md_var(tc, "descr", 106 "Test that JIT compilation of a program with bad BPF_RET fails"); 107 } 108 109 ATF_TC_BODY(libbpfjit_bad_ret_k, tc) 110 { 111 static struct bpf_insn insns[] = { 112 BPF_STMT(BPF_RET+BPF_K+0x8000, 13) 113 }; 114 115 bpfjit_func_t code; 116 uint8_t pkt[1]; /* the program doesn't read any data */ 117 118 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 119 120 /* 121 * The point of this test is checking a bad instruction of 122 * a valid class and with a valid BPF_RVAL data. 123 */ 124 const uint16_t rcode = insns[0].code; 125 ATF_CHECK(BPF_CLASS(rcode) == BPF_RET && 126 (BPF_RVAL(rcode) == BPF_K || BPF_RVAL(rcode) == BPF_A)); 127 128 ATF_CHECK(!bpf_validate(insns, insn_count)); 129 130 /* Current implementation generates code. */ 131 code = bpfjit_generate_code(NULL, insns, insn_count); 132 ATF_REQUIRE(code != NULL); 133 134 ATF_CHECK(jitcall(code, pkt, 1, 1) == 13); 135 136 bpfjit_free_code(code); 137 } 138 139 ATF_TC(libbpfjit_alu_add_k); 140 ATF_TC_HEAD(libbpfjit_alu_add_k, tc) 141 { 142 atf_tc_set_md_var(tc, "descr", 143 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_K"); 144 } 145 146 ATF_TC_BODY(libbpfjit_alu_add_k, tc) 147 { 148 static struct bpf_insn insns[] = { 149 BPF_STMT(BPF_LD+BPF_IMM, 3), 150 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 2), 151 BPF_STMT(BPF_RET+BPF_A, 0) 152 }; 153 154 bpfjit_func_t code; 155 uint8_t pkt[1]; /* the program doesn't read any data */ 156 157 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 158 159 ATF_CHECK(bpf_validate(insns, insn_count)); 160 161 code = bpfjit_generate_code(NULL, insns, insn_count); 162 ATF_REQUIRE(code != NULL); 163 164 ATF_CHECK(jitcall(code, pkt, 1, 1) == 5); 165 166 bpfjit_free_code(code); 167 } 168 169 ATF_TC(libbpfjit_alu_sub_k); 170 ATF_TC_HEAD(libbpfjit_alu_sub_k, tc) 171 { 172 atf_tc_set_md_var(tc, "descr", 173 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_K"); 174 } 175 176 ATF_TC_BODY(libbpfjit_alu_sub_k, tc) 177 { 178 static struct bpf_insn insns[] = { 179 BPF_STMT(BPF_LD+BPF_IMM, 1), 180 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, 2), 181 BPF_STMT(BPF_RET+BPF_A, 0) 182 }; 183 184 bpfjit_func_t code; 185 uint8_t pkt[1]; /* the program doesn't read any data */ 186 187 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 188 189 ATF_CHECK(bpf_validate(insns, insn_count)); 190 191 code = bpfjit_generate_code(NULL, insns, insn_count); 192 ATF_REQUIRE(code != NULL); 193 194 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 195 196 bpfjit_free_code(code); 197 } 198 199 ATF_TC(libbpfjit_alu_mul_k); 200 ATF_TC_HEAD(libbpfjit_alu_mul_k, tc) 201 { 202 atf_tc_set_md_var(tc, "descr", 203 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_K"); 204 } 205 206 ATF_TC_BODY(libbpfjit_alu_mul_k, tc) 207 { 208 static struct bpf_insn insns[] = { 209 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 210 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, 3), 211 BPF_STMT(BPF_RET+BPF_A, 0) 212 }; 213 214 bpfjit_func_t code; 215 uint8_t pkt[1]; /* the program doesn't read any data */ 216 217 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 218 219 ATF_CHECK(bpf_validate(insns, insn_count)); 220 221 code = bpfjit_generate_code(NULL, insns, insn_count); 222 ATF_REQUIRE(code != NULL); 223 224 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd)); 225 226 bpfjit_free_code(code); 227 } 228 229 ATF_TC(libbpfjit_alu_div0_k); 230 ATF_TC_HEAD(libbpfjit_alu_div0_k, tc) 231 { 232 atf_tc_set_md_var(tc, "descr", 233 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0"); 234 } 235 236 ATF_TC_BODY(libbpfjit_alu_div0_k, tc) 237 { 238 static struct bpf_insn insns[] = { 239 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 0), 240 BPF_STMT(BPF_RET+BPF_A, 0) 241 }; 242 243 bpfjit_func_t code; 244 uint8_t pkt[1]; /* the program doesn't read any data */ 245 246 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 247 248 //ATF_CHECK(bpf_validate(insns, insn_count)); 249 250 code = bpfjit_generate_code(NULL, insns, insn_count); 251 ATF_REQUIRE(code != NULL); 252 253 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 254 255 bpfjit_free_code(code); 256 } 257 258 ATF_TC(libbpfjit_alu_div1_k); 259 ATF_TC_HEAD(libbpfjit_alu_div1_k, tc) 260 { 261 atf_tc_set_md_var(tc, "descr", 262 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=1"); 263 } 264 265 ATF_TC_BODY(libbpfjit_alu_div1_k, tc) 266 { 267 static struct bpf_insn insns[] = { 268 BPF_STMT(BPF_LD+BPF_IMM, 7), 269 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 1), 270 BPF_STMT(BPF_RET+BPF_A, 0) 271 }; 272 273 bpfjit_func_t code; 274 uint8_t pkt[1]; /* the program doesn't read any data */ 275 276 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 277 278 ATF_CHECK(bpf_validate(insns, insn_count)); 279 280 code = bpfjit_generate_code(NULL, insns, insn_count); 281 ATF_REQUIRE(code != NULL); 282 283 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 284 285 bpfjit_free_code(code); 286 } 287 288 ATF_TC(libbpfjit_alu_div2_k); 289 ATF_TC_HEAD(libbpfjit_alu_div2_k, tc) 290 { 291 atf_tc_set_md_var(tc, "descr", 292 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=2"); 293 } 294 295 ATF_TC_BODY(libbpfjit_alu_div2_k, tc) 296 { 297 static struct bpf_insn insns[] = { 298 BPF_STMT(BPF_LD+BPF_IMM, 7), 299 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 2), 300 BPF_STMT(BPF_RET+BPF_A, 0) 301 }; 302 303 bpfjit_func_t code; 304 uint8_t pkt[1]; /* the program doesn't read any data */ 305 306 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 307 308 ATF_CHECK(bpf_validate(insns, insn_count)); 309 310 code = bpfjit_generate_code(NULL, insns, insn_count); 311 ATF_REQUIRE(code != NULL); 312 313 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 314 315 bpfjit_free_code(code); 316 } 317 318 ATF_TC(libbpfjit_alu_div4_k); 319 ATF_TC_HEAD(libbpfjit_alu_div4_k, tc) 320 { 321 atf_tc_set_md_var(tc, "descr", 322 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=4"); 323 } 324 325 ATF_TC_BODY(libbpfjit_alu_div4_k, tc) 326 { 327 static struct bpf_insn insns[] = { 328 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 329 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), 330 BPF_STMT(BPF_RET+BPF_A, 0) 331 }; 332 333 bpfjit_func_t code; 334 uint8_t pkt[1]; /* the program doesn't read any data */ 335 336 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 337 338 ATF_CHECK(bpf_validate(insns, insn_count)); 339 340 code = bpfjit_generate_code(NULL, insns, insn_count); 341 ATF_REQUIRE(code != NULL); 342 343 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff)); 344 345 bpfjit_free_code(code); 346 } 347 348 ATF_TC(libbpfjit_alu_div10_k); 349 ATF_TC_HEAD(libbpfjit_alu_div10_k, tc) 350 { 351 atf_tc_set_md_var(tc, "descr", 352 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10"); 353 } 354 355 ATF_TC_BODY(libbpfjit_alu_div10_k, tc) 356 { 357 static struct bpf_insn insns[] = { 358 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 359 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10), 360 BPF_STMT(BPF_RET+BPF_A, 0) 361 }; 362 363 bpfjit_func_t code; 364 uint8_t pkt[1]; /* the program doesn't read any data */ 365 366 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 367 368 ATF_CHECK(bpf_validate(insns, insn_count)); 369 370 code = bpfjit_generate_code(NULL, insns, insn_count); 371 ATF_REQUIRE(code != NULL); 372 373 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384)); 374 375 bpfjit_free_code(code); 376 } 377 378 ATF_TC(libbpfjit_alu_div10000_k); 379 ATF_TC_HEAD(libbpfjit_alu_div10000_k, tc) 380 { 381 atf_tc_set_md_var(tc, "descr", 382 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10000"); 383 } 384 385 ATF_TC_BODY(libbpfjit_alu_div10000_k, tc) 386 { 387 static struct bpf_insn insns[] = { 388 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 389 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10000), 390 BPF_STMT(BPF_RET+BPF_A, 0) 391 }; 392 393 bpfjit_func_t code; 394 uint8_t pkt[1]; /* the program doesn't read any data */ 395 396 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 397 398 ATF_CHECK(bpf_validate(insns, insn_count)); 399 400 code = bpfjit_generate_code(NULL, insns, insn_count); 401 ATF_REQUIRE(code != NULL); 402 403 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484)); 404 405 bpfjit_free_code(code); 406 } 407 408 ATF_TC(libbpfjit_alu_div7609801_k); 409 ATF_TC_HEAD(libbpfjit_alu_div7609801_k, tc) 410 { 411 atf_tc_set_md_var(tc, "descr", 412 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=7609801"); 413 } 414 415 ATF_TC_BODY(libbpfjit_alu_div7609801_k, tc) 416 { 417 static struct bpf_insn insns[] = { 418 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 419 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(7609801)), 420 BPF_STMT(BPF_RET+BPF_A, 0) 421 }; 422 423 bpfjit_func_t code; 424 uint8_t pkt[1]; /* the program doesn't read any data */ 425 426 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 427 428 ATF_CHECK(bpf_validate(insns, insn_count)); 429 430 code = bpfjit_generate_code(NULL, insns, insn_count); 431 ATF_REQUIRE(code != NULL); 432 433 ATF_CHECK(jitcall(code, pkt, 1, 1) == 564); 434 435 bpfjit_free_code(code); 436 } 437 438 ATF_TC(libbpfjit_alu_div80000000_k); 439 ATF_TC_HEAD(libbpfjit_alu_div80000000_k, tc) 440 { 441 atf_tc_set_md_var(tc, "descr", 442 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0x80000000"); 443 } 444 445 ATF_TC_BODY(libbpfjit_alu_div80000000_k, tc) 446 { 447 static struct bpf_insn insns[] = { 448 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 449 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0x80000000)), 450 BPF_STMT(BPF_RET+BPF_A, 0) 451 }; 452 453 bpfjit_func_t code; 454 uint8_t pkt[1]; /* the program doesn't read any data */ 455 456 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 457 458 ATF_CHECK(bpf_validate(insns, insn_count)); 459 460 code = bpfjit_generate_code(NULL, insns, insn_count); 461 ATF_REQUIRE(code != NULL); 462 463 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 464 465 bpfjit_free_code(code); 466 } 467 468 ATF_TC(libbpfjit_alu_mod0_k); 469 ATF_TC_HEAD(libbpfjit_alu_mod0_k, tc) 470 { 471 atf_tc_set_md_var(tc, "descr", 472 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=0"); 473 } 474 475 ATF_TC_BODY(libbpfjit_alu_mod0_k, tc) 476 { 477 static struct bpf_insn insns[] = { 478 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 0), 479 BPF_STMT(BPF_RET+BPF_A, 0) 480 }; 481 482 bpfjit_func_t code; 483 uint8_t pkt[1]; /* the program doesn't read any data */ 484 485 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 486 487 //ATF_CHECK(bpf_validate(insns, insn_count)); 488 489 code = bpfjit_generate_code(NULL, insns, insn_count); 490 ATF_REQUIRE(code != NULL); 491 492 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 493 494 bpfjit_free_code(code); 495 } 496 497 ATF_TC(libbpfjit_alu_mod1_k); 498 ATF_TC_HEAD(libbpfjit_alu_mod1_k, tc) 499 { 500 atf_tc_set_md_var(tc, "descr", 501 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=1"); 502 } 503 504 ATF_TC_BODY(libbpfjit_alu_mod1_k, tc) 505 { 506 static struct bpf_insn insns[] = { 507 BPF_STMT(BPF_LD+BPF_IMM, 7), 508 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 1), 509 BPF_STMT(BPF_RET+BPF_A, 0) 510 }; 511 512 bpfjit_func_t code; 513 uint8_t pkt[1]; /* the program doesn't read any data */ 514 515 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 516 517 ATF_CHECK(bpf_validate(insns, insn_count)); 518 519 code = bpfjit_generate_code(NULL, insns, insn_count); 520 ATF_REQUIRE(code != NULL); 521 522 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 523 524 bpfjit_free_code(code); 525 } 526 527 ATF_TC(libbpfjit_alu_mod2_k); 528 ATF_TC_HEAD(libbpfjit_alu_mod2_k, tc) 529 { 530 atf_tc_set_md_var(tc, "descr", 531 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=2"); 532 } 533 534 ATF_TC_BODY(libbpfjit_alu_mod2_k, tc) 535 { 536 static struct bpf_insn insns[] = { 537 BPF_STMT(BPF_LD+BPF_IMM, 7), 538 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 2), 539 BPF_STMT(BPF_RET+BPF_A, 0) 540 }; 541 542 bpfjit_func_t code; 543 uint8_t pkt[1]; /* the program doesn't read any data */ 544 545 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 546 547 ATF_CHECK(bpf_validate(insns, insn_count)); 548 549 code = bpfjit_generate_code(NULL, insns, insn_count); 550 ATF_REQUIRE(code != NULL); 551 552 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 553 554 bpfjit_free_code(code); 555 } 556 557 ATF_TC(libbpfjit_alu_mod4_k); 558 ATF_TC_HEAD(libbpfjit_alu_mod4_k, tc) 559 { 560 atf_tc_set_md_var(tc, "descr", 561 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=4"); 562 } 563 564 ATF_TC_BODY(libbpfjit_alu_mod4_k, tc) 565 { 566 static struct bpf_insn insns[] = { 567 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 568 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 4), 569 BPF_STMT(BPF_RET+BPF_A, 0) 570 }; 571 572 bpfjit_func_t code; 573 uint8_t pkt[1]; /* the program doesn't read any data */ 574 575 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 576 577 ATF_CHECK(bpf_validate(insns, insn_count)); 578 579 code = bpfjit_generate_code(NULL, insns, insn_count); 580 ATF_REQUIRE(code != NULL); 581 582 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 583 584 bpfjit_free_code(code); 585 } 586 587 ATF_TC(libbpfjit_alu_mod10_k); 588 ATF_TC_HEAD(libbpfjit_alu_mod10_k, tc) 589 { 590 atf_tc_set_md_var(tc, "descr", 591 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=10"); 592 } 593 594 ATF_TC_BODY(libbpfjit_alu_mod10_k, tc) 595 { 596 static struct bpf_insn insns[] = { 597 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 598 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 10), 599 BPF_STMT(BPF_RET+BPF_A, 0) 600 }; 601 602 bpfjit_func_t code; 603 uint8_t pkt[1]; /* the program doesn't read any data */ 604 605 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 606 607 ATF_CHECK(bpf_validate(insns, insn_count)); 608 609 code = bpfjit_generate_code(NULL, insns, insn_count); 610 ATF_REQUIRE(code != NULL); 611 612 ATF_CHECK(jitcall(code, pkt, 1, 1) == 9); 613 614 bpfjit_free_code(code); 615 } 616 617 ATF_TC(libbpfjit_alu_mod10000_k); 618 ATF_TC_HEAD(libbpfjit_alu_mod10000_k, tc) 619 { 620 atf_tc_set_md_var(tc, "descr", 621 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=10000"); 622 } 623 624 ATF_TC_BODY(libbpfjit_alu_mod10000_k, tc) 625 { 626 static struct bpf_insn insns[] = { 627 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 628 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, 10000), 629 BPF_STMT(BPF_RET+BPF_A, 0) 630 }; 631 632 bpfjit_func_t code; 633 uint8_t pkt[1]; /* the program doesn't read any data */ 634 635 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 636 637 ATF_CHECK(bpf_validate(insns, insn_count)); 638 639 code = bpfjit_generate_code(NULL, insns, insn_count); 640 ATF_REQUIRE(code != NULL); 641 642 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3849); 643 644 bpfjit_free_code(code); 645 } 646 647 ATF_TC(libbpfjit_alu_mod7609801_k); 648 ATF_TC_HEAD(libbpfjit_alu_mod7609801_k, tc) 649 { 650 atf_tc_set_md_var(tc, "descr", 651 "Test JIT compilation of BPF_ALU+BPF_mod+BPF_K with k=7609801"); 652 } 653 654 ATF_TC_BODY(libbpfjit_alu_mod7609801_k, tc) 655 { 656 static struct bpf_insn insns[] = { 657 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 658 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, UINT32_C(7609801)), 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) == UINT32_C(3039531)); 673 674 bpfjit_free_code(code); 675 } 676 677 ATF_TC(libbpfjit_alu_mod80000000_k); 678 ATF_TC_HEAD(libbpfjit_alu_mod80000000_k, tc) 679 { 680 atf_tc_set_md_var(tc, "descr", 681 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_K with k=0x80000000"); 682 } 683 684 ATF_TC_BODY(libbpfjit_alu_mod80000000_k, tc) 685 { 686 static struct bpf_insn insns[] = { 687 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 688 BPF_STMT(BPF_ALU+BPF_MOD+BPF_K, UINT32_C(0x80000000)), 689 BPF_STMT(BPF_RET+BPF_A, 0) 690 }; 691 692 bpfjit_func_t code; 693 uint8_t pkt[1]; /* the program doesn't read any data */ 694 695 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 696 697 ATF_CHECK(bpf_validate(insns, insn_count)); 698 699 code = bpfjit_generate_code(NULL, insns, insn_count); 700 ATF_REQUIRE(code != NULL); 701 702 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x7fffffde)); 703 704 bpfjit_free_code(code); 705 } 706 707 ATF_TC(libbpfjit_alu_and_k); 708 ATF_TC_HEAD(libbpfjit_alu_and_k, tc) 709 { 710 atf_tc_set_md_var(tc, "descr", 711 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_K"); 712 } 713 714 ATF_TC_BODY(libbpfjit_alu_and_k, tc) 715 { 716 static struct bpf_insn insns[] = { 717 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 718 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xbeef), 719 BPF_STMT(BPF_RET+BPF_A, 0) 720 }; 721 722 bpfjit_func_t code; 723 uint8_t pkt[1]; /* the program doesn't read any data */ 724 725 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 726 727 ATF_CHECK(bpf_validate(insns, insn_count)); 728 729 code = bpfjit_generate_code(NULL, insns, insn_count); 730 ATF_REQUIRE(code != NULL); 731 732 ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef)); 733 734 bpfjit_free_code(code); 735 } 736 737 ATF_TC(libbpfjit_alu_or_k); 738 ATF_TC_HEAD(libbpfjit_alu_or_k, tc) 739 { 740 atf_tc_set_md_var(tc, "descr", 741 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_K"); 742 } 743 744 ATF_TC_BODY(libbpfjit_alu_or_k, tc) 745 { 746 static struct bpf_insn insns[] = { 747 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 748 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, 0x0000beef), 749 BPF_STMT(BPF_RET+BPF_A, 0) 750 }; 751 752 bpfjit_func_t code; 753 uint8_t pkt[1]; /* the program doesn't read any data */ 754 755 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 756 757 ATF_CHECK(bpf_validate(insns, insn_count)); 758 759 code = bpfjit_generate_code(NULL, insns, insn_count); 760 ATF_REQUIRE(code != NULL); 761 762 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 763 764 bpfjit_free_code(code); 765 } 766 767 ATF_TC(libbpfjit_alu_xor_k); 768 ATF_TC_HEAD(libbpfjit_alu_xor_k, tc) 769 { 770 atf_tc_set_md_var(tc, "descr", 771 "Test JIT compilation of BPF_ALU+BPF_XOR+BPF_K"); 772 } 773 774 ATF_TC_BODY(libbpfjit_alu_xor_k, tc) 775 { 776 static struct bpf_insn insns[] = { 777 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0f0f), 778 BPF_STMT(BPF_ALU+BPF_XOR+BPF_K, 0x0000b1e0), 779 BPF_STMT(BPF_RET+BPF_A, 0) 780 }; 781 782 bpfjit_func_t code; 783 uint8_t pkt[1]; /* the program doesn't read any data */ 784 785 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 786 787 ATF_CHECK(bpf_validate(insns, insn_count)); 788 789 code = bpfjit_generate_code(NULL, insns, insn_count); 790 ATF_REQUIRE(code != NULL); 791 792 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 793 794 bpfjit_free_code(code); 795 } 796 797 ATF_TC(libbpfjit_alu_lsh_k); 798 ATF_TC_HEAD(libbpfjit_alu_lsh_k, tc) 799 { 800 atf_tc_set_md_var(tc, "descr", 801 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K"); 802 } 803 804 ATF_TC_BODY(libbpfjit_alu_lsh_k, tc) 805 { 806 static struct bpf_insn insns[] = { 807 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 808 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 16), 809 BPF_STMT(BPF_RET+BPF_A, 0) 810 }; 811 812 bpfjit_func_t code; 813 uint8_t pkt[1]; /* the program doesn't read any data */ 814 815 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 816 817 ATF_CHECK(bpf_validate(insns, insn_count)); 818 819 code = bpfjit_generate_code(NULL, insns, insn_count); 820 ATF_REQUIRE(code != NULL); 821 822 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000); 823 824 bpfjit_free_code(code); 825 } 826 827 ATF_TC(libbpfjit_alu_lsh0_k); 828 ATF_TC_HEAD(libbpfjit_alu_lsh0_k, tc) 829 { 830 atf_tc_set_md_var(tc, "descr", 831 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K with k=0"); 832 } 833 834 ATF_TC_BODY(libbpfjit_alu_lsh0_k, tc) 835 { 836 static struct bpf_insn insns[] = { 837 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 838 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 0), 839 BPF_STMT(BPF_RET+BPF_A, 0) 840 }; 841 842 bpfjit_func_t code; 843 uint8_t pkt[1]; /* the program doesn't read any data */ 844 845 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 846 847 ATF_CHECK(bpf_validate(insns, insn_count)); 848 849 code = bpfjit_generate_code(NULL, insns, insn_count); 850 ATF_REQUIRE(code != NULL); 851 852 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 853 854 bpfjit_free_code(code); 855 } 856 857 ATF_TC(libbpfjit_alu_rsh_k); 858 ATF_TC_HEAD(libbpfjit_alu_rsh_k, tc) 859 { 860 atf_tc_set_md_var(tc, "descr", 861 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K"); 862 } 863 864 ATF_TC_BODY(libbpfjit_alu_rsh_k, tc) 865 { 866 static struct bpf_insn insns[] = { 867 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 868 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 16), 869 BPF_STMT(BPF_RET+BPF_A, 0) 870 }; 871 872 bpfjit_func_t code; 873 uint8_t pkt[1]; /* the program doesn't read any data */ 874 875 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 876 877 ATF_CHECK(bpf_validate(insns, insn_count)); 878 879 code = bpfjit_generate_code(NULL, insns, insn_count); 880 ATF_REQUIRE(code != NULL); 881 882 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead); 883 884 bpfjit_free_code(code); 885 } 886 887 ATF_TC(libbpfjit_alu_rsh0_k); 888 ATF_TC_HEAD(libbpfjit_alu_rsh0_k, tc) 889 { 890 atf_tc_set_md_var(tc, "descr", 891 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K with k=0"); 892 } 893 894 ATF_TC_BODY(libbpfjit_alu_rsh0_k, tc) 895 { 896 static struct bpf_insn insns[] = { 897 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 898 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 0), 899 BPF_STMT(BPF_RET+BPF_A, 0) 900 }; 901 902 bpfjit_func_t code; 903 uint8_t pkt[1]; /* the program doesn't read any data */ 904 905 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 906 907 ATF_CHECK(bpf_validate(insns, insn_count)); 908 909 code = bpfjit_generate_code(NULL, insns, insn_count); 910 ATF_REQUIRE(code != NULL); 911 912 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 913 914 bpfjit_free_code(code); 915 } 916 917 ATF_TC(libbpfjit_alu_modulo_k); 918 ATF_TC_HEAD(libbpfjit_alu_modulo_k, tc) 919 { 920 atf_tc_set_md_var(tc, "descr", 921 "Test JIT compilation of modulo logic of BPF_ALU+BPF_K operations"); 922 } 923 924 ATF_TC_BODY(libbpfjit_alu_modulo_k, tc) 925 { 926 static struct bpf_insn insns[] = { 927 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 928 929 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 930 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x0fffff77)), 931 932 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 933 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 1), 934 935 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 936 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xdddddddd)), 937 938 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 939 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, UINT32_C(0xffffffff)), 940 941 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 942 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, UINT32_C(0x0000030c)), 943 944 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 945 BPF_STMT(BPF_ALU+BPF_NEG, 0), 946 947 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 948 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, UINT32_C(0xffffff0f)), 949 950 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 951 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 952 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 3), 953 954 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 955 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x7fffff77)), 956 957 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 958 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 959 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0xdead)), 960 961 BPF_STMT(BPF_RET+BPF_A, 0) 962 }; 963 964 bpfjit_func_t code; 965 uint8_t pkt[1]; /* the program doesn't read any data */ 966 967 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 968 969 ATF_CHECK(bpf_validate(insns, insn_count)); 970 971 code = bpfjit_generate_code(NULL, insns, insn_count); 972 ATF_REQUIRE(code != NULL); 973 974 ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 975 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994)); 976 977 978 bpfjit_free_code(code); 979 } 980 981 ATF_TC(libbpfjit_alu_add_x); 982 ATF_TC_HEAD(libbpfjit_alu_add_x, tc) 983 { 984 atf_tc_set_md_var(tc, "descr", 985 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_X"); 986 } 987 988 ATF_TC_BODY(libbpfjit_alu_add_x, tc) 989 { 990 static struct bpf_insn insns[] = { 991 BPF_STMT(BPF_LD+BPF_IMM, 3), 992 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 993 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 994 BPF_STMT(BPF_RET+BPF_A, 0) 995 }; 996 997 bpfjit_func_t code; 998 uint8_t pkt[1]; /* the program doesn't read any data */ 999 1000 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1001 1002 ATF_CHECK(bpf_validate(insns, insn_count)); 1003 1004 code = bpfjit_generate_code(NULL, insns, insn_count); 1005 ATF_REQUIRE(code != NULL); 1006 1007 ATF_CHECK(jitcall(code, pkt, 1, 1) == 5); 1008 1009 bpfjit_free_code(code); 1010 } 1011 1012 ATF_TC(libbpfjit_alu_sub_x); 1013 ATF_TC_HEAD(libbpfjit_alu_sub_x, tc) 1014 { 1015 atf_tc_set_md_var(tc, "descr", 1016 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_X"); 1017 } 1018 1019 ATF_TC_BODY(libbpfjit_alu_sub_x, tc) 1020 { 1021 static struct bpf_insn insns[] = { 1022 BPF_STMT(BPF_LD+BPF_IMM, 1), 1023 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1024 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 1025 BPF_STMT(BPF_RET+BPF_A, 0) 1026 }; 1027 1028 bpfjit_func_t code; 1029 uint8_t pkt[1]; /* the program doesn't read any data */ 1030 1031 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1032 1033 ATF_CHECK(bpf_validate(insns, insn_count)); 1034 1035 code = bpfjit_generate_code(NULL, insns, insn_count); 1036 ATF_REQUIRE(code != NULL); 1037 1038 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 1039 1040 bpfjit_free_code(code); 1041 } 1042 1043 ATF_TC(libbpfjit_alu_mul_x); 1044 ATF_TC_HEAD(libbpfjit_alu_mul_x, tc) 1045 { 1046 atf_tc_set_md_var(tc, "descr", 1047 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_X"); 1048 } 1049 1050 ATF_TC_BODY(libbpfjit_alu_mul_x, tc) 1051 { 1052 static struct bpf_insn insns[] = { 1053 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 1054 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 1055 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1056 BPF_STMT(BPF_RET+BPF_A, 0) 1057 }; 1058 1059 bpfjit_func_t code; 1060 uint8_t pkt[1]; /* the program doesn't read any data */ 1061 1062 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1063 1064 ATF_CHECK(bpf_validate(insns, insn_count)); 1065 1066 code = bpfjit_generate_code(NULL, insns, insn_count); 1067 ATF_REQUIRE(code != NULL); 1068 1069 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0xfffffffd)); 1070 1071 bpfjit_free_code(code); 1072 } 1073 1074 ATF_TC(libbpfjit_alu_div0_x); 1075 ATF_TC_HEAD(libbpfjit_alu_div0_x, tc) 1076 { 1077 atf_tc_set_md_var(tc, "descr", 1078 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0"); 1079 } 1080 1081 ATF_TC_BODY(libbpfjit_alu_div0_x, tc) 1082 { 1083 static struct bpf_insn insns[] = { 1084 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1085 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1086 BPF_STMT(BPF_RET+BPF_A, 0) 1087 }; 1088 1089 bpfjit_func_t code; 1090 uint8_t pkt[1]; /* the program doesn't read any data */ 1091 1092 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1093 1094 ATF_CHECK(bpf_validate(insns, insn_count)); 1095 1096 code = bpfjit_generate_code(NULL, insns, insn_count); 1097 ATF_REQUIRE(code != NULL); 1098 1099 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 1100 1101 bpfjit_free_code(code); 1102 } 1103 1104 ATF_TC(libbpfjit_alu_div1_x); 1105 ATF_TC_HEAD(libbpfjit_alu_div1_x, tc) 1106 { 1107 atf_tc_set_md_var(tc, "descr", 1108 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=1"); 1109 } 1110 1111 ATF_TC_BODY(libbpfjit_alu_div1_x, tc) 1112 { 1113 static struct bpf_insn insns[] = { 1114 BPF_STMT(BPF_LD+BPF_IMM, 7), 1115 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1116 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1117 BPF_STMT(BPF_RET+BPF_A, 0) 1118 }; 1119 1120 bpfjit_func_t code; 1121 uint8_t pkt[1]; /* the program doesn't read any data */ 1122 1123 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1124 1125 ATF_CHECK(bpf_validate(insns, insn_count)); 1126 1127 code = bpfjit_generate_code(NULL, insns, insn_count); 1128 ATF_REQUIRE(code != NULL); 1129 1130 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 1131 1132 bpfjit_free_code(code); 1133 } 1134 1135 ATF_TC(libbpfjit_alu_div2_x); 1136 ATF_TC_HEAD(libbpfjit_alu_div2_x, tc) 1137 { 1138 atf_tc_set_md_var(tc, "descr", 1139 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=2"); 1140 } 1141 1142 ATF_TC_BODY(libbpfjit_alu_div2_x, tc) 1143 { 1144 static struct bpf_insn insns[] = { 1145 BPF_STMT(BPF_LD+BPF_IMM, 7), 1146 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1147 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1148 BPF_STMT(BPF_RET+BPF_A, 0) 1149 }; 1150 1151 bpfjit_func_t code; 1152 uint8_t pkt[1]; /* the program doesn't read any data */ 1153 1154 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1155 1156 ATF_CHECK(bpf_validate(insns, insn_count)); 1157 1158 code = bpfjit_generate_code(NULL, insns, insn_count); 1159 ATF_REQUIRE(code != NULL); 1160 1161 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 1162 1163 bpfjit_free_code(code); 1164 } 1165 1166 ATF_TC(libbpfjit_alu_div4_x); 1167 ATF_TC_HEAD(libbpfjit_alu_div4_x, tc) 1168 { 1169 atf_tc_set_md_var(tc, "descr", 1170 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=4"); 1171 } 1172 1173 ATF_TC_BODY(libbpfjit_alu_div4_x, tc) 1174 { 1175 static struct bpf_insn insns[] = { 1176 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 1177 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1178 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1179 BPF_STMT(BPF_RET+BPF_A, 0) 1180 }; 1181 1182 bpfjit_func_t code; 1183 uint8_t pkt[1]; /* the program doesn't read any data */ 1184 1185 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1186 1187 ATF_CHECK(bpf_validate(insns, insn_count)); 1188 1189 code = bpfjit_generate_code(NULL, insns, insn_count); 1190 ATF_REQUIRE(code != NULL); 1191 1192 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x3fffffff)); 1193 1194 bpfjit_free_code(code); 1195 } 1196 1197 ATF_TC(libbpfjit_alu_div10_x); 1198 ATF_TC_HEAD(libbpfjit_alu_div10_x, tc) 1199 { 1200 atf_tc_set_md_var(tc, "descr", 1201 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10"); 1202 } 1203 1204 ATF_TC_BODY(libbpfjit_alu_div10_x, tc) 1205 { 1206 static struct bpf_insn insns[] = { 1207 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 1208 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10), 1209 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1210 BPF_STMT(BPF_RET+BPF_A, 0) 1211 }; 1212 1213 bpfjit_func_t code; 1214 uint8_t pkt[1]; /* the program doesn't read any data */ 1215 1216 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1217 1218 ATF_CHECK(bpf_validate(insns, insn_count)); 1219 1220 code = bpfjit_generate_code(NULL, insns, insn_count); 1221 ATF_REQUIRE(code != NULL); 1222 1223 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484384)); 1224 1225 bpfjit_free_code(code); 1226 } 1227 1228 ATF_TC(libbpfjit_alu_div10000_x); 1229 ATF_TC_HEAD(libbpfjit_alu_div10000_x, tc) 1230 { 1231 atf_tc_set_md_var(tc, "descr", 1232 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10000"); 1233 } 1234 1235 ATF_TC_BODY(libbpfjit_alu_div10000_x, tc) 1236 { 1237 static struct bpf_insn insns[] = { 1238 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 1239 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000), 1240 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1241 BPF_STMT(BPF_RET+BPF_A, 0) 1242 }; 1243 1244 bpfjit_func_t code; 1245 uint8_t pkt[1]; /* the program doesn't read any data */ 1246 1247 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1248 1249 ATF_CHECK(bpf_validate(insns, insn_count)); 1250 1251 code = bpfjit_generate_code(NULL, insns, insn_count); 1252 ATF_REQUIRE(code != NULL); 1253 1254 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(429484)); 1255 1256 bpfjit_free_code(code); 1257 } 1258 1259 ATF_TC(libbpfjit_alu_div7609801_x); 1260 ATF_TC_HEAD(libbpfjit_alu_div7609801_x, tc) 1261 { 1262 atf_tc_set_md_var(tc, "descr", 1263 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=7609801"); 1264 } 1265 1266 ATF_TC_BODY(libbpfjit_alu_div7609801_x, tc) 1267 { 1268 static struct bpf_insn insns[] = { 1269 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 1270 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)), 1271 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1272 BPF_STMT(BPF_RET+BPF_A, 0) 1273 }; 1274 1275 bpfjit_func_t code; 1276 uint8_t pkt[1]; /* the program doesn't read any data */ 1277 1278 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1279 1280 ATF_CHECK(bpf_validate(insns, insn_count)); 1281 1282 code = bpfjit_generate_code(NULL, insns, insn_count); 1283 ATF_REQUIRE(code != NULL); 1284 1285 ATF_CHECK(jitcall(code, pkt, 1, 1) == 564); 1286 1287 bpfjit_free_code(code); 1288 } 1289 1290 ATF_TC(libbpfjit_alu_div80000000_x); 1291 ATF_TC_HEAD(libbpfjit_alu_div80000000_x, tc) 1292 { 1293 atf_tc_set_md_var(tc, "descr", 1294 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0x80000000"); 1295 } 1296 1297 ATF_TC_BODY(libbpfjit_alu_div80000000_x, tc) 1298 { 1299 static struct bpf_insn insns[] = { 1300 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 1301 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)), 1302 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1303 BPF_STMT(BPF_RET+BPF_A, 0) 1304 }; 1305 1306 bpfjit_func_t code; 1307 uint8_t pkt[1]; /* the program doesn't read any data */ 1308 1309 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1310 1311 ATF_CHECK(bpf_validate(insns, insn_count)); 1312 1313 code = bpfjit_generate_code(NULL, insns, insn_count); 1314 ATF_REQUIRE(code != NULL); 1315 1316 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1317 1318 bpfjit_free_code(code); 1319 } 1320 1321 ATF_TC(libbpfjit_alu_mod0_x); 1322 ATF_TC_HEAD(libbpfjit_alu_mod0_x, tc) 1323 { 1324 atf_tc_set_md_var(tc, "descr", 1325 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=0"); 1326 } 1327 1328 ATF_TC_BODY(libbpfjit_alu_mod0_x, tc) 1329 { 1330 static struct bpf_insn insns[] = { 1331 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1332 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1333 BPF_STMT(BPF_RET+BPF_A, 0) 1334 }; 1335 1336 bpfjit_func_t code; 1337 uint8_t pkt[1]; /* the program doesn't read any data */ 1338 1339 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1340 1341 ATF_CHECK(bpf_validate(insns, insn_count)); 1342 1343 code = bpfjit_generate_code(NULL, insns, insn_count); 1344 ATF_REQUIRE(code != NULL); 1345 1346 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 1347 1348 bpfjit_free_code(code); 1349 } 1350 1351 ATF_TC(libbpfjit_alu_mod1_x); 1352 ATF_TC_HEAD(libbpfjit_alu_mod1_x, tc) 1353 { 1354 atf_tc_set_md_var(tc, "descr", 1355 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=1"); 1356 } 1357 1358 ATF_TC_BODY(libbpfjit_alu_mod1_x, tc) 1359 { 1360 static struct bpf_insn insns[] = { 1361 BPF_STMT(BPF_LD+BPF_IMM, 7), 1362 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1363 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1364 BPF_STMT(BPF_RET+BPF_A, 0) 1365 }; 1366 1367 bpfjit_func_t code; 1368 uint8_t pkt[1]; /* the program doesn't read any data */ 1369 1370 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1371 1372 ATF_CHECK(bpf_validate(insns, insn_count)); 1373 1374 code = bpfjit_generate_code(NULL, insns, insn_count); 1375 ATF_REQUIRE(code != NULL); 1376 1377 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 1378 1379 bpfjit_free_code(code); 1380 } 1381 1382 ATF_TC(libbpfjit_alu_mod2_x); 1383 ATF_TC_HEAD(libbpfjit_alu_mod2_x, tc) 1384 { 1385 atf_tc_set_md_var(tc, "descr", 1386 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=2"); 1387 } 1388 1389 ATF_TC_BODY(libbpfjit_alu_mod2_x, tc) 1390 { 1391 static struct bpf_insn insns[] = { 1392 BPF_STMT(BPF_LD+BPF_IMM, 7), 1393 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1394 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1395 BPF_STMT(BPF_RET+BPF_A, 0) 1396 }; 1397 1398 bpfjit_func_t code; 1399 uint8_t pkt[1]; /* the program doesn't read any data */ 1400 1401 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1402 1403 ATF_CHECK(bpf_validate(insns, insn_count)); 1404 1405 code = bpfjit_generate_code(NULL, insns, insn_count); 1406 ATF_REQUIRE(code != NULL); 1407 1408 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 1409 1410 bpfjit_free_code(code); 1411 } 1412 1413 ATF_TC(libbpfjit_alu_mod4_x); 1414 ATF_TC_HEAD(libbpfjit_alu_mod4_x, tc) 1415 { 1416 atf_tc_set_md_var(tc, "descr", 1417 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=4"); 1418 } 1419 1420 ATF_TC_BODY(libbpfjit_alu_mod4_x, tc) 1421 { 1422 static struct bpf_insn insns[] = { 1423 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 1424 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1425 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1426 BPF_STMT(BPF_RET+BPF_A, 0) 1427 }; 1428 1429 bpfjit_func_t code; 1430 uint8_t pkt[1]; /* the program doesn't read any data */ 1431 1432 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1433 1434 ATF_CHECK(bpf_validate(insns, insn_count)); 1435 1436 code = bpfjit_generate_code(NULL, insns, insn_count); 1437 ATF_REQUIRE(code != NULL); 1438 1439 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3); 1440 1441 bpfjit_free_code(code); 1442 } 1443 1444 ATF_TC(libbpfjit_alu_mod10_x); 1445 ATF_TC_HEAD(libbpfjit_alu_mod10_x, tc) 1446 { 1447 atf_tc_set_md_var(tc, "descr", 1448 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=10"); 1449 } 1450 1451 ATF_TC_BODY(libbpfjit_alu_mod10_x, tc) 1452 { 1453 static struct bpf_insn insns[] = { 1454 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 1455 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10), 1456 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1457 BPF_STMT(BPF_RET+BPF_A, 0) 1458 }; 1459 1460 bpfjit_func_t code; 1461 uint8_t pkt[1]; /* the program doesn't read any data */ 1462 1463 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1464 1465 ATF_CHECK(bpf_validate(insns, insn_count)); 1466 1467 code = bpfjit_generate_code(NULL, insns, insn_count); 1468 ATF_REQUIRE(code != NULL); 1469 1470 ATF_CHECK(jitcall(code, pkt, 1, 1) == 9); 1471 1472 bpfjit_free_code(code); 1473 } 1474 1475 ATF_TC(libbpfjit_alu_mod10000_x); 1476 ATF_TC_HEAD(libbpfjit_alu_mod10000_x, tc) 1477 { 1478 atf_tc_set_md_var(tc, "descr", 1479 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=10000"); 1480 } 1481 1482 ATF_TC_BODY(libbpfjit_alu_mod10000_x, tc) 1483 { 1484 static struct bpf_insn insns[] = { 1485 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 1486 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000), 1487 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1488 BPF_STMT(BPF_RET+BPF_A, 0) 1489 }; 1490 1491 bpfjit_func_t code; 1492 uint8_t pkt[1]; /* the program doesn't read any data */ 1493 1494 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1495 1496 ATF_CHECK(bpf_validate(insns, insn_count)); 1497 1498 code = bpfjit_generate_code(NULL, insns, insn_count); 1499 ATF_REQUIRE(code != NULL); 1500 1501 ATF_CHECK(jitcall(code, pkt, 1, 1) == 3849); 1502 1503 bpfjit_free_code(code); 1504 } 1505 1506 ATF_TC(libbpfjit_alu_mod7609801_x); 1507 ATF_TC_HEAD(libbpfjit_alu_mod7609801_x, tc) 1508 { 1509 atf_tc_set_md_var(tc, "descr", 1510 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=7609801"); 1511 } 1512 1513 ATF_TC_BODY(libbpfjit_alu_mod7609801_x, tc) 1514 { 1515 static struct bpf_insn insns[] = { 1516 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 1517 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)), 1518 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1519 BPF_STMT(BPF_RET+BPF_A, 0) 1520 }; 1521 1522 bpfjit_func_t code; 1523 uint8_t pkt[1]; /* the program doesn't read any data */ 1524 1525 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1526 1527 ATF_CHECK(bpf_validate(insns, insn_count)); 1528 1529 code = bpfjit_generate_code(NULL, insns, insn_count); 1530 ATF_REQUIRE(code != NULL); 1531 1532 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(3039531)); 1533 1534 bpfjit_free_code(code); 1535 } 1536 1537 ATF_TC(libbpfjit_alu_mod80000000_x); 1538 ATF_TC_HEAD(libbpfjit_alu_mod80000000_x, tc) 1539 { 1540 atf_tc_set_md_var(tc, "descr", 1541 "Test JIT compilation of BPF_ALU+BPF_MOD+BPF_X with X=0x80000000"); 1542 } 1543 1544 ATF_TC_BODY(libbpfjit_alu_mod80000000_x, tc) 1545 { 1546 static struct bpf_insn insns[] = { 1547 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 1548 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)), 1549 BPF_STMT(BPF_ALU+BPF_MOD+BPF_X, 0), 1550 BPF_STMT(BPF_RET+BPF_A, 0) 1551 }; 1552 1553 bpfjit_func_t code; 1554 uint8_t pkt[1]; /* the program doesn't read any data */ 1555 1556 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1557 1558 ATF_CHECK(bpf_validate(insns, insn_count)); 1559 1560 code = bpfjit_generate_code(NULL, insns, insn_count); 1561 ATF_REQUIRE(code != NULL); 1562 1563 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x7fffffde)); 1564 1565 bpfjit_free_code(code); 1566 } 1567 1568 ATF_TC(libbpfjit_alu_and_x); 1569 ATF_TC_HEAD(libbpfjit_alu_and_x, tc) 1570 { 1571 atf_tc_set_md_var(tc, "descr", 1572 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_X"); 1573 } 1574 1575 ATF_TC_BODY(libbpfjit_alu_and_x, tc) 1576 { 1577 static struct bpf_insn insns[] = { 1578 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 1579 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0xbeef), 1580 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 1581 BPF_STMT(BPF_RET+BPF_A, 0) 1582 }; 1583 1584 bpfjit_func_t code; 1585 uint8_t pkt[1]; /* the program doesn't read any data */ 1586 1587 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1588 1589 ATF_CHECK(bpf_validate(insns, insn_count)); 1590 1591 code = bpfjit_generate_code(NULL, insns, insn_count); 1592 ATF_REQUIRE(code != NULL); 1593 1594 ATF_CHECK(jitcall(code, pkt, 1, 1) == (0xdead&0xbeef)); 1595 1596 bpfjit_free_code(code); 1597 } 1598 1599 ATF_TC(libbpfjit_alu_or_x); 1600 ATF_TC_HEAD(libbpfjit_alu_or_x, tc) 1601 { 1602 atf_tc_set_md_var(tc, "descr", 1603 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_X"); 1604 } 1605 1606 ATF_TC_BODY(libbpfjit_alu_or_x, tc) 1607 { 1608 static struct bpf_insn insns[] = { 1609 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 1610 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0x0000beef), 1611 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1612 BPF_STMT(BPF_RET+BPF_A, 0) 1613 }; 1614 1615 bpfjit_func_t code; 1616 uint8_t pkt[1]; /* the program doesn't read any data */ 1617 1618 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1619 1620 ATF_CHECK(bpf_validate(insns, insn_count)); 1621 1622 code = bpfjit_generate_code(NULL, insns, insn_count); 1623 ATF_REQUIRE(code != NULL); 1624 1625 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1626 1627 bpfjit_free_code(code); 1628 } 1629 1630 ATF_TC(libbpfjit_alu_xor_x); 1631 ATF_TC_HEAD(libbpfjit_alu_xor_x, tc) 1632 { 1633 atf_tc_set_md_var(tc, "descr", 1634 "Test JIT compilation of BPF_ALU+BPF_XOR+BPF_X"); 1635 } 1636 1637 ATF_TC_BODY(libbpfjit_alu_xor_x, tc) 1638 { 1639 static struct bpf_insn insns[] = { 1640 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0f0f), 1641 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0x0000b1e0), 1642 BPF_STMT(BPF_ALU+BPF_XOR+BPF_X, 0), 1643 BPF_STMT(BPF_RET+BPF_A, 0) 1644 }; 1645 1646 bpfjit_func_t code; 1647 uint8_t pkt[1]; /* the program doesn't read any data */ 1648 1649 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1650 1651 ATF_CHECK(bpf_validate(insns, insn_count)); 1652 1653 code = bpfjit_generate_code(NULL, insns, insn_count); 1654 ATF_REQUIRE(code != NULL); 1655 1656 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1657 1658 bpfjit_free_code(code); 1659 } 1660 1661 ATF_TC(libbpfjit_alu_lsh_x); 1662 ATF_TC_HEAD(libbpfjit_alu_lsh_x, tc) 1663 { 1664 atf_tc_set_md_var(tc, "descr", 1665 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X"); 1666 } 1667 1668 ATF_TC_BODY(libbpfjit_alu_lsh_x, tc) 1669 { 1670 static struct bpf_insn insns[] = { 1671 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1672 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1673 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1674 BPF_STMT(BPF_RET+BPF_A, 0) 1675 }; 1676 1677 bpfjit_func_t code; 1678 uint8_t pkt[1]; /* the program doesn't read any data */ 1679 1680 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1681 1682 ATF_CHECK(bpf_validate(insns, insn_count)); 1683 1684 code = bpfjit_generate_code(NULL, insns, insn_count); 1685 ATF_REQUIRE(code != NULL); 1686 1687 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xbeef0000); 1688 1689 bpfjit_free_code(code); 1690 } 1691 1692 ATF_TC(libbpfjit_alu_lsh0_x); 1693 ATF_TC_HEAD(libbpfjit_alu_lsh0_x, tc) 1694 { 1695 atf_tc_set_md_var(tc, "descr", 1696 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X with k=0"); 1697 } 1698 1699 ATF_TC_BODY(libbpfjit_alu_lsh0_x, tc) 1700 { 1701 static struct bpf_insn insns[] = { 1702 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1703 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1704 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1705 BPF_STMT(BPF_RET+BPF_A, 0) 1706 }; 1707 1708 bpfjit_func_t code; 1709 uint8_t pkt[1]; /* the program doesn't read any data */ 1710 1711 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1712 1713 ATF_CHECK(bpf_validate(insns, insn_count)); 1714 1715 code = bpfjit_generate_code(NULL, insns, insn_count); 1716 ATF_REQUIRE(code != NULL); 1717 1718 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1719 1720 bpfjit_free_code(code); 1721 } 1722 1723 ATF_TC(libbpfjit_alu_rsh_x); 1724 ATF_TC_HEAD(libbpfjit_alu_rsh_x, tc) 1725 { 1726 atf_tc_set_md_var(tc, "descr", 1727 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X"); 1728 } 1729 1730 ATF_TC_BODY(libbpfjit_alu_rsh_x, tc) 1731 { 1732 static struct bpf_insn insns[] = { 1733 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1734 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1735 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1736 BPF_STMT(BPF_RET+BPF_A, 0) 1737 }; 1738 1739 bpfjit_func_t code; 1740 uint8_t pkt[1]; /* the program doesn't read any data */ 1741 1742 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1743 1744 ATF_CHECK(bpf_validate(insns, insn_count)); 1745 1746 code = bpfjit_generate_code(NULL, insns, insn_count); 1747 ATF_REQUIRE(code != NULL); 1748 1749 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0x0000dead); 1750 1751 bpfjit_free_code(code); 1752 } 1753 1754 ATF_TC(libbpfjit_alu_rsh0_x); 1755 ATF_TC_HEAD(libbpfjit_alu_rsh0_x, tc) 1756 { 1757 atf_tc_set_md_var(tc, "descr", 1758 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X with k=0"); 1759 } 1760 1761 ATF_TC_BODY(libbpfjit_alu_rsh0_x, tc) 1762 { 1763 static struct bpf_insn insns[] = { 1764 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1765 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1766 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1767 BPF_STMT(BPF_RET+BPF_A, 0) 1768 }; 1769 1770 bpfjit_func_t code; 1771 uint8_t pkt[1]; /* the program doesn't read any data */ 1772 1773 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1774 1775 ATF_CHECK(bpf_validate(insns, insn_count)); 1776 1777 code = bpfjit_generate_code(NULL, insns, insn_count); 1778 ATF_REQUIRE(code != NULL); 1779 1780 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0xdeadbeef); 1781 1782 bpfjit_free_code(code); 1783 } 1784 1785 ATF_TC(libbpfjit_alu_modulo_x); 1786 ATF_TC_HEAD(libbpfjit_alu_modulo_x, tc) 1787 { 1788 atf_tc_set_md_var(tc, "descr", 1789 "Test JIT compilation of modulo logic of BPF_ALU+BPF_X operations"); 1790 } 1791 1792 ATF_TC_BODY(libbpfjit_alu_modulo_x, tc) 1793 { 1794 static struct bpf_insn insns[] = { 1795 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1796 1797 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 1798 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0fffff77)), 1799 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1800 1801 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 1802 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 1), 1803 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1804 1805 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 1806 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdddddddd)), 1807 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 1808 1809 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 1810 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffffff)), 1811 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 1812 1813 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 1814 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0000030c)), 1815 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1816 1817 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 1818 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1819 1820 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 1821 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffff0f)), 1822 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 1823 1824 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 1825 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 1826 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 3), 1827 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1828 1829 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 1830 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x7fffff77)), 1831 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1832 1833 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 1834 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 1835 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdead)), 1836 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1837 1838 BPF_STMT(BPF_RET+BPF_A, 0) 1839 }; 1840 1841 bpfjit_func_t code; 1842 uint8_t pkt[1]; /* the program doesn't read any data */ 1843 1844 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1845 1846 ATF_CHECK(bpf_validate(insns, insn_count)); 1847 1848 code = bpfjit_generate_code(NULL, insns, insn_count); 1849 ATF_REQUIRE(code != NULL); 1850 1851 ATF_CHECK(jitcall(code, pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 1852 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_C(0x0000a994)); 1853 1854 1855 bpfjit_free_code(code); 1856 } 1857 1858 ATF_TC(libbpfjit_alu_neg); 1859 ATF_TC_HEAD(libbpfjit_alu_neg, tc) 1860 { 1861 atf_tc_set_md_var(tc, "descr", 1862 "Test JIT compilation of BPF_ALU+BPF_NEG"); 1863 } 1864 1865 ATF_TC_BODY(libbpfjit_alu_neg, tc) 1866 { 1867 static struct bpf_insn insns[] = { 1868 BPF_STMT(BPF_LD+BPF_IMM, 777), 1869 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1870 BPF_STMT(BPF_RET+BPF_A, 0) 1871 }; 1872 1873 bpfjit_func_t code; 1874 uint8_t pkt[1]; /* the program doesn't read any data */ 1875 1876 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1877 1878 ATF_CHECK(bpf_validate(insns, insn_count)); 1879 1880 code = bpfjit_generate_code(NULL, insns, insn_count); 1881 ATF_REQUIRE(code != NULL); 1882 1883 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0u-777u); 1884 1885 bpfjit_free_code(code); 1886 } 1887 1888 ATF_TC(libbpfjit_jmp_ja); 1889 ATF_TC_HEAD(libbpfjit_jmp_ja, tc) 1890 { 1891 atf_tc_set_md_var(tc, "descr", 1892 "Test JIT compilation of BPF_JMP+BPF_JA"); 1893 } 1894 1895 ATF_TC_BODY(libbpfjit_jmp_ja, tc) 1896 { 1897 static struct bpf_insn insns[] = { 1898 BPF_STMT(BPF_JMP+BPF_JA, 1), 1899 BPF_STMT(BPF_RET+BPF_K, 0), 1900 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1901 BPF_STMT(BPF_RET+BPF_K, 1), 1902 BPF_STMT(BPF_RET+BPF_K, 2), 1903 BPF_STMT(BPF_RET+BPF_K, 3), 1904 }; 1905 1906 bpfjit_func_t code; 1907 uint8_t pkt[1]; /* the program doesn't read any data */ 1908 1909 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1910 1911 ATF_CHECK(bpf_validate(insns, insn_count)); 1912 1913 code = bpfjit_generate_code(NULL, insns, insn_count); 1914 ATF_REQUIRE(code != NULL); 1915 1916 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 1917 1918 bpfjit_free_code(code); 1919 } 1920 1921 ATF_TC(libbpfjit_jmp_ja_invalid); 1922 ATF_TC_HEAD(libbpfjit_jmp_ja_invalid, tc) 1923 { 1924 atf_tc_set_md_var(tc, "descr", 1925 "Test BPF_JMP+BPF_JA to invalid destination"); 1926 } 1927 1928 ATF_TC_BODY(libbpfjit_jmp_ja_invalid, tc) 1929 { 1930 static struct bpf_insn insns[] = { 1931 BPF_STMT(BPF_JMP+BPF_JA, 4), 1932 BPF_STMT(BPF_RET+BPF_K, 0), 1933 BPF_STMT(BPF_RET+BPF_K, 1), 1934 BPF_STMT(BPF_RET+BPF_K, 2), 1935 BPF_STMT(BPF_RET+BPF_K, 3), 1936 }; 1937 1938 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1939 1940 ATF_CHECK(!bpf_validate(insns, insn_count)); 1941 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 1942 } 1943 1944 ATF_TC(libbpfjit_jmp_ja_overflow); 1945 ATF_TC_HEAD(libbpfjit_jmp_ja_overflow, tc) 1946 { 1947 atf_tc_set_md_var(tc, "descr", 1948 "Test BPF_JMP+BPF_JA with negative offset"); 1949 } 1950 1951 ATF_TC_BODY(libbpfjit_jmp_ja_overflow, tc) 1952 { 1953 static struct bpf_insn insns[] = { 1954 BPF_STMT(BPF_JMP+BPF_JA, 1), 1955 BPF_STMT(BPF_RET+BPF_K, 777), 1956 BPF_STMT(BPF_JMP+BPF_JA, UINT32_MAX - 1), // -2 1957 BPF_STMT(BPF_RET+BPF_K, 0) 1958 }; 1959 1960 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1961 1962 /* Jumps with negative offsets work in userspace ... */ 1963 ATF_CHECK(bpf_validate(insns, insn_count)); 1964 1965 /* .. but not for bpfjit. */ 1966 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 1967 } 1968 1969 ATF_TC(libbpfjit_jmp_jgt_k); 1970 ATF_TC_HEAD(libbpfjit_jmp_jgt_k, tc) 1971 { 1972 atf_tc_set_md_var(tc, "descr", 1973 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_K"); 1974 } 1975 1976 ATF_TC_BODY(libbpfjit_jmp_jgt_k, tc) 1977 { 1978 static struct bpf_insn insns[] = { 1979 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1980 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 7, 0, 1), 1981 BPF_STMT(BPF_RET+BPF_K, 0), 1982 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 2, 2, 0), 1983 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 9, 0, 0), 1984 BPF_STMT(BPF_RET+BPF_K, 1), 1985 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 4, 1, 1), 1986 BPF_STMT(BPF_RET+BPF_K, 2), 1987 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 2, 3), 1988 BPF_STMT(BPF_RET+BPF_K, 3), 1989 BPF_STMT(BPF_RET+BPF_K, 4), 1990 BPF_STMT(BPF_RET+BPF_K, 5), 1991 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 5, 3, 1), 1992 BPF_STMT(BPF_RET+BPF_K, 6), 1993 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 0, 0, 0), 1994 BPF_STMT(BPF_RET+BPF_K, 7), 1995 BPF_STMT(BPF_RET+BPF_K, 8) 1996 }; 1997 1998 bpfjit_func_t code; 1999 uint8_t pkt[8]; /* the program doesn't read any data */ 2000 2001 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2002 2003 ATF_CHECK(bpf_validate(insns, insn_count)); 2004 2005 code = bpfjit_generate_code(NULL, insns, insn_count); 2006 ATF_REQUIRE(code != NULL); 2007 2008 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2009 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2010 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 2011 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2012 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2013 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2014 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2015 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2016 2017 bpfjit_free_code(code); 2018 } 2019 2020 ATF_TC(libbpfjit_jmp_jge_k); 2021 ATF_TC_HEAD(libbpfjit_jmp_jge_k, tc) 2022 { 2023 atf_tc_set_md_var(tc, "descr", 2024 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_K"); 2025 } 2026 2027 ATF_TC_BODY(libbpfjit_jmp_jge_k, tc) 2028 { 2029 static struct bpf_insn insns[] = { 2030 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2031 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 8, 0, 1), 2032 BPF_STMT(BPF_RET+BPF_K, 0), 2033 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 3, 2, 0), 2034 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 9, 0, 0), 2035 BPF_STMT(BPF_RET+BPF_K, 1), 2036 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 5, 1, 1), 2037 BPF_STMT(BPF_RET+BPF_K, 2), 2038 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 2, 3), 2039 BPF_STMT(BPF_RET+BPF_K, 3), 2040 BPF_STMT(BPF_RET+BPF_K, 4), 2041 BPF_STMT(BPF_RET+BPF_K, 5), 2042 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 6, 3, 1), 2043 BPF_STMT(BPF_RET+BPF_K, 6), 2044 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 1, 0, 0), 2045 BPF_STMT(BPF_RET+BPF_K, 7), 2046 BPF_STMT(BPF_RET+BPF_K, 8) 2047 }; 2048 2049 bpfjit_func_t code; 2050 uint8_t pkt[8]; /* the program doesn't read any data */ 2051 2052 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2053 2054 ATF_CHECK(bpf_validate(insns, insn_count)); 2055 2056 code = bpfjit_generate_code(NULL, insns, insn_count); 2057 ATF_REQUIRE(code != NULL); 2058 2059 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2060 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2061 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 2062 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2063 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2064 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2065 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2066 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2067 2068 bpfjit_free_code(code); 2069 } 2070 2071 ATF_TC(libbpfjit_jmp_jeq_k); 2072 ATF_TC_HEAD(libbpfjit_jmp_jeq_k, tc) 2073 { 2074 atf_tc_set_md_var(tc, "descr", 2075 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_K"); 2076 } 2077 2078 ATF_TC_BODY(libbpfjit_jmp_jeq_k, tc) 2079 { 2080 static struct bpf_insn insns[] = { 2081 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2082 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 1), 2083 BPF_STMT(BPF_RET+BPF_K, 0), 2084 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 1, 0), 2085 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 9, 1, 1), 2086 BPF_STMT(BPF_RET+BPF_K, 1), 2087 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 5, 1, 1), 2088 BPF_STMT(BPF_RET+BPF_K, 2), 2089 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 7, 2, 3), 2090 BPF_STMT(BPF_RET+BPF_K, 3), 2091 BPF_STMT(BPF_RET+BPF_K, 4), 2092 BPF_STMT(BPF_RET+BPF_K, 5), 2093 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 3, 1), 2094 BPF_STMT(BPF_RET+BPF_K, 6), 2095 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 1, 0, 0), 2096 BPF_STMT(BPF_RET+BPF_K, 7), 2097 BPF_STMT(BPF_RET+BPF_K, 8) 2098 }; 2099 2100 bpfjit_func_t code; 2101 uint8_t pkt[8]; /* the program doesn't read any data */ 2102 2103 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2104 2105 ATF_CHECK(bpf_validate(insns, insn_count)); 2106 2107 code = bpfjit_generate_code(NULL, insns, insn_count); 2108 ATF_REQUIRE(code != NULL); 2109 2110 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 2111 ATF_CHECK(jitcall(code, pkt, 2, 2) == 7); 2112 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 2113 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2114 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2115 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2116 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2117 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2118 2119 bpfjit_free_code(code); 2120 } 2121 2122 ATF_TC(libbpfjit_jmp_jset_k); 2123 ATF_TC_HEAD(libbpfjit_jmp_jset_k, tc) 2124 { 2125 atf_tc_set_md_var(tc, "descr", 2126 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_K"); 2127 } 2128 2129 ATF_TC_BODY(libbpfjit_jmp_jset_k, tc) 2130 { 2131 static struct bpf_insn insns[] = { 2132 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2133 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 8, 0, 1), 2134 BPF_STMT(BPF_RET+BPF_K, 0), 2135 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 4, 2, 0), 2136 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 3, 0, 0), 2137 BPF_STMT(BPF_RET+BPF_K, 1), 2138 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 1, 1), 2139 BPF_STMT(BPF_RET+BPF_K, 2), 2140 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 1, 2, 3), 2141 BPF_STMT(BPF_RET+BPF_K, 3), 2142 BPF_STMT(BPF_RET+BPF_K, 4), 2143 BPF_STMT(BPF_RET+BPF_K, 5), 2144 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 3, 1), 2145 BPF_STMT(BPF_RET+BPF_K, 6), 2146 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 7, 0, 0), 2147 BPF_STMT(BPF_RET+BPF_K, 7), 2148 BPF_STMT(BPF_RET+BPF_K, 8) 2149 }; 2150 2151 bpfjit_func_t code; 2152 uint8_t pkt[8]; /* the program doesn't read any data */ 2153 2154 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2155 2156 ATF_CHECK(bpf_validate(insns, insn_count)); 2157 2158 code = bpfjit_generate_code(NULL, insns, insn_count); 2159 ATF_REQUIRE(code != NULL); 2160 2161 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2162 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2163 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 2164 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2165 ATF_CHECK(jitcall(code, pkt, 5, 5) == 5); 2166 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2167 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2168 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2169 2170 bpfjit_free_code(code); 2171 } 2172 2173 ATF_TC(libbpfjit_jmp_modulo_k); 2174 ATF_TC_HEAD(libbpfjit_jmp_modulo_k, tc) 2175 { 2176 atf_tc_set_md_var(tc, "descr", 2177 "Test JIT compilation of modulo logic of BPF_JMP+BPF_K operations"); 2178 } 2179 2180 ATF_TC_BODY(libbpfjit_jmp_modulo_k, tc) 2181 { 2182 static struct bpf_insn insns[] = { 2183 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 2184 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 2185 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 1, 0), 2186 BPF_STMT(BPF_RET+BPF_K, 0), 2187 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 0, 1), 2188 BPF_STMT(BPF_RET+BPF_K, 1), 2189 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 0, 1), 2190 BPF_STMT(BPF_RET+BPF_K, 2), 2191 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 0, 3), 2192 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 2, 0), 2193 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 1, 0), 2194 BPF_STMT(BPF_JMP+BPF_JA, 1), 2195 BPF_STMT(BPF_RET+BPF_K, 3), 2196 2197 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 2198 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 2199 2200 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 1, 0), 2201 BPF_STMT(BPF_RET+BPF_K, 4), 2202 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 0, 1), 2203 BPF_STMT(BPF_RET+BPF_K, 5), 2204 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 0, 1), 2205 BPF_STMT(BPF_RET+BPF_K, 6), 2206 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 0, 3), 2207 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 2, 0), 2208 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 1, 0), 2209 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2210 BPF_STMT(BPF_RET+BPF_K, 7) 2211 }; 2212 2213 bpfjit_func_t code; 2214 uint8_t pkt[1]; /* the program doesn't read any data */ 2215 2216 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2217 2218 ATF_CHECK(bpf_validate(insns, insn_count)); 2219 2220 code = bpfjit_generate_code(NULL, insns, insn_count); 2221 ATF_REQUIRE(code != NULL); 2222 2223 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2224 2225 bpfjit_free_code(code); 2226 } 2227 2228 ATF_TC(libbpfjit_jmp_jgt_x); 2229 ATF_TC_HEAD(libbpfjit_jmp_jgt_x, tc) 2230 { 2231 atf_tc_set_md_var(tc, "descr", 2232 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_X"); 2233 } 2234 2235 ATF_TC_BODY(libbpfjit_jmp_jgt_x, tc) 2236 { 2237 static struct bpf_insn insns[] = { 2238 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2239 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 2240 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 2241 BPF_STMT(BPF_RET+BPF_K, 0), 2242 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 2243 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 2244 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 2245 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 2246 BPF_STMT(BPF_RET+BPF_K, 1), 2247 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 2248 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 1, 1), 2249 BPF_STMT(BPF_RET+BPF_K, 2), 2250 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 2251 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 2, 3), 2252 BPF_STMT(BPF_RET+BPF_K, 3), 2253 BPF_STMT(BPF_RET+BPF_K, 4), 2254 BPF_STMT(BPF_RET+BPF_K, 5), 2255 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2256 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 4, 1), 2257 BPF_STMT(BPF_RET+BPF_K, 6), 2258 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 2259 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 2260 BPF_STMT(BPF_RET+BPF_K, 7), 2261 BPF_STMT(BPF_RET+BPF_K, 8) 2262 }; 2263 2264 bpfjit_func_t code; 2265 uint8_t pkt[8]; /* the program doesn't read any data */ 2266 2267 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2268 2269 ATF_CHECK(bpf_validate(insns, insn_count)); 2270 2271 code = bpfjit_generate_code(NULL, insns, insn_count); 2272 ATF_REQUIRE(code != NULL); 2273 2274 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2275 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2276 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 2277 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2278 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2279 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2280 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2281 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2282 2283 bpfjit_free_code(code); 2284 } 2285 2286 ATF_TC(libbpfjit_jmp_jge_x); 2287 ATF_TC_HEAD(libbpfjit_jmp_jge_x, tc) 2288 { 2289 atf_tc_set_md_var(tc, "descr", 2290 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_X"); 2291 } 2292 2293 ATF_TC_BODY(libbpfjit_jmp_jge_x, tc) 2294 { 2295 static struct bpf_insn insns[] = { 2296 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2297 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 2298 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 2299 BPF_STMT(BPF_RET+BPF_K, 0), 2300 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2301 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 3, 0), 2302 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 2303 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 2304 BPF_STMT(BPF_RET+BPF_K, 1), 2305 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2306 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 1), 2307 BPF_STMT(BPF_RET+BPF_K, 2), 2308 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 2309 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 2, 3), 2310 BPF_STMT(BPF_RET+BPF_K, 3), 2311 BPF_STMT(BPF_RET+BPF_K, 4), 2312 BPF_STMT(BPF_RET+BPF_K, 5), 2313 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 2314 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 4, 1), 2315 BPF_STMT(BPF_RET+BPF_K, 6), 2316 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 2317 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 2318 BPF_STMT(BPF_RET+BPF_K, 7), 2319 BPF_STMT(BPF_RET+BPF_K, 8) 2320 }; 2321 2322 bpfjit_func_t code; 2323 uint8_t pkt[8]; /* the program doesn't read any data */ 2324 2325 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2326 2327 ATF_CHECK(bpf_validate(insns, insn_count)); 2328 2329 code = bpfjit_generate_code(NULL, insns, insn_count); 2330 ATF_REQUIRE(code != NULL); 2331 2332 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2333 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2334 ATF_CHECK(jitcall(code, pkt, 3, 3) == 7); 2335 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2336 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2337 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2338 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2339 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2340 2341 bpfjit_free_code(code); 2342 } 2343 2344 ATF_TC(libbpfjit_jmp_jeq_x); 2345 ATF_TC_HEAD(libbpfjit_jmp_jeq_x, tc) 2346 { 2347 atf_tc_set_md_var(tc, "descr", 2348 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_X"); 2349 } 2350 2351 ATF_TC_BODY(libbpfjit_jmp_jeq_x, tc) 2352 { 2353 static struct bpf_insn insns[] = { 2354 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2355 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 2356 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1), 2357 BPF_STMT(BPF_RET+BPF_K, 0), 2358 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2359 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 0), 2360 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 2361 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 2362 BPF_STMT(BPF_RET+BPF_K, 1), 2363 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2364 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 2365 BPF_STMT(BPF_RET+BPF_K, 2), 2366 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 2367 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 3), 2368 BPF_STMT(BPF_RET+BPF_K, 3), 2369 BPF_STMT(BPF_RET+BPF_K, 4), 2370 BPF_STMT(BPF_RET+BPF_K, 5), 2371 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 2372 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 3, 1), 2373 BPF_STMT(BPF_RET+BPF_K, 6), 2374 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 1, 0, 0), 2375 BPF_STMT(BPF_RET+BPF_K, 7), 2376 BPF_STMT(BPF_RET+BPF_K, 8) 2377 }; 2378 2379 bpfjit_func_t code; 2380 uint8_t pkt[8]; /* the program doesn't read any data */ 2381 2382 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2383 2384 ATF_CHECK(bpf_validate(insns, insn_count)); 2385 2386 code = bpfjit_generate_code(NULL, insns, insn_count); 2387 ATF_REQUIRE(code != NULL); 2388 2389 ATF_CHECK(jitcall(code, pkt, 1, 1) == 7); 2390 ATF_CHECK(jitcall(code, pkt, 2, 2) == 7); 2391 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 2392 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2393 ATF_CHECK(jitcall(code, pkt, 5, 5) == 7); 2394 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2395 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2396 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2397 2398 bpfjit_free_code(code); 2399 } 2400 2401 ATF_TC(libbpfjit_jmp_jset_x); 2402 ATF_TC_HEAD(libbpfjit_jmp_jset_x, tc) 2403 { 2404 atf_tc_set_md_var(tc, "descr", 2405 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_X"); 2406 } 2407 2408 ATF_TC_BODY(libbpfjit_jmp_jset_x, tc) 2409 { 2410 static struct bpf_insn insns[] = { 2411 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2412 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 2413 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 1), 2414 BPF_STMT(BPF_RET+BPF_K, 0), 2415 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 2416 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 0), 2417 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 3, 0, 0), 2418 BPF_STMT(BPF_RET+BPF_K, 1), 2419 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 2420 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 1, 1), 2421 BPF_STMT(BPF_RET+BPF_K, 2), 2422 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 2423 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 3), 2424 BPF_STMT(BPF_RET+BPF_K, 3), 2425 BPF_STMT(BPF_RET+BPF_K, 4), 2426 BPF_STMT(BPF_RET+BPF_K, 5), 2427 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 2428 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 4, 1), 2429 BPF_STMT(BPF_RET+BPF_K, 6), 2430 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 2431 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 0), 2432 BPF_STMT(BPF_RET+BPF_K, 7), 2433 BPF_STMT(BPF_RET+BPF_K, 8) 2434 }; 2435 2436 bpfjit_func_t code; 2437 uint8_t pkt[8]; /* the program doesn't read any data */ 2438 2439 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2440 2441 ATF_CHECK(bpf_validate(insns, insn_count)); 2442 2443 code = bpfjit_generate_code(NULL, insns, insn_count); 2444 ATF_REQUIRE(code != NULL); 2445 2446 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 2447 ATF_CHECK(jitcall(code, pkt, 2, 2) == 1); 2448 ATF_CHECK(jitcall(code, pkt, 3, 3) == 1); 2449 ATF_CHECK(jitcall(code, pkt, 4, 4) == 7); 2450 ATF_CHECK(jitcall(code, pkt, 5, 5) == 5); 2451 ATF_CHECK(jitcall(code, pkt, 6, 6) == 8); 2452 ATF_CHECK(jitcall(code, pkt, 7, 7) == 5); 2453 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2454 2455 bpfjit_free_code(code); 2456 } 2457 2458 ATF_TC(libbpfjit_jmp_modulo_x); 2459 ATF_TC_HEAD(libbpfjit_jmp_modulo_x, tc) 2460 { 2461 atf_tc_set_md_var(tc, "descr", 2462 "Test JIT compilation of modulo logic of BPF_JMP+BPF_X operations"); 2463 } 2464 2465 ATF_TC_BODY(libbpfjit_jmp_modulo_x, tc) 2466 { 2467 static struct bpf_insn insns[] = { 2468 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 2469 /* FFFFF770 << 4 = FFFFF770 */ 2470 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 2471 2472 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 2473 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2474 BPF_STMT(BPF_RET+BPF_K, 0), 2475 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 2476 BPF_STMT(BPF_RET+BPF_K, 1), 2477 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 2478 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 2479 BPF_STMT(BPF_RET+BPF_K, 2), 2480 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 2481 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 2482 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 2483 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 2484 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 2485 BPF_STMT(BPF_JMP+BPF_JA, 1), 2486 BPF_STMT(BPF_RET+BPF_K, 3), 2487 2488 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 2489 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 2490 2491 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 2492 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2493 BPF_STMT(BPF_RET+BPF_K, 4), 2494 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 2495 BPF_STMT(BPF_RET+BPF_K, 5), 2496 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 2497 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 2498 BPF_STMT(BPF_RET+BPF_K, 6), 2499 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 2500 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 2501 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 2502 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 2503 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 2504 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2505 BPF_STMT(BPF_RET+BPF_K, 7) 2506 }; 2507 2508 bpfjit_func_t code; 2509 uint8_t pkt[1]; /* the program doesn't read any data */ 2510 2511 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2512 2513 ATF_CHECK(bpf_validate(insns, insn_count)); 2514 2515 code = bpfjit_generate_code(NULL, insns, insn_count); 2516 ATF_REQUIRE(code != NULL); 2517 2518 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2519 2520 bpfjit_free_code(code); 2521 } 2522 2523 ATF_TC(libbpfjit_ld_abs); 2524 ATF_TC_HEAD(libbpfjit_ld_abs, tc) 2525 { 2526 atf_tc_set_md_var(tc, "descr", 2527 "Test JIT compilation of BPF_LD+BPF_ABS"); 2528 } 2529 2530 ATF_TC_BODY(libbpfjit_ld_abs, tc) 2531 { 2532 static struct bpf_insn insns[3][2] = { 2533 { 2534 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 2535 BPF_STMT(BPF_RET+BPF_A, 0) 2536 }, 2537 { 2538 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 5), 2539 BPF_STMT(BPF_RET+BPF_A, 0) 2540 }, 2541 { 2542 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 5), 2543 BPF_STMT(BPF_RET+BPF_A, 0) 2544 } 2545 }; 2546 2547 static size_t lengths[3] = { 1, 2, 4 }; 2548 static unsigned int expected[3] = { 0xde, 0xdead, 0xdeadbeef }; 2549 2550 size_t i, l; 2551 uint8_t *pkt = deadbeef_at_5; 2552 size_t pktsize = sizeof(deadbeef_at_5); 2553 2554 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2555 2556 for (i = 0; i < 3; i++) { 2557 bpfjit_func_t code; 2558 2559 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2560 2561 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2562 ATF_REQUIRE(code != NULL); 2563 2564 for (l = 1; l < 5 + lengths[i]; l++) { 2565 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 2566 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 2567 } 2568 2569 l = 5 + lengths[i]; 2570 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2571 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 2572 2573 l = pktsize; 2574 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2575 2576 bpfjit_free_code(code); 2577 } 2578 } 2579 2580 ATF_TC(libbpfjit_ld_abs_k_overflow); 2581 ATF_TC_HEAD(libbpfjit_ld_abs_k_overflow, tc) 2582 { 2583 atf_tc_set_md_var(tc, "descr", 2584 "Test JIT compilation of BPF_LD+BPF_ABS with overflow in k+4"); 2585 } 2586 2587 ATF_TC_BODY(libbpfjit_ld_abs_k_overflow, tc) 2588 { 2589 static struct bpf_insn insns[12][3] = { 2590 { 2591 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 2592 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2593 BPF_STMT(BPF_RET+BPF_K, 1) 2594 }, 2595 { 2596 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 2597 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2598 BPF_STMT(BPF_RET+BPF_K, 1) 2599 }, 2600 { 2601 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 2602 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2603 BPF_STMT(BPF_RET+BPF_K, 1) 2604 }, 2605 { 2606 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 2607 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2608 BPF_STMT(BPF_RET+BPF_K, 1) 2609 }, 2610 { 2611 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 2612 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2613 BPF_STMT(BPF_RET+BPF_K, 1) 2614 }, 2615 { 2616 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 2617 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2618 BPF_STMT(BPF_RET+BPF_K, 1) 2619 }, 2620 { 2621 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2622 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 2623 BPF_STMT(BPF_RET+BPF_K, 1) 2624 }, 2625 { 2626 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2627 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 2628 BPF_STMT(BPF_RET+BPF_K, 1) 2629 }, 2630 { 2631 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2632 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 2633 BPF_STMT(BPF_RET+BPF_K, 1) 2634 }, 2635 { 2636 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2637 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 2638 BPF_STMT(BPF_RET+BPF_K, 1) 2639 }, 2640 { 2641 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2642 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 2643 BPF_STMT(BPF_RET+BPF_K, 1) 2644 }, 2645 { 2646 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2647 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 2648 BPF_STMT(BPF_RET+BPF_K, 1) 2649 } 2650 }; 2651 2652 int i; 2653 uint8_t pkt[8] = { 0 }; 2654 2655 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2656 2657 for (i = 0; i < 3; i++) { 2658 bpfjit_func_t code; 2659 2660 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2661 2662 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2663 ATF_REQUIRE(code != NULL); 2664 2665 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2666 2667 bpfjit_free_code(code); 2668 } 2669 } 2670 2671 ATF_TC(libbpfjit_ld_ind); 2672 ATF_TC_HEAD(libbpfjit_ld_ind, tc) 2673 { 2674 atf_tc_set_md_var(tc, "descr", 2675 "Test JIT compilation of BPF_LD+BPF_IND"); 2676 } 2677 2678 ATF_TC_BODY(libbpfjit_ld_ind, tc) 2679 { 2680 static struct bpf_insn insns[6][3] = { 2681 { 2682 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2683 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2684 BPF_STMT(BPF_RET+BPF_A, 0) 2685 }, 2686 { 2687 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2688 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), 2689 BPF_STMT(BPF_RET+BPF_A, 0) 2690 }, 2691 { 2692 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2693 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2), 2694 BPF_STMT(BPF_RET+BPF_A, 0) 2695 }, 2696 { 2697 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2698 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2699 BPF_STMT(BPF_RET+BPF_A, 0) 2700 }, 2701 { 2702 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2703 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 2704 BPF_STMT(BPF_RET+BPF_A, 0) 2705 }, 2706 { 2707 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2708 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), 2709 BPF_STMT(BPF_RET+BPF_A, 0) 2710 } 2711 }; 2712 2713 static size_t lengths[6] = { 1, 2, 4, 1, 2, 4 }; 2714 2715 static unsigned int expected[6] = { 2716 0xde, 0xdead, 0xdeadbeef, 2717 0xde, 0xdead, 0xdeadbeef 2718 }; 2719 2720 size_t i, l; 2721 uint8_t *pkt = deadbeef_at_5; 2722 size_t pktsize = sizeof(deadbeef_at_5); 2723 2724 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2725 2726 for (i = 0; i < 3; i++) { 2727 bpfjit_func_t code; 2728 2729 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2730 2731 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2732 ATF_REQUIRE(code != NULL); 2733 2734 for (l = 1; l < 5 + lengths[i]; l++) { 2735 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 2736 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 2737 } 2738 2739 l = 5 + lengths[i]; 2740 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2741 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 2742 2743 l = pktsize; 2744 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2745 2746 bpfjit_free_code(code); 2747 } 2748 } 2749 2750 ATF_TC(libbpfjit_ld_ind_k_overflow); 2751 ATF_TC_HEAD(libbpfjit_ld_ind_k_overflow, tc) 2752 { 2753 atf_tc_set_md_var(tc, "descr", 2754 "Test JIT compilation of BPF_LD+BPF_IND with overflow in k+4"); 2755 } 2756 2757 ATF_TC_BODY(libbpfjit_ld_ind_k_overflow, tc) 2758 { 2759 static struct bpf_insn insns[12][3] = { 2760 { 2761 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2762 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2763 BPF_STMT(BPF_RET+BPF_K, 1) 2764 }, 2765 { 2766 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2767 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2768 BPF_STMT(BPF_RET+BPF_K, 1) 2769 }, 2770 { 2771 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2772 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2773 BPF_STMT(BPF_RET+BPF_K, 1) 2774 }, 2775 { 2776 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2777 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2778 BPF_STMT(BPF_RET+BPF_K, 1) 2779 }, 2780 { 2781 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2782 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2783 BPF_STMT(BPF_RET+BPF_K, 1) 2784 }, 2785 { 2786 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2787 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2788 BPF_STMT(BPF_RET+BPF_K, 1) 2789 }, 2790 { 2791 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2792 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2793 BPF_STMT(BPF_RET+BPF_K, 1) 2794 }, 2795 { 2796 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2797 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2798 BPF_STMT(BPF_RET+BPF_K, 1) 2799 }, 2800 { 2801 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2802 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2803 BPF_STMT(BPF_RET+BPF_K, 1) 2804 }, 2805 { 2806 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2807 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2808 BPF_STMT(BPF_RET+BPF_K, 1) 2809 }, 2810 { 2811 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2812 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2813 BPF_STMT(BPF_RET+BPF_K, 1) 2814 }, 2815 { 2816 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2817 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2818 BPF_STMT(BPF_RET+BPF_K, 1) 2819 } 2820 }; 2821 2822 int i; 2823 uint8_t pkt[8] = { 0 }; 2824 2825 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2826 2827 for (i = 0; i < 3; i++) { 2828 bpfjit_func_t code; 2829 2830 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2831 2832 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2833 ATF_REQUIRE(code != NULL); 2834 2835 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2836 2837 bpfjit_free_code(code); 2838 } 2839 } 2840 2841 ATF_TC(libbpfjit_ld_ind_x_overflow1); 2842 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow1, tc) 2843 { 2844 atf_tc_set_md_var(tc, "descr", 2845 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2846 } 2847 2848 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow1, tc) 2849 { 2850 static struct bpf_insn insns[] = { 2851 BPF_STMT(BPF_LD+BPF_LEN, 0), 2852 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2853 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2854 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2855 BPF_STMT(BPF_RET+BPF_A, 0) 2856 }; 2857 2858 size_t i; 2859 bpfjit_func_t code; 2860 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2861 2862 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2863 2864 ATF_CHECK(bpf_validate(insns, insn_count)); 2865 2866 code = bpfjit_generate_code(NULL, insns, insn_count); 2867 ATF_REQUIRE(code != NULL); 2868 2869 for (i = 1; i <= sizeof(pkt); i++) { 2870 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2871 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2872 } 2873 2874 bpfjit_free_code(code); 2875 } 2876 2877 ATF_TC(libbpfjit_ld_ind_x_overflow2); 2878 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow2, tc) 2879 { 2880 atf_tc_set_md_var(tc, "descr", 2881 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2882 } 2883 2884 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow2, tc) 2885 { 2886 static struct bpf_insn insns[] = { 2887 BPF_STMT(BPF_LD+BPF_LEN, 0), 2888 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2889 BPF_STMT(BPF_ST, 3), 2890 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2891 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2892 BPF_STMT(BPF_RET+BPF_A, 0) 2893 }; 2894 2895 size_t i; 2896 bpfjit_func_t code; 2897 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2898 2899 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2900 2901 ATF_CHECK(bpf_validate(insns, insn_count)); 2902 2903 code = bpfjit_generate_code(NULL, insns, insn_count); 2904 ATF_REQUIRE(code != NULL); 2905 2906 for (i = 1; i <= sizeof(pkt); i++) { 2907 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2908 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2909 } 2910 2911 bpfjit_free_code(code); 2912 } 2913 2914 ATF_TC(libbpfjit_ld_len); 2915 ATF_TC_HEAD(libbpfjit_ld_len, tc) 2916 { 2917 atf_tc_set_md_var(tc, "descr", 2918 "Test JIT compilation of BPF_LD+BPF_W+BPF_LEN"); 2919 } 2920 2921 ATF_TC_BODY(libbpfjit_ld_len, tc) 2922 { 2923 static struct bpf_insn insns[] = { 2924 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2925 BPF_STMT(BPF_RET+BPF_A, 0) 2926 }; 2927 2928 size_t i; 2929 bpfjit_func_t code; 2930 uint8_t pkt[32]; /* the program doesn't read any data */ 2931 2932 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2933 2934 ATF_CHECK(bpf_validate(insns, insn_count)); 2935 2936 code = bpfjit_generate_code(NULL, insns, insn_count); 2937 ATF_REQUIRE(code != NULL); 2938 2939 for (i = 0; i < sizeof(pkt); i++) 2940 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 2941 2942 bpfjit_free_code(code); 2943 } 2944 2945 ATF_TC(libbpfjit_ld_imm); 2946 ATF_TC_HEAD(libbpfjit_ld_imm, tc) 2947 { 2948 atf_tc_set_md_var(tc, "descr", 2949 "Test JIT compilation of BPF_LD+BPF_IMM"); 2950 } 2951 2952 ATF_TC_BODY(libbpfjit_ld_imm, tc) 2953 { 2954 static struct bpf_insn insns[] = { 2955 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX), 2956 BPF_STMT(BPF_RET+BPF_A, 0) 2957 }; 2958 2959 bpfjit_func_t code; 2960 uint8_t pkt[1]; /* the program doesn't read any data */ 2961 2962 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2963 2964 ATF_CHECK(bpf_validate(insns, insn_count)); 2965 2966 code = bpfjit_generate_code(NULL, insns, insn_count); 2967 ATF_REQUIRE(code != NULL); 2968 2969 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2970 2971 bpfjit_free_code(code); 2972 } 2973 2974 ATF_TC(libbpfjit_ldx_imm1); 2975 ATF_TC_HEAD(libbpfjit_ldx_imm1, tc) 2976 { 2977 atf_tc_set_md_var(tc, "descr", 2978 "Test JIT compilation of BPF_LDX+BPF_IMM"); 2979 } 2980 2981 ATF_TC_BODY(libbpfjit_ldx_imm1, tc) 2982 { 2983 static struct bpf_insn insns[] = { 2984 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX - 5), 2985 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2986 BPF_STMT(BPF_RET+BPF_A, 0) 2987 }; 2988 2989 bpfjit_func_t code; 2990 uint8_t pkt[1]; /* the program doesn't read any data */ 2991 2992 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2993 2994 ATF_CHECK(bpf_validate(insns, insn_count)); 2995 2996 code = bpfjit_generate_code(NULL, insns, insn_count); 2997 ATF_REQUIRE(code != NULL); 2998 2999 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX - 5); 3000 3001 bpfjit_free_code(code); 3002 } 3003 3004 ATF_TC(libbpfjit_ldx_imm2); 3005 ATF_TC_HEAD(libbpfjit_ldx_imm2, tc) 3006 { 3007 atf_tc_set_md_var(tc, "descr", 3008 "Test JIT compilation of BPF_LDX+BPF_IMM"); 3009 } 3010 3011 ATF_TC_BODY(libbpfjit_ldx_imm2, tc) 3012 { 3013 static struct bpf_insn insns[] = { 3014 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 3015 BPF_STMT(BPF_LD+BPF_IMM, 5), 3016 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 3017 BPF_STMT(BPF_RET+BPF_K, 7), 3018 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 3019 }; 3020 3021 bpfjit_func_t code; 3022 uint8_t pkt[1]; /* the program doesn't read any data */ 3023 3024 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3025 3026 ATF_CHECK(bpf_validate(insns, insn_count)); 3027 3028 code = bpfjit_generate_code(NULL, insns, insn_count); 3029 ATF_REQUIRE(code != NULL); 3030 3031 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 3032 3033 bpfjit_free_code(code); 3034 } 3035 3036 ATF_TC(libbpfjit_ldx_len1); 3037 ATF_TC_HEAD(libbpfjit_ldx_len1, tc) 3038 { 3039 atf_tc_set_md_var(tc, "descr", 3040 "Test JIT compilation of BPF_LDX+BPF_LEN"); 3041 } 3042 3043 ATF_TC_BODY(libbpfjit_ldx_len1, tc) 3044 { 3045 static struct bpf_insn insns[] = { 3046 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3047 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3048 BPF_STMT(BPF_RET+BPF_A, 0) 3049 }; 3050 3051 size_t i; 3052 bpfjit_func_t code; 3053 uint8_t pkt[5]; /* the program doesn't read any data */ 3054 3055 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3056 3057 ATF_CHECK(bpf_validate(insns, insn_count)); 3058 3059 code = bpfjit_generate_code(NULL, insns, insn_count); 3060 ATF_REQUIRE(code != NULL); 3061 3062 for (i = 1; i < sizeof(pkt); i++) { 3063 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 3064 ATF_CHECK(jitcall(code, pkt, i + 1, i) == i + 1); 3065 } 3066 3067 bpfjit_free_code(code); 3068 } 3069 3070 ATF_TC(libbpfjit_ldx_len2); 3071 ATF_TC_HEAD(libbpfjit_ldx_len2, tc) 3072 { 3073 atf_tc_set_md_var(tc, "descr", 3074 "Test JIT compilation of BPF_LDX+BPF_LEN"); 3075 } 3076 3077 ATF_TC_BODY(libbpfjit_ldx_len2, tc) 3078 { 3079 static struct bpf_insn insns[] = { 3080 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3081 BPF_STMT(BPF_LD+BPF_IMM, 5), 3082 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 3083 BPF_STMT(BPF_RET+BPF_K, 7), 3084 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 3085 }; 3086 3087 bpfjit_func_t code; 3088 uint8_t pkt[5]; /* the program doesn't read any data */ 3089 3090 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3091 3092 ATF_CHECK(bpf_validate(insns, insn_count)); 3093 3094 code = bpfjit_generate_code(NULL, insns, insn_count); 3095 ATF_REQUIRE(code != NULL); 3096 3097 ATF_CHECK(jitcall(code, pkt, 5, 1) == UINT32_MAX); 3098 ATF_CHECK(jitcall(code, pkt, 6, 5) == 7); 3099 3100 bpfjit_free_code(code); 3101 } 3102 3103 ATF_TC(libbpfjit_ldx_msh); 3104 ATF_TC_HEAD(libbpfjit_ldx_msh, tc) 3105 { 3106 atf_tc_set_md_var(tc, "descr", 3107 "Test JIT compilation of BPF_LDX+BPF_MSH"); 3108 } 3109 3110 ATF_TC_BODY(libbpfjit_ldx_msh, tc) 3111 { 3112 static struct bpf_insn insns[] = { 3113 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), 3114 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3115 BPF_STMT(BPF_RET+BPF_A, 0) 3116 }; 3117 3118 bpfjit_func_t code; 3119 uint8_t pkt[2] = { 0, 0x7a }; 3120 3121 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3122 3123 ATF_CHECK(bpf_validate(insns, insn_count)); 3124 3125 code = bpfjit_generate_code(NULL, insns, insn_count); 3126 ATF_REQUIRE(code != NULL); 3127 3128 ATF_CHECK(jitcall(code, pkt, 2, 2) == 40); 3129 3130 bpfjit_free_code(code); 3131 } 3132 3133 ATF_TC(libbpfjit_misc_tax); 3134 ATF_TC_HEAD(libbpfjit_misc_tax, tc) 3135 { 3136 atf_tc_set_md_var(tc, "descr", 3137 "Test JIT compilation of BPF_MISC+BPF_TAX"); 3138 } 3139 3140 ATF_TC_BODY(libbpfjit_misc_tax, tc) 3141 { 3142 static struct bpf_insn insns[] = { 3143 BPF_STMT(BPF_LD+BPF_IMM, 3), 3144 BPF_STMT(BPF_MISC+BPF_TAX, 0), 3145 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 3146 BPF_STMT(BPF_RET+BPF_A, 0) 3147 }; 3148 3149 bpfjit_func_t code; 3150 uint8_t pkt[] = { 0, 11, 22, 33, 44, 55 }; 3151 3152 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3153 3154 ATF_CHECK(bpf_validate(insns, insn_count)); 3155 3156 code = bpfjit_generate_code(NULL, insns, insn_count); 3157 ATF_REQUIRE(code != NULL); 3158 3159 ATF_CHECK(jitcall(code, pkt, sizeof(pkt), sizeof(pkt)) == 55); 3160 3161 bpfjit_free_code(code); 3162 } 3163 3164 ATF_TC(libbpfjit_misc_txa); 3165 ATF_TC_HEAD(libbpfjit_misc_txa, tc) 3166 { 3167 atf_tc_set_md_var(tc, "descr", 3168 "Test JIT compilation of BPF_MISC+BPF_TXA"); 3169 } 3170 3171 ATF_TC_BODY(libbpfjit_misc_txa, tc) 3172 { 3173 static struct bpf_insn insns[] = { 3174 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 391), 3175 BPF_STMT(BPF_MISC+BPF_TXA, 0), 3176 BPF_STMT(BPF_RET+BPF_A, 0) 3177 }; 3178 3179 bpfjit_func_t code; 3180 uint8_t pkt[1]; /* the program doesn't read any data */ 3181 3182 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3183 3184 ATF_CHECK(bpf_validate(insns, insn_count)); 3185 3186 code = bpfjit_generate_code(NULL, insns, insn_count); 3187 ATF_REQUIRE(code != NULL); 3188 3189 ATF_CHECK(jitcall(code, pkt, 1, 1) == 391); 3190 3191 bpfjit_free_code(code); 3192 } 3193 3194 ATF_TC(libbpfjit_st1); 3195 ATF_TC_HEAD(libbpfjit_st1, tc) 3196 { 3197 atf_tc_set_md_var(tc, "descr", 3198 "Test JIT compilation of BPF_ST"); 3199 } 3200 3201 ATF_TC_BODY(libbpfjit_st1, tc) 3202 { 3203 static struct bpf_insn insns[] = { 3204 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3205 BPF_STMT(BPF_ST, 0), 3206 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 3207 BPF_STMT(BPF_LD+BPF_MEM, 0), 3208 BPF_STMT(BPF_RET+BPF_A, 0) 3209 }; 3210 3211 size_t i; 3212 bpfjit_func_t code; 3213 uint8_t pkt[16]; /* the program doesn't read any data */ 3214 3215 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3216 3217 ATF_CHECK(bpf_validate(insns, insn_count)); 3218 3219 code = bpfjit_generate_code(NULL, insns, insn_count); 3220 ATF_REQUIRE(code != NULL); 3221 3222 for (i = 1; i <= sizeof(pkt); i++) 3223 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 3224 3225 bpfjit_free_code(code); 3226 } 3227 3228 ATF_TC(libbpfjit_st2); 3229 ATF_TC_HEAD(libbpfjit_st2, tc) 3230 { 3231 atf_tc_set_md_var(tc, "descr", 3232 "Test JIT compilation of BPF_ST"); 3233 } 3234 3235 ATF_TC_BODY(libbpfjit_st2, tc) 3236 { 3237 static struct bpf_insn insns[] = { 3238 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3239 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3240 BPF_STMT(BPF_LD+BPF_MEM, 0), 3241 BPF_STMT(BPF_RET+BPF_A, 0) 3242 }; 3243 3244 bpfjit_func_t code; 3245 uint8_t pkt[1]; /* the program doesn't read any data */ 3246 3247 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3248 3249 ATF_CHECK(bpf_validate(insns, insn_count)); 3250 3251 code = bpfjit_generate_code(NULL, insns, insn_count); 3252 ATF_REQUIRE(code != NULL); 3253 3254 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3255 3256 bpfjit_free_code(code); 3257 } 3258 3259 ATF_TC(libbpfjit_st3); 3260 ATF_TC_HEAD(libbpfjit_st3, tc) 3261 { 3262 atf_tc_set_md_var(tc, "descr", 3263 "Test JIT compilation of BPF_ST"); 3264 } 3265 3266 ATF_TC_BODY(libbpfjit_st3, tc) 3267 { 3268 static struct bpf_insn insns[] = { 3269 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3270 BPF_STMT(BPF_ST, 0), 3271 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 3272 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3273 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 3274 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 3275 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 3276 BPF_STMT(BPF_RET+BPF_A, 0), 3277 BPF_STMT(BPF_LD+BPF_MEM, 0), 3278 BPF_STMT(BPF_RET+BPF_A, 0) 3279 }; 3280 3281 bpfjit_func_t code; 3282 uint8_t pkt[2]; /* the program doesn't read any data */ 3283 3284 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3285 3286 ATF_REQUIRE(BPF_MEMWORDS > 1); 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 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 3294 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 3295 3296 bpfjit_free_code(code); 3297 } 3298 3299 ATF_TC(libbpfjit_st4); 3300 ATF_TC_HEAD(libbpfjit_st4, tc) 3301 { 3302 atf_tc_set_md_var(tc, "descr", 3303 "Test JIT compilation of BPF_ST"); 3304 } 3305 3306 ATF_TC_BODY(libbpfjit_st4, tc) 3307 { 3308 static struct bpf_insn insns[] = { 3309 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3310 BPF_STMT(BPF_ST, 5), 3311 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 3312 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3313 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 3314 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 3315 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 3316 BPF_STMT(BPF_RET+BPF_A, 0), 3317 BPF_STMT(BPF_LD+BPF_MEM, 5), 3318 BPF_STMT(BPF_RET+BPF_A, 0) 3319 }; 3320 3321 bpfjit_func_t code; 3322 uint8_t pkt[2]; /* the program doesn't read any data */ 3323 3324 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3325 3326 ATF_REQUIRE(BPF_MEMWORDS > 6); 3327 3328 ATF_CHECK(bpf_validate(insns, insn_count)); 3329 3330 code = bpfjit_generate_code(NULL, insns, insn_count); 3331 ATF_REQUIRE(code != NULL); 3332 3333 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 3334 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 3335 3336 bpfjit_free_code(code); 3337 } 3338 3339 ATF_TC(libbpfjit_st5); 3340 ATF_TC_HEAD(libbpfjit_st5, tc) 3341 { 3342 atf_tc_set_md_var(tc, "descr", 3343 "Test JIT compilation of BPF_ST"); 3344 } 3345 3346 ATF_TC_BODY(libbpfjit_st5, tc) 3347 { 3348 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 3349 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3350 3351 size_t k; 3352 bpfjit_func_t code; 3353 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 3354 3355 memset(insns, 0, sizeof(insns)); 3356 3357 /* for each k do M[k] = k */ 3358 for (k = 0; k < BPF_MEMWORDS; k++) { 3359 insns[2*k].code = BPF_LD+BPF_IMM; 3360 insns[2*k].k = 3*k; 3361 insns[2*k+1].code = BPF_ST; 3362 insns[2*k+1].k = k; 3363 } 3364 3365 /* load wirelen into A */ 3366 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 3367 3368 /* for each k, if (A == k + 1) return M[k] */ 3369 for (k = 0; k < BPF_MEMWORDS; k++) { 3370 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 3371 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 3372 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 3373 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 3374 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 3375 insns[2*BPF_MEMWORDS+3*k+2].k = k; 3376 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 3377 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 3378 } 3379 3380 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 3381 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 3382 3383 ATF_CHECK(bpf_validate(insns, insn_count)); 3384 3385 code = bpfjit_generate_code(NULL, insns, insn_count); 3386 ATF_REQUIRE(code != NULL); 3387 3388 for (k = 1; k <= sizeof(pkt); k++) 3389 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 3390 3391 bpfjit_free_code(code); 3392 } 3393 3394 ATF_TC(libbpfjit_stx1); 3395 ATF_TC_HEAD(libbpfjit_stx1, tc) 3396 { 3397 atf_tc_set_md_var(tc, "descr", 3398 "Test JIT compilation of BPF_STX"); 3399 } 3400 3401 ATF_TC_BODY(libbpfjit_stx1, tc) 3402 { 3403 static struct bpf_insn insns[] = { 3404 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3405 BPF_STMT(BPF_STX, 0), 3406 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 3407 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3408 BPF_STMT(BPF_RET+BPF_A, 0) 3409 }; 3410 3411 size_t i; 3412 bpfjit_func_t code; 3413 uint8_t pkt[16]; /* the program doesn't read any data */ 3414 3415 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3416 3417 ATF_CHECK(bpf_validate(insns, insn_count)); 3418 3419 code = bpfjit_generate_code(NULL, insns, insn_count); 3420 ATF_REQUIRE(code != NULL); 3421 3422 for (i = 1; i <= sizeof(pkt); i++) 3423 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 3424 3425 bpfjit_free_code(code); 3426 } 3427 3428 ATF_TC(libbpfjit_stx2); 3429 ATF_TC_HEAD(libbpfjit_stx2, tc) 3430 { 3431 atf_tc_set_md_var(tc, "descr", 3432 "Test JIT compilation of BPF_STX"); 3433 } 3434 3435 ATF_TC_BODY(libbpfjit_stx2, tc) 3436 { 3437 static struct bpf_insn insns[] = { 3438 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3439 BPF_STMT(BPF_STX, BPF_MEMWORDS-1), 3440 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 3441 BPF_STMT(BPF_MISC+BPF_TXA, 0), 3442 BPF_STMT(BPF_RET+BPF_A, 0) 3443 }; 3444 3445 bpfjit_func_t code; 3446 uint8_t pkt[1]; /* the program doesn't read any data */ 3447 3448 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3449 3450 ATF_CHECK(bpf_validate(insns, insn_count)); 3451 3452 code = bpfjit_generate_code(NULL, insns, insn_count); 3453 ATF_REQUIRE(code != NULL); 3454 3455 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3456 3457 bpfjit_free_code(code); 3458 } 3459 3460 ATF_TC(libbpfjit_stx3); 3461 ATF_TC_HEAD(libbpfjit_stx3, tc) 3462 { 3463 atf_tc_set_md_var(tc, "descr", 3464 "Test JIT compilation of BPF_STX"); 3465 } 3466 3467 ATF_TC_BODY(libbpfjit_stx3, tc) 3468 { 3469 static struct bpf_insn insns[] = { 3470 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3471 BPF_STMT(BPF_STX, 5), 3472 BPF_STMT(BPF_STX, 2), 3473 BPF_STMT(BPF_STX, 3), 3474 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 1), 3475 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3476 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 2), 3477 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3478 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 3479 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3480 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 5), 3481 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3482 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 6), 3483 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3484 BPF_STMT(BPF_RET+BPF_A, 0) 3485 }; 3486 3487 size_t i; 3488 bpfjit_func_t code; 3489 uint8_t pkt[16]; /* the program doesn't read any data */ 3490 3491 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3492 3493 ATF_CHECK(bpf_validate(insns, insn_count)); 3494 3495 code = bpfjit_generate_code(NULL, insns, insn_count); 3496 ATF_REQUIRE(code != NULL); 3497 3498 for (i = 1; i <= sizeof(pkt); i++) 3499 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == 3 * i); 3500 3501 bpfjit_free_code(code); 3502 } 3503 3504 ATF_TC(libbpfjit_stx4); 3505 ATF_TC_HEAD(libbpfjit_stx4, tc) 3506 { 3507 atf_tc_set_md_var(tc, "descr", 3508 "Test JIT compilation of BPF_STX"); 3509 } 3510 3511 ATF_TC_BODY(libbpfjit_stx4, tc) 3512 { 3513 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 3514 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3515 3516 size_t k; 3517 bpfjit_func_t code; 3518 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 3519 3520 memset(insns, 0, sizeof(insns)); 3521 3522 /* for each k do M[k] = k */ 3523 for (k = 0; k < BPF_MEMWORDS; k++) { 3524 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM; 3525 insns[2*k].k = 3*k; 3526 insns[2*k+1].code = BPF_STX; 3527 insns[2*k+1].k = k; 3528 } 3529 3530 /* load wirelen into A */ 3531 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 3532 3533 /* for each k, if (A == k + 1) return M[k] */ 3534 for (k = 0; k < BPF_MEMWORDS; k++) { 3535 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 3536 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 3537 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 3538 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 3539 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 3540 insns[2*BPF_MEMWORDS+3*k+2].k = k; 3541 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 3542 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 3543 } 3544 3545 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 3546 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 3547 3548 ATF_CHECK(bpf_validate(insns, insn_count)); 3549 3550 code = bpfjit_generate_code(NULL, insns, insn_count); 3551 ATF_REQUIRE(code != NULL); 3552 3553 for (k = 1; k <= sizeof(pkt); k++) 3554 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 3555 3556 bpfjit_free_code(code); 3557 } 3558 3559 ATF_TC(libbpfjit_opt_ld_abs_1); 3560 ATF_TC_HEAD(libbpfjit_opt_ld_abs_1, tc) 3561 { 3562 atf_tc_set_md_var(tc, "descr", 3563 "Test JIT compilation with length optimization " 3564 "applied to BPF_LD+BPF_ABS"); 3565 } 3566 3567 ATF_TC_BODY(libbpfjit_opt_ld_abs_1, tc) 3568 { 3569 static struct bpf_insn insns[] = { 3570 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3571 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3572 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3573 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3574 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3575 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3576 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3577 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3578 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3579 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3580 BPF_STMT(BPF_RET+BPF_K, 0), 3581 }; 3582 3583 size_t i, j; 3584 bpfjit_func_t code; 3585 uint8_t pkt[2][34] = { 3586 { 3587 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3588 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3589 0x80, 0x03, 0x70, 0x0f, 3590 0x80, 0x03, 0x70, 0x23 3591 }, 3592 { 3593 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3594 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3595 0x80, 0x03, 0x70, 0x23, 3596 0x80, 0x03, 0x70, 0x0f 3597 } 3598 }; 3599 3600 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3601 3602 ATF_CHECK(bpf_validate(insns, insn_count)); 3603 3604 code = bpfjit_generate_code(NULL, insns, insn_count); 3605 ATF_REQUIRE(code != NULL); 3606 3607 for (i = 0; i < 2; i++) { 3608 for (j = 1; j < sizeof(pkt[i]); j++) 3609 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3610 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3611 } 3612 3613 bpfjit_free_code(code); 3614 } 3615 3616 ATF_TC(libbpfjit_opt_ld_abs_2); 3617 ATF_TC_HEAD(libbpfjit_opt_ld_abs_2, tc) 3618 { 3619 atf_tc_set_md_var(tc, "descr", 3620 "Test JIT compilation with length optimization " 3621 "applied to BPF_LD+BPF_ABS"); 3622 } 3623 3624 ATF_TC_BODY(libbpfjit_opt_ld_abs_2, tc) 3625 { 3626 static struct bpf_insn insns[] = { 3627 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3628 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3629 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3630 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3631 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3632 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3633 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3634 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3635 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3636 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3637 BPF_STMT(BPF_RET+BPF_K, 0), 3638 }; 3639 3640 size_t i, j; 3641 bpfjit_func_t code; 3642 uint8_t pkt[2][34] = { 3643 { 3644 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3645 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3646 0x80, 0x03, 0x70, 0x0f, 3647 0x80, 0x03, 0x70, 0x23 3648 }, 3649 { 3650 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3651 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3652 0x80, 0x03, 0x70, 0x23, 3653 0x80, 0x03, 0x70, 0x0f 3654 } 3655 }; 3656 3657 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3658 3659 ATF_CHECK(bpf_validate(insns, insn_count)); 3660 3661 code = bpfjit_generate_code(NULL, insns, insn_count); 3662 ATF_REQUIRE(code != NULL); 3663 3664 for (i = 0; i < 2; i++) { 3665 for (j = 1; j < sizeof(pkt[i]); j++) 3666 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3667 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3668 } 3669 3670 bpfjit_free_code(code); 3671 } 3672 3673 ATF_TC(libbpfjit_opt_ld_abs_3); 3674 ATF_TC_HEAD(libbpfjit_opt_ld_abs_3, tc) 3675 { 3676 atf_tc_set_md_var(tc, "descr", 3677 "Test JIT compilation with length optimization " 3678 "applied to BPF_LD+BPF_ABS"); 3679 } 3680 3681 ATF_TC_BODY(libbpfjit_opt_ld_abs_3, tc) 3682 { 3683 static struct bpf_insn insns[] = { 3684 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3685 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3686 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3687 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 6), 3688 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 5), 3689 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3690 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3691 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3692 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3693 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3694 BPF_STMT(BPF_RET+BPF_K, 0), 3695 }; 3696 3697 size_t i, j; 3698 bpfjit_func_t code; 3699 uint8_t pkt[2][34] = { 3700 { 3701 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3702 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3703 0x80, 0x03, 0x70, 0x0f, 3704 0x80, 0x03, 0x70, 0x23 3705 }, 3706 { 3707 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3708 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3709 0x80, 0x03, 0x70, 0x23, 3710 0x80, 0x03, 0x70, 0x0f 3711 } 3712 }; 3713 3714 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3715 3716 ATF_CHECK(bpf_validate(insns, insn_count)); 3717 3718 code = bpfjit_generate_code(NULL, insns, insn_count); 3719 ATF_REQUIRE(code != NULL); 3720 3721 for (i = 0; i < 2; i++) { 3722 for (j = 1; j < sizeof(pkt[i]); j++) 3723 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3724 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3725 } 3726 3727 bpfjit_free_code(code); 3728 } 3729 3730 ATF_TC(libbpfjit_opt_ld_ind_1); 3731 ATF_TC_HEAD(libbpfjit_opt_ld_ind_1, tc) 3732 { 3733 atf_tc_set_md_var(tc, "descr", 3734 "Test JIT compilation with length optimization " 3735 "applied to BPF_LD+BPF_IND"); 3736 } 3737 3738 ATF_TC_BODY(libbpfjit_opt_ld_ind_1, tc) 3739 { 3740 static struct bpf_insn insns[] = { 3741 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 12), 3742 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 3743 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3744 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 14), 3745 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3746 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3747 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3748 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3749 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3750 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3751 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3752 BPF_STMT(BPF_RET+BPF_K, 0), 3753 }; 3754 3755 size_t i, j; 3756 bpfjit_func_t code; 3757 uint8_t pkt[2][34] = { 3758 { 3759 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3760 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3761 0x80, 0x03, 0x70, 0x0f, 3762 0x80, 0x03, 0x70, 0x23 3763 }, 3764 { 3765 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3766 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3767 0x80, 0x03, 0x70, 0x23, 3768 0x80, 0x03, 0x70, 0x0f 3769 } 3770 }; 3771 3772 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3773 3774 ATF_CHECK(bpf_validate(insns, insn_count)); 3775 3776 code = bpfjit_generate_code(NULL, insns, insn_count); 3777 ATF_REQUIRE(code != NULL); 3778 3779 for (i = 0; i < 2; i++) { 3780 for (j = 1; j < sizeof(pkt[i]); j++) 3781 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3782 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3783 } 3784 3785 bpfjit_free_code(code); 3786 } 3787 3788 ATF_TC(libbpfjit_opt_ld_ind_2); 3789 ATF_TC_HEAD(libbpfjit_opt_ld_ind_2, tc) 3790 { 3791 atf_tc_set_md_var(tc, "descr", 3792 "Test JIT compilation with length optimization " 3793 "applied to BPF_LD+BPF_IND"); 3794 } 3795 3796 ATF_TC_BODY(libbpfjit_opt_ld_ind_2, tc) 3797 { 3798 static struct bpf_insn insns[] = { 3799 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3800 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 26), 3801 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3802 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3803 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3804 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3805 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3806 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3807 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3808 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3809 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3810 BPF_STMT(BPF_RET+BPF_K, 0), 3811 }; 3812 3813 size_t i, j; 3814 bpfjit_func_t code; 3815 uint8_t pkt[2][34] = { 3816 { 3817 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3818 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3819 0x80, 0x03, 0x70, 0x0f, 3820 0x80, 0x03, 0x70, 0x23 3821 }, 3822 { 3823 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3824 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3825 0x80, 0x03, 0x70, 0x23, 3826 0x80, 0x03, 0x70, 0x0f 3827 } 3828 }; 3829 3830 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3831 3832 ATF_CHECK(bpf_validate(insns, insn_count)); 3833 3834 code = bpfjit_generate_code(NULL, insns, insn_count); 3835 ATF_REQUIRE(code != NULL); 3836 3837 for (i = 0; i < 2; i++) { 3838 for (j = 1; j < sizeof(pkt[i]); j++) 3839 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3840 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3841 } 3842 3843 bpfjit_free_code(code); 3844 } 3845 3846 ATF_TC(libbpfjit_opt_ld_ind_3); 3847 ATF_TC_HEAD(libbpfjit_opt_ld_ind_3, tc) 3848 { 3849 atf_tc_set_md_var(tc, "descr", 3850 "Test JIT compilation with length optimization " 3851 "applied to BPF_LD+BPF_IND"); 3852 } 3853 3854 ATF_TC_BODY(libbpfjit_opt_ld_ind_3, tc) 3855 { 3856 static struct bpf_insn insns[] = { 3857 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 15), 3858 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3859 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3860 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3861 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3862 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3863 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3864 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3865 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3866 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3867 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3868 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3869 BPF_STMT(BPF_RET+BPF_K, 0), 3870 }; 3871 3872 size_t i, j; 3873 bpfjit_func_t code; 3874 uint8_t pkt[2][34] = { 3875 { 3876 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3877 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3878 0x80, 0x03, 0x70, 0x0f, 3879 0x80, 0x03, 0x70, 0x23 3880 }, 3881 { 3882 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3883 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3884 0x80, 0x03, 0x70, 0x23, 3885 0x80, 0x03, 0x70, 0x0f 3886 } 3887 }; 3888 3889 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3890 3891 ATF_CHECK(bpf_validate(insns, insn_count)); 3892 3893 code = bpfjit_generate_code(NULL, insns, insn_count); 3894 ATF_REQUIRE(code != NULL); 3895 3896 for (i = 0; i < 2; i++) { 3897 for (j = 1; j < sizeof(pkt[i]); j++) 3898 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3899 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3900 } 3901 3902 bpfjit_free_code(code); 3903 } 3904 3905 ATF_TC(libbpfjit_opt_ld_ind_4); 3906 ATF_TC_HEAD(libbpfjit_opt_ld_ind_4, tc) 3907 { 3908 atf_tc_set_md_var(tc, "descr", 3909 "Test JIT compilation with length optimization " 3910 "applied to BPF_LD+BPF_IND"); 3911 } 3912 3913 ATF_TC_BODY(libbpfjit_opt_ld_ind_4, tc) 3914 { 3915 static struct bpf_insn insns[] = { 3916 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 11), 3917 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 19), 3918 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3919 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3920 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3921 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3922 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3923 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3924 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3925 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3926 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3927 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3928 BPF_STMT(BPF_RET+BPF_K, 0), 3929 }; 3930 3931 size_t i, j; 3932 bpfjit_func_t code; 3933 uint8_t pkt[2][34] = { 3934 { 3935 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3936 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3937 0x80, 0x03, 0x70, 0x0f, 3938 0x80, 0x03, 0x70, 0x23 3939 }, 3940 { 3941 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3942 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3943 0x80, 0x03, 0x70, 0x23, 3944 0x80, 0x03, 0x70, 0x0f 3945 } 3946 }; 3947 3948 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3949 3950 ATF_CHECK(bpf_validate(insns, insn_count)); 3951 3952 code = bpfjit_generate_code(NULL, insns, insn_count); 3953 ATF_REQUIRE(code != NULL); 3954 3955 for (i = 0; i < 2; i++) { 3956 for (j = 1; j < sizeof(pkt[i]); j++) 3957 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3958 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3959 } 3960 3961 bpfjit_free_code(code); 3962 } 3963 3964 ATF_TC(libbpfjit_abc_ja); 3965 ATF_TC_HEAD(libbpfjit_abc_ja, tc) 3966 { 3967 atf_tc_set_md_var(tc, "descr", 3968 "Test ABC optimization with a single BPF_JMP+BPF_JA"); 3969 } 3970 3971 ATF_TC_BODY(libbpfjit_abc_ja, tc) 3972 { 3973 static struct bpf_insn insns[] = { 3974 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 3975 BPF_STMT(BPF_JMP+BPF_JA, 2), 3976 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, UINT32_MAX - 1), 3977 BPF_STMT(BPF_RET+BPF_K, 0), 3978 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2), /* min. length 6 */ 3979 BPF_STMT(BPF_RET+BPF_A, 0), 3980 BPF_STMT(BPF_RET+BPF_K, 1), 3981 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 3982 BPF_STMT(BPF_RET+BPF_K, 2), 3983 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 3984 BPF_STMT(BPF_RET+BPF_K, 3), 3985 }; 3986 3987 bpfjit_func_t code; 3988 uint8_t pkt[6] = {0, 0, /* UINT32_MAX: */ 255, 255, 255, 255}; 3989 3990 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3991 3992 ATF_CHECK(bpf_validate(insns, insn_count)); 3993 3994 code = bpfjit_generate_code(NULL, insns, insn_count); 3995 ATF_REQUIRE(code != NULL); 3996 3997 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3998 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 3999 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4000 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4001 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4002 ATF_CHECK(jitcall(code, pkt, 6, 6) == UINT32_MAX); 4003 4004 bpfjit_free_code(code); 4005 } 4006 4007 ATF_TC(libbpfjit_abc_ja_over); 4008 ATF_TC_HEAD(libbpfjit_abc_ja_over, tc) 4009 { 4010 atf_tc_set_md_var(tc, "descr", 4011 "Test ABC optimization when BPF_JMP+BPF_JA jumps over all loads"); 4012 } 4013 4014 ATF_TC_BODY(libbpfjit_abc_ja_over, tc) 4015 { 4016 static struct bpf_insn insns[] = { 4017 BPF_STMT(BPF_JMP+BPF_JA, 2), 4018 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), 4019 BPF_STMT(BPF_RET+BPF_K, 0), 4020 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4021 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), 4022 BPF_STMT(BPF_RET+BPF_K, 1), 4023 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 4024 BPF_STMT(BPF_RET+BPF_K, 2), 4025 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 4026 BPF_STMT(BPF_RET+BPF_K, 3), 4027 }; 4028 4029 bpfjit_func_t code; 4030 uint8_t pkt[1]; /* the program doesn't read any data */ 4031 4032 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4033 4034 ATF_CHECK(bpf_validate(insns, insn_count)); 4035 4036 code = bpfjit_generate_code(NULL, insns, insn_count); 4037 ATF_REQUIRE(code != NULL); 4038 4039 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 4040 4041 bpfjit_free_code(code); 4042 } 4043 4044 ATF_TC(libbpfjit_abc_ld_chain); 4045 ATF_TC_HEAD(libbpfjit_abc_ld_chain, tc) 4046 { 4047 atf_tc_set_md_var(tc, "descr", 4048 "Test ABC optimization of a chain of BPF_LD instructions " 4049 "with exits leading to a single BPF_RET"); 4050 } 4051 4052 ATF_TC_BODY(libbpfjit_abc_ld_chain, tc) 4053 { 4054 static struct bpf_insn insns[] = { 4055 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 4056 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 4), 4057 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* min. length 6 */ 4058 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 0, 2), 4059 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 6), /* min. length 10 */ 4060 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 0, 1), 4061 BPF_STMT(BPF_RET+BPF_K, 123456789), 4062 BPF_STMT(BPF_RET+BPF_K, 987654321), 4063 }; 4064 4065 bpfjit_func_t code; 4066 uint8_t pkt[10] = {}; 4067 4068 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4069 4070 ATF_CHECK(bpf_validate(insns, insn_count)); 4071 4072 code = bpfjit_generate_code(NULL, insns, insn_count); 4073 ATF_REQUIRE(code != NULL); 4074 4075 /* Packet is too short. */ 4076 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4077 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4078 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4079 4080 /* !(pkt[3] == 8) => return 123456789 */ 4081 ATF_CHECK(jitcall(code, pkt, 4, 4) == 123456789); 4082 ATF_CHECK(jitcall(code, pkt, 5, 5) == 123456789); 4083 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 4084 ATF_CHECK(jitcall(code, pkt, 7, 7) == 123456789); 4085 ATF_CHECK(jitcall(code, pkt, 8, 8) == 123456789); 4086 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 4087 4088 /* !(pkt[4:2] >= 7) => too short or return 123456789 */ 4089 pkt[3] = 8; 4090 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4091 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4092 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4093 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4094 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4095 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 4096 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 4097 4098 /* !(pkt[6:4] > 6) => too short or return 987654321 */ 4099 pkt[4] = pkt[5] = 1; 4100 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4101 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4102 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4103 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4104 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4105 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4106 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4107 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4108 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4109 ATF_CHECK(jitcall(code, pkt, 10, 10) == 987654321); 4110 4111 /* (pkt[6:4] > 6) => too short or return 123456789 */ 4112 pkt[6] = pkt[7] = pkt[8] = pkt[9] = 1; 4113 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4114 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4115 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4116 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4117 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4118 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4119 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4120 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4121 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4122 ATF_CHECK(jitcall(code, pkt, 10, 10) == 123456789); 4123 4124 bpfjit_free_code(code); 4125 } 4126 4127 ATF_TC(libbpfjit_examples_1); 4128 ATF_TC_HEAD(libbpfjit_examples_1, tc) 4129 { 4130 atf_tc_set_md_var(tc, "descr", 4131 "Test the first example from bpf(4) - " 4132 "accept Reverse ARP requests"); 4133 } 4134 4135 ATF_TC_BODY(libbpfjit_examples_1, tc) 4136 { 4137 /* 4138 * The following filter is taken from the Reverse ARP 4139 * Daemon. It accepts only Reverse ARP requests. 4140 */ 4141 struct bpf_insn insns[] = { 4142 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4143 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8035, 0, 3), 4144 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 4145 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 0, 1), 4146 BPF_STMT(BPF_RET+BPF_K, 42), 4147 BPF_STMT(BPF_RET+BPF_K, 0), 4148 }; 4149 4150 bpfjit_func_t code; 4151 uint8_t pkt[22] = {}; 4152 4153 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4154 4155 ATF_CHECK(bpf_validate(insns, insn_count)); 4156 4157 code = bpfjit_generate_code(NULL, insns, insn_count); 4158 ATF_REQUIRE(code != NULL); 4159 4160 /* Packet is too short. */ 4161 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4162 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4163 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4164 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4165 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4166 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4167 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4168 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4169 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4170 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4171 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4172 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4173 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4174 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4175 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4176 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4177 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4178 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4179 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4180 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4181 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4182 4183 /* The packet doesn't match. */ 4184 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4185 4186 /* Still no match after setting the protocol field. */ 4187 pkt[12] = 0x80; pkt[13] = 0x35; 4188 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4189 4190 /* Set RARP message type. */ 4191 pkt[21] = 3; 4192 ATF_CHECK(jitcall(code, pkt, 22, 22) == 42); 4193 4194 /* Packet is too short. */ 4195 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4196 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4197 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4198 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4199 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4200 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4201 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4202 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4203 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4204 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4205 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4206 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4207 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4208 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4209 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4210 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4211 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4212 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4213 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4214 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4215 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4216 4217 /* Change RARP message type. */ 4218 pkt[20] = 3; 4219 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4220 4221 bpfjit_free_code(code); 4222 } 4223 4224 ATF_TC(libbpfjit_examples_2); 4225 ATF_TC_HEAD(libbpfjit_examples_2, tc) 4226 { 4227 atf_tc_set_md_var(tc, "descr", 4228 "Test the second example from bpf(4) - " 4229 "accept IP packets between two specified hosts"); 4230 } 4231 4232 ATF_TC_BODY(libbpfjit_examples_2, tc) 4233 { 4234 /* 4235 * This filter accepts only IP packets between host 128.3.112.15 4236 * and 128.3.112.35. 4237 */ 4238 static struct bpf_insn insns[] = { 4239 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4240 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 8), 4241 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 4242 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 4243 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 4244 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 4245 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 4246 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 4247 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 4248 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4249 BPF_STMT(BPF_RET+BPF_K, 0), 4250 }; 4251 4252 bpfjit_func_t code; 4253 uint8_t pkt[34] = {}; 4254 4255 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4256 4257 ATF_CHECK(bpf_validate(insns, insn_count)); 4258 4259 code = bpfjit_generate_code(NULL, insns, insn_count); 4260 ATF_REQUIRE(code != NULL); 4261 4262 /* Packet is too short. */ 4263 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4264 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4265 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4266 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4267 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4268 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4269 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4270 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4271 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4272 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4273 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4274 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4275 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4276 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4277 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4278 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4279 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4280 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4281 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4282 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4283 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4284 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4285 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4286 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4287 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4288 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4289 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4290 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4291 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4292 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4293 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 4294 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 4295 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 4296 4297 /* The packet doesn't match. */ 4298 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4299 4300 /* Still no match after setting the protocol field. */ 4301 pkt[12] = 8; 4302 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4303 4304 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 15; 4305 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4306 4307 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 35; 4308 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 4309 4310 /* Swap the ip addresses. */ 4311 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 35; 4312 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4313 4314 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 15; 4315 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 4316 4317 /* Packet is too short. */ 4318 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4319 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4320 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4321 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4322 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4323 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4324 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4325 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4326 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4327 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4328 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4329 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4330 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4331 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4332 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4333 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4334 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4335 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4336 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4337 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4338 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4339 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4340 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4341 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4342 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4343 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4344 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4345 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4346 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4347 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4348 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 4349 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 4350 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 4351 4352 /* Change the protocol field. */ 4353 pkt[13] = 8; 4354 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4355 4356 bpfjit_free_code(code); 4357 } 4358 4359 ATF_TC(libbpfjit_examples_3); 4360 ATF_TC_HEAD(libbpfjit_examples_3, tc) 4361 { 4362 atf_tc_set_md_var(tc, "descr", 4363 "Test the third example from bpf(4) - " 4364 "accept TCP finger packets"); 4365 } 4366 4367 ATF_TC_BODY(libbpfjit_examples_3, tc) 4368 { 4369 /* 4370 * This filter returns only TCP finger packets. 4371 */ 4372 struct bpf_insn insns[] = { 4373 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4374 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 10), 4375 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 23), 4376 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 0, 8), 4377 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 4378 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 0x1fff, 6, 0), 4379 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 14), 4380 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 14), 4381 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 2, 0), 4382 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 16), 4383 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 0, 1), 4384 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4385 BPF_STMT(BPF_RET+BPF_K, 0), 4386 }; 4387 4388 bpfjit_func_t code; 4389 uint8_t pkt[30] = {}; 4390 4391 /* Set IP fragment offset to non-zero. */ 4392 pkt[20] = 1; pkt[21] = 1; 4393 4394 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4395 4396 ATF_CHECK(bpf_validate(insns, insn_count)); 4397 4398 code = bpfjit_generate_code(NULL, insns, insn_count); 4399 ATF_REQUIRE(code != NULL); 4400 4401 /* Packet is too short. */ 4402 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4403 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4404 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4405 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4406 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4407 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4408 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4409 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4410 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4411 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4412 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4413 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4414 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4415 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4416 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4417 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4418 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4419 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4420 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4421 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4422 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4423 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4424 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4425 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4426 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4427 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4428 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4429 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4430 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4431 4432 /* The packet doesn't match. */ 4433 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4434 4435 /* Still no match after setting the protocol field. */ 4436 pkt[12] = 8; 4437 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4438 4439 /* Get one step closer to the match. */ 4440 pkt[23] = 6; 4441 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4442 4443 /* Set IP fragment offset to zero. */ 4444 pkt[20] = 0x20; pkt[21] = 0; 4445 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4446 4447 /* Set IP header length to 12. */ 4448 pkt[14] = 0xd3; 4449 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4450 4451 /* Match one branch of the program. */ 4452 pkt[27] = 79; 4453 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 4454 4455 /* Match the other branch of the program. */ 4456 pkt[29] = 79; pkt[27] = 0; 4457 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 4458 4459 /* Packet is too short. */ 4460 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4461 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4462 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4463 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4464 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4465 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4466 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4467 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4468 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4469 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4470 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4471 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4472 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4473 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4474 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4475 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4476 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4477 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4478 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4479 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4480 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4481 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4482 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4483 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4484 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4485 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4486 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4487 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4488 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4489 4490 /* Set IP header length to 16. Packet is too short. */ 4491 pkt[14] = 4; 4492 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4493 4494 bpfjit_free_code(code); 4495 } 4496 4497 ATF_TC(libbpfjit_cop_no_ctx); 4498 ATF_TC_HEAD(libbpfjit_cop_no_ctx, tc) 4499 { 4500 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COP " 4501 "instruction can't be accepted without a context"); 4502 } 4503 4504 ATF_TC_BODY(libbpfjit_cop_no_ctx, tc) 4505 { 4506 static struct bpf_insn insns[] = { 4507 BPF_STMT(BPF_MISC+BPF_COP, 0), 4508 BPF_STMT(BPF_RET+BPF_K, 7) 4509 }; 4510 4511 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4512 4513 ATF_CHECK(!bpf_validate(insns, insn_count)); 4514 4515 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 4516 } 4517 4518 ATF_TC(libbpfjit_copx_no_ctx); 4519 ATF_TC_HEAD(libbpfjit_copx_no_ctx, tc) 4520 { 4521 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COPX " 4522 "instruction can't be accepted without a context"); 4523 } 4524 4525 ATF_TC_BODY(libbpfjit_copx_no_ctx, tc) 4526 { 4527 static struct bpf_insn insns[] = { 4528 BPF_STMT(BPF_MISC+BPF_COPX, 0), 4529 BPF_STMT(BPF_RET+BPF_K, 7) 4530 }; 4531 4532 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4533 4534 ATF_CHECK(!bpf_validate(insns, insn_count)); 4535 4536 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 4537 } 4538 4539 ATF_TP_ADD_TCS(tp) 4540 { 4541 4542 /* 4543 * For every new test please also add a similar test 4544 * to ../../net/bpfjit/t_bpfjit.c 4545 */ 4546 ATF_TP_ADD_TC(tp, libbpfjit_empty); 4547 ATF_TP_ADD_TC(tp, libbpfjit_ret_k); 4548 ATF_TP_ADD_TC(tp, libbpfjit_bad_ret_k); 4549 ATF_TP_ADD_TC(tp, libbpfjit_alu_add_k); 4550 ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_k); 4551 ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_k); 4552 ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_k); 4553 ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_k); 4554 ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_k); 4555 ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_k); 4556 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_k); 4557 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_k); 4558 ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_k); 4559 ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_k); 4560 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod0_k); 4561 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod1_k); 4562 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod2_k); 4563 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod4_k); 4564 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10_k); 4565 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10000_k); 4566 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod7609801_k); 4567 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod80000000_k); 4568 ATF_TP_ADD_TC(tp, libbpfjit_alu_and_k); 4569 ATF_TP_ADD_TC(tp, libbpfjit_alu_or_k); 4570 ATF_TP_ADD_TC(tp, libbpfjit_alu_xor_k); 4571 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_k); 4572 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_k); 4573 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_k); 4574 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_k); 4575 ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_k); 4576 ATF_TP_ADD_TC(tp, libbpfjit_alu_add_x); 4577 ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_x); 4578 ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_x); 4579 ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_x); 4580 ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_x); 4581 ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_x); 4582 ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_x); 4583 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_x); 4584 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_x); 4585 ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_x); 4586 ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_x); 4587 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod0_x); 4588 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod1_x); 4589 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod2_x); 4590 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod4_x); 4591 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10_x); 4592 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10000_x); 4593 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod7609801_x); 4594 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod80000000_x); 4595 ATF_TP_ADD_TC(tp, libbpfjit_alu_and_x); 4596 ATF_TP_ADD_TC(tp, libbpfjit_alu_or_x); 4597 ATF_TP_ADD_TC(tp, libbpfjit_alu_xor_x); 4598 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_x); 4599 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_x); 4600 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_x); 4601 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_x); 4602 ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_x); 4603 ATF_TP_ADD_TC(tp, libbpfjit_alu_neg); 4604 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja); 4605 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja_invalid); 4606 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja_overflow); 4607 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_k); 4608 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_k); 4609 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_k); 4610 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_k); 4611 ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_k); 4612 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_x); 4613 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_x); 4614 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_x); 4615 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_x); 4616 ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_x); 4617 ATF_TP_ADD_TC(tp, libbpfjit_ld_abs); 4618 ATF_TP_ADD_TC(tp, libbpfjit_ld_abs_k_overflow); 4619 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind); 4620 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_k_overflow); 4621 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow1); 4622 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow2); 4623 ATF_TP_ADD_TC(tp, libbpfjit_ld_len); 4624 ATF_TP_ADD_TC(tp, libbpfjit_ld_imm); 4625 ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm1); 4626 ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm2); 4627 ATF_TP_ADD_TC(tp, libbpfjit_ldx_len1); 4628 ATF_TP_ADD_TC(tp, libbpfjit_ldx_len2); 4629 ATF_TP_ADD_TC(tp, libbpfjit_ldx_msh); 4630 ATF_TP_ADD_TC(tp, libbpfjit_misc_tax); 4631 ATF_TP_ADD_TC(tp, libbpfjit_misc_txa); 4632 ATF_TP_ADD_TC(tp, libbpfjit_st1); 4633 ATF_TP_ADD_TC(tp, libbpfjit_st2); 4634 ATF_TP_ADD_TC(tp, libbpfjit_st3); 4635 ATF_TP_ADD_TC(tp, libbpfjit_st4); 4636 ATF_TP_ADD_TC(tp, libbpfjit_st5); 4637 ATF_TP_ADD_TC(tp, libbpfjit_stx1); 4638 ATF_TP_ADD_TC(tp, libbpfjit_stx2); 4639 ATF_TP_ADD_TC(tp, libbpfjit_stx3); 4640 ATF_TP_ADD_TC(tp, libbpfjit_stx4); 4641 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_1); 4642 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_2); 4643 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_3); 4644 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_1); 4645 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_2); 4646 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_3); 4647 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_4); 4648 ATF_TP_ADD_TC(tp, libbpfjit_abc_ja); 4649 ATF_TP_ADD_TC(tp, libbpfjit_abc_ja_over); 4650 ATF_TP_ADD_TC(tp, libbpfjit_abc_ld_chain); 4651 ATF_TP_ADD_TC(tp, libbpfjit_examples_1); 4652 ATF_TP_ADD_TC(tp, libbpfjit_examples_2); 4653 ATF_TP_ADD_TC(tp, libbpfjit_examples_3); 4654 ATF_TP_ADD_TC(tp, libbpfjit_cop_no_ctx); 4655 ATF_TP_ADD_TC(tp, libbpfjit_copx_no_ctx); 4656 4657 return atf_no_error(); 4658 } 4659
Indexes created Wed Sep 24 05:09:52 GMT 2025