t_bpfjit.c revision 1.12
1 /* $NetBSD: t_bpfjit.c,v 1.12 2015/02/14 20:29:36 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.12 2015/02/14 20:29:36 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, 1), 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, 2), 2363 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2364 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1), 2365 BPF_STMT(BPF_RET+BPF_K, 3), 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, 4), 2369 BPF_STMT(BPF_RET+BPF_K, 5), 2370 BPF_STMT(BPF_RET+BPF_K, 6), 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, 7), 2374 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2375 BPF_STMT(BPF_RET+BPF_K, 8), 2376 BPF_STMT(BPF_RET+BPF_K, 9) 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) == 8); 2390 ATF_CHECK(jitcall(code, pkt, 2, 2) == 8); 2391 ATF_CHECK(jitcall(code, pkt, 3, 3) == 2); 2392 ATF_CHECK(jitcall(code, pkt, 4, 4) == 8); 2393 ATF_CHECK(jitcall(code, pkt, 5, 5) == 3); 2394 ATF_CHECK(jitcall(code, pkt, 6, 6) == 9); 2395 ATF_CHECK(jitcall(code, pkt, 7, 7) == 6); 2396 ATF_CHECK(jitcall(code, pkt, 8, 8) == 1); 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_x_uninitialised); 2459 ATF_TC_HEAD(libbpfjit_jmp_x_uninitialised, tc) 2460 { 2461 atf_tc_set_md_var(tc, "descr", "Test JIT compilation " 2462 "of BPF_JMP+BPF_EQ+BPF_X with uninitialised X"); 2463 } 2464 2465 ATF_TC_BODY(libbpfjit_jmp_x_uninitialised, tc) 2466 { 2467 static struct bpf_insn insns[] = { 2468 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), /* A > 0 */ 2469 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1), 2470 BPF_STMT(BPF_RET+BPF_K, 11), 2471 BPF_STMT(BPF_RET+BPF_K, 10) 2472 }; 2473 2474 bpfjit_func_t code; 2475 uint8_t pkt[8]; /* the program doesn't read any data */ 2476 2477 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2478 2479 ATF_CHECK(bpf_validate(insns, insn_count)); 2480 2481 code = bpfjit_generate_code(NULL, insns, insn_count); 2482 ATF_REQUIRE(code != NULL); 2483 2484 ATF_CHECK(jitcall(code, pkt, 1, 1) == 10); 2485 2486 bpfjit_free_code(code); 2487 } 2488 2489 ATF_TC(libbpfjit_jmp_modulo_x); 2490 ATF_TC_HEAD(libbpfjit_jmp_modulo_x, tc) 2491 { 2492 atf_tc_set_md_var(tc, "descr", 2493 "Test JIT compilation of modulo logic of BPF_JMP+BPF_X operations"); 2494 } 2495 2496 ATF_TC_BODY(libbpfjit_jmp_modulo_x, tc) 2497 { 2498 static struct bpf_insn insns[] = { 2499 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 2500 /* FFFFF770 << 4 = FFFFF770 */ 2501 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 2502 2503 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 2504 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2505 BPF_STMT(BPF_RET+BPF_K, 0), 2506 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 2507 BPF_STMT(BPF_RET+BPF_K, 1), 2508 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 2509 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 2510 BPF_STMT(BPF_RET+BPF_K, 2), 2511 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 2512 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 2513 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 2514 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 2515 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 2516 BPF_STMT(BPF_JMP+BPF_JA, 1), 2517 BPF_STMT(BPF_RET+BPF_K, 3), 2518 2519 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 2520 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 2521 2522 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 2523 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2524 BPF_STMT(BPF_RET+BPF_K, 4), 2525 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 2526 BPF_STMT(BPF_RET+BPF_K, 5), 2527 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 2528 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 2529 BPF_STMT(BPF_RET+BPF_K, 6), 2530 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 2531 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 2532 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 2533 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 2534 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 2535 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2536 BPF_STMT(BPF_RET+BPF_K, 7) 2537 }; 2538 2539 bpfjit_func_t code; 2540 uint8_t pkt[1]; /* the program doesn't read any data */ 2541 2542 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2543 2544 ATF_CHECK(bpf_validate(insns, insn_count)); 2545 2546 code = bpfjit_generate_code(NULL, insns, insn_count); 2547 ATF_REQUIRE(code != NULL); 2548 2549 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 2550 2551 bpfjit_free_code(code); 2552 } 2553 2554 ATF_TC(libbpfjit_ld_abs); 2555 ATF_TC_HEAD(libbpfjit_ld_abs, tc) 2556 { 2557 atf_tc_set_md_var(tc, "descr", 2558 "Test JIT compilation of BPF_LD+BPF_ABS"); 2559 } 2560 2561 ATF_TC_BODY(libbpfjit_ld_abs, tc) 2562 { 2563 static struct bpf_insn insns[3][2] = { 2564 { 2565 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 2566 BPF_STMT(BPF_RET+BPF_A, 0) 2567 }, 2568 { 2569 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 5), 2570 BPF_STMT(BPF_RET+BPF_A, 0) 2571 }, 2572 { 2573 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 5), 2574 BPF_STMT(BPF_RET+BPF_A, 0) 2575 } 2576 }; 2577 2578 static size_t lengths[3] = { 1, 2, 4 }; 2579 static unsigned int expected[3] = { 0xde, 0xdead, 0xdeadbeef }; 2580 2581 size_t i, l; 2582 uint8_t *pkt = deadbeef_at_5; 2583 size_t pktsize = sizeof(deadbeef_at_5); 2584 2585 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2586 2587 for (i = 0; i < 3; i++) { 2588 bpfjit_func_t code; 2589 2590 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2591 2592 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2593 ATF_REQUIRE(code != NULL); 2594 2595 for (l = 1; l < 5 + lengths[i]; l++) { 2596 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 2597 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 2598 } 2599 2600 l = 5 + lengths[i]; 2601 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2602 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 2603 2604 l = pktsize; 2605 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2606 2607 bpfjit_free_code(code); 2608 } 2609 } 2610 2611 ATF_TC(libbpfjit_ld_abs_k_overflow); 2612 ATF_TC_HEAD(libbpfjit_ld_abs_k_overflow, tc) 2613 { 2614 atf_tc_set_md_var(tc, "descr", 2615 "Test JIT compilation of BPF_LD+BPF_ABS with overflow in k+4"); 2616 } 2617 2618 ATF_TC_BODY(libbpfjit_ld_abs_k_overflow, tc) 2619 { 2620 static struct bpf_insn insns[12][3] = { 2621 { 2622 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 2623 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2624 BPF_STMT(BPF_RET+BPF_K, 1) 2625 }, 2626 { 2627 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 2628 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2629 BPF_STMT(BPF_RET+BPF_K, 1) 2630 }, 2631 { 2632 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 2633 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2634 BPF_STMT(BPF_RET+BPF_K, 1) 2635 }, 2636 { 2637 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 2638 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2639 BPF_STMT(BPF_RET+BPF_K, 1) 2640 }, 2641 { 2642 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 2643 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2644 BPF_STMT(BPF_RET+BPF_K, 1) 2645 }, 2646 { 2647 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 2648 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2649 BPF_STMT(BPF_RET+BPF_K, 1) 2650 }, 2651 { 2652 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2653 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 2654 BPF_STMT(BPF_RET+BPF_K, 1) 2655 }, 2656 { 2657 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2658 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 2659 BPF_STMT(BPF_RET+BPF_K, 1) 2660 }, 2661 { 2662 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2663 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 2664 BPF_STMT(BPF_RET+BPF_K, 1) 2665 }, 2666 { 2667 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2668 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 2669 BPF_STMT(BPF_RET+BPF_K, 1) 2670 }, 2671 { 2672 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2673 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 2674 BPF_STMT(BPF_RET+BPF_K, 1) 2675 }, 2676 { 2677 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 2678 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 2679 BPF_STMT(BPF_RET+BPF_K, 1) 2680 } 2681 }; 2682 2683 int i; 2684 uint8_t pkt[8] = { 0 }; 2685 2686 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2687 2688 for (i = 0; i < 3; i++) { 2689 bpfjit_func_t code; 2690 2691 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2692 2693 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2694 ATF_REQUIRE(code != NULL); 2695 2696 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2697 2698 bpfjit_free_code(code); 2699 } 2700 } 2701 2702 ATF_TC(libbpfjit_ld_ind); 2703 ATF_TC_HEAD(libbpfjit_ld_ind, tc) 2704 { 2705 atf_tc_set_md_var(tc, "descr", 2706 "Test JIT compilation of BPF_LD+BPF_IND"); 2707 } 2708 2709 ATF_TC_BODY(libbpfjit_ld_ind, tc) 2710 { 2711 static struct bpf_insn insns[6][3] = { 2712 { 2713 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2714 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2715 BPF_STMT(BPF_RET+BPF_A, 0) 2716 }, 2717 { 2718 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2719 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), 2720 BPF_STMT(BPF_RET+BPF_A, 0) 2721 }, 2722 { 2723 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2724 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2), 2725 BPF_STMT(BPF_RET+BPF_A, 0) 2726 }, 2727 { 2728 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2729 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2730 BPF_STMT(BPF_RET+BPF_A, 0) 2731 }, 2732 { 2733 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2734 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 2735 BPF_STMT(BPF_RET+BPF_A, 0) 2736 }, 2737 { 2738 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2739 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), 2740 BPF_STMT(BPF_RET+BPF_A, 0) 2741 } 2742 }; 2743 2744 static size_t lengths[6] = { 1, 2, 4, 1, 2, 4 }; 2745 2746 static unsigned int expected[6] = { 2747 0xde, 0xdead, 0xdeadbeef, 2748 0xde, 0xdead, 0xdeadbeef 2749 }; 2750 2751 size_t i, l; 2752 uint8_t *pkt = deadbeef_at_5; 2753 size_t pktsize = sizeof(deadbeef_at_5); 2754 2755 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2756 2757 for (i = 0; i < 3; i++) { 2758 bpfjit_func_t code; 2759 2760 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2761 2762 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2763 ATF_REQUIRE(code != NULL); 2764 2765 for (l = 1; l < 5 + lengths[i]; l++) { 2766 ATF_CHECK(jitcall(code, pkt, l, l) == 0); 2767 ATF_CHECK(jitcall(code, pkt, pktsize, l) == 0); 2768 } 2769 2770 l = 5 + lengths[i]; 2771 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2772 ATF_CHECK(jitcall(code, pkt, pktsize, l) == expected[i]); 2773 2774 l = pktsize; 2775 ATF_CHECK(jitcall(code, pkt, l, l) == expected[i]); 2776 2777 bpfjit_free_code(code); 2778 } 2779 } 2780 2781 ATF_TC(libbpfjit_ld_ind_k_overflow); 2782 ATF_TC_HEAD(libbpfjit_ld_ind_k_overflow, tc) 2783 { 2784 atf_tc_set_md_var(tc, "descr", 2785 "Test JIT compilation of BPF_LD+BPF_IND with overflow in k+4"); 2786 } 2787 2788 ATF_TC_BODY(libbpfjit_ld_ind_k_overflow, tc) 2789 { 2790 static struct bpf_insn insns[12][3] = { 2791 { 2792 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2793 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2794 BPF_STMT(BPF_RET+BPF_K, 1) 2795 }, 2796 { 2797 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2798 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2799 BPF_STMT(BPF_RET+BPF_K, 1) 2800 }, 2801 { 2802 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2803 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2804 BPF_STMT(BPF_RET+BPF_K, 1) 2805 }, 2806 { 2807 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2808 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2809 BPF_STMT(BPF_RET+BPF_K, 1) 2810 }, 2811 { 2812 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2813 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2814 BPF_STMT(BPF_RET+BPF_K, 1) 2815 }, 2816 { 2817 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2818 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2819 BPF_STMT(BPF_RET+BPF_K, 1) 2820 }, 2821 { 2822 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2823 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2824 BPF_STMT(BPF_RET+BPF_K, 1) 2825 }, 2826 { 2827 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2828 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2829 BPF_STMT(BPF_RET+BPF_K, 1) 2830 }, 2831 { 2832 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2833 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2834 BPF_STMT(BPF_RET+BPF_K, 1) 2835 }, 2836 { 2837 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2838 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2839 BPF_STMT(BPF_RET+BPF_K, 1) 2840 }, 2841 { 2842 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2843 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2844 BPF_STMT(BPF_RET+BPF_K, 1) 2845 }, 2846 { 2847 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2848 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2849 BPF_STMT(BPF_RET+BPF_K, 1) 2850 } 2851 }; 2852 2853 int i; 2854 uint8_t pkt[8] = { 0 }; 2855 2856 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2857 2858 for (i = 0; i < 3; i++) { 2859 bpfjit_func_t code; 2860 2861 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2862 2863 code = bpfjit_generate_code(NULL, insns[i], insn_count); 2864 ATF_REQUIRE(code != NULL); 2865 2866 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 2867 2868 bpfjit_free_code(code); 2869 } 2870 } 2871 2872 ATF_TC(libbpfjit_ld_ind_x_overflow1); 2873 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow1, tc) 2874 { 2875 atf_tc_set_md_var(tc, "descr", 2876 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2877 } 2878 2879 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow1, tc) 2880 { 2881 static struct bpf_insn insns[] = { 2882 BPF_STMT(BPF_LD+BPF_LEN, 0), 2883 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2884 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2885 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2886 BPF_STMT(BPF_RET+BPF_A, 0) 2887 }; 2888 2889 size_t i; 2890 bpfjit_func_t code; 2891 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2892 2893 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2894 2895 ATF_CHECK(bpf_validate(insns, insn_count)); 2896 2897 code = bpfjit_generate_code(NULL, insns, insn_count); 2898 ATF_REQUIRE(code != NULL); 2899 2900 for (i = 1; i <= sizeof(pkt); i++) { 2901 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2902 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2903 } 2904 2905 bpfjit_free_code(code); 2906 } 2907 2908 ATF_TC(libbpfjit_ld_ind_x_overflow2); 2909 ATF_TC_HEAD(libbpfjit_ld_ind_x_overflow2, tc) 2910 { 2911 atf_tc_set_md_var(tc, "descr", 2912 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2913 } 2914 2915 ATF_TC_BODY(libbpfjit_ld_ind_x_overflow2, tc) 2916 { 2917 static struct bpf_insn insns[] = { 2918 BPF_STMT(BPF_LD+BPF_LEN, 0), 2919 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2920 BPF_STMT(BPF_ST, 3), 2921 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2922 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2923 BPF_STMT(BPF_RET+BPF_A, 0) 2924 }; 2925 2926 size_t i; 2927 bpfjit_func_t code; 2928 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2929 2930 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2931 2932 ATF_CHECK(bpf_validate(insns, insn_count)); 2933 2934 code = bpfjit_generate_code(NULL, insns, insn_count); 2935 ATF_REQUIRE(code != NULL); 2936 2937 for (i = 1; i <= sizeof(pkt); i++) { 2938 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2939 ATF_CHECK(jitcall(code, pkt, i, i) == 10 * i); 2940 } 2941 2942 bpfjit_free_code(code); 2943 } 2944 2945 ATF_TC(libbpfjit_ld_len); 2946 ATF_TC_HEAD(libbpfjit_ld_len, tc) 2947 { 2948 atf_tc_set_md_var(tc, "descr", 2949 "Test JIT compilation of BPF_LD+BPF_W+BPF_LEN"); 2950 } 2951 2952 ATF_TC_BODY(libbpfjit_ld_len, tc) 2953 { 2954 static struct bpf_insn insns[] = { 2955 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2956 BPF_STMT(BPF_RET+BPF_A, 0) 2957 }; 2958 2959 size_t i; 2960 bpfjit_func_t code; 2961 uint8_t pkt[32]; /* the program doesn't read any data */ 2962 2963 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2964 2965 ATF_CHECK(bpf_validate(insns, insn_count)); 2966 2967 code = bpfjit_generate_code(NULL, insns, insn_count); 2968 ATF_REQUIRE(code != NULL); 2969 2970 for (i = 0; i < sizeof(pkt); i++) 2971 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 2972 2973 bpfjit_free_code(code); 2974 } 2975 2976 ATF_TC(libbpfjit_ld_imm); 2977 ATF_TC_HEAD(libbpfjit_ld_imm, tc) 2978 { 2979 atf_tc_set_md_var(tc, "descr", 2980 "Test JIT compilation of BPF_LD+BPF_IMM"); 2981 } 2982 2983 ATF_TC_BODY(libbpfjit_ld_imm, tc) 2984 { 2985 static struct bpf_insn insns[] = { 2986 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX), 2987 BPF_STMT(BPF_RET+BPF_A, 0) 2988 }; 2989 2990 bpfjit_func_t code; 2991 uint8_t pkt[1]; /* the program doesn't read any data */ 2992 2993 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2994 2995 ATF_CHECK(bpf_validate(insns, insn_count)); 2996 2997 code = bpfjit_generate_code(NULL, insns, insn_count); 2998 ATF_REQUIRE(code != NULL); 2999 3000 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 3001 3002 bpfjit_free_code(code); 3003 } 3004 3005 ATF_TC(libbpfjit_ldx_imm1); 3006 ATF_TC_HEAD(libbpfjit_ldx_imm1, tc) 3007 { 3008 atf_tc_set_md_var(tc, "descr", 3009 "Test JIT compilation of BPF_LDX+BPF_IMM"); 3010 } 3011 3012 ATF_TC_BODY(libbpfjit_ldx_imm1, tc) 3013 { 3014 static struct bpf_insn insns[] = { 3015 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX - 5), 3016 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3017 BPF_STMT(BPF_RET+BPF_A, 0) 3018 }; 3019 3020 bpfjit_func_t code; 3021 uint8_t pkt[1]; /* the program doesn't read any data */ 3022 3023 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3024 3025 ATF_CHECK(bpf_validate(insns, insn_count)); 3026 3027 code = bpfjit_generate_code(NULL, insns, insn_count); 3028 ATF_REQUIRE(code != NULL); 3029 3030 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX - 5); 3031 3032 bpfjit_free_code(code); 3033 } 3034 3035 ATF_TC(libbpfjit_ldx_imm2); 3036 ATF_TC_HEAD(libbpfjit_ldx_imm2, tc) 3037 { 3038 atf_tc_set_md_var(tc, "descr", 3039 "Test JIT compilation of BPF_LDX+BPF_IMM"); 3040 } 3041 3042 ATF_TC_BODY(libbpfjit_ldx_imm2, tc) 3043 { 3044 static struct bpf_insn insns[] = { 3045 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 3046 BPF_STMT(BPF_LD+BPF_IMM, 5), 3047 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 3048 BPF_STMT(BPF_RET+BPF_K, 7), 3049 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 3050 }; 3051 3052 bpfjit_func_t code; 3053 uint8_t pkt[1]; /* 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 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 3063 3064 bpfjit_free_code(code); 3065 } 3066 3067 ATF_TC(libbpfjit_ldx_len1); 3068 ATF_TC_HEAD(libbpfjit_ldx_len1, tc) 3069 { 3070 atf_tc_set_md_var(tc, "descr", 3071 "Test JIT compilation of BPF_LDX+BPF_LEN"); 3072 } 3073 3074 ATF_TC_BODY(libbpfjit_ldx_len1, tc) 3075 { 3076 static struct bpf_insn insns[] = { 3077 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3078 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3079 BPF_STMT(BPF_RET+BPF_A, 0) 3080 }; 3081 3082 size_t i; 3083 bpfjit_func_t code; 3084 uint8_t pkt[5]; /* the program doesn't read any data */ 3085 3086 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3087 3088 ATF_CHECK(bpf_validate(insns, insn_count)); 3089 3090 code = bpfjit_generate_code(NULL, insns, insn_count); 3091 ATF_REQUIRE(code != NULL); 3092 3093 for (i = 1; i < sizeof(pkt); i++) { 3094 ATF_CHECK(jitcall(code, pkt, i, 1) == i); 3095 ATF_CHECK(jitcall(code, pkt, i + 1, i) == i + 1); 3096 } 3097 3098 bpfjit_free_code(code); 3099 } 3100 3101 ATF_TC(libbpfjit_ldx_len2); 3102 ATF_TC_HEAD(libbpfjit_ldx_len2, tc) 3103 { 3104 atf_tc_set_md_var(tc, "descr", 3105 "Test JIT compilation of BPF_LDX+BPF_LEN"); 3106 } 3107 3108 ATF_TC_BODY(libbpfjit_ldx_len2, tc) 3109 { 3110 static struct bpf_insn insns[] = { 3111 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3112 BPF_STMT(BPF_LD+BPF_IMM, 5), 3113 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 3114 BPF_STMT(BPF_RET+BPF_K, 7), 3115 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 3116 }; 3117 3118 bpfjit_func_t code; 3119 uint8_t pkt[5]; /* the program doesn't read any data */ 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, 5, 1) == UINT32_MAX); 3129 ATF_CHECK(jitcall(code, pkt, 6, 5) == 7); 3130 3131 bpfjit_free_code(code); 3132 } 3133 3134 ATF_TC(libbpfjit_ldx_msh); 3135 ATF_TC_HEAD(libbpfjit_ldx_msh, tc) 3136 { 3137 atf_tc_set_md_var(tc, "descr", 3138 "Test JIT compilation of BPF_LDX+BPF_MSH"); 3139 } 3140 3141 ATF_TC_BODY(libbpfjit_ldx_msh, tc) 3142 { 3143 static struct bpf_insn insns[] = { 3144 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), 3145 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3146 BPF_STMT(BPF_RET+BPF_A, 0) 3147 }; 3148 3149 bpfjit_func_t code; 3150 uint8_t pkt[2] = { 0, 0x7a }; 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, 2, 2) == 40); 3160 3161 bpfjit_free_code(code); 3162 } 3163 3164 ATF_TC(libbpfjit_misc_tax); 3165 ATF_TC_HEAD(libbpfjit_misc_tax, tc) 3166 { 3167 atf_tc_set_md_var(tc, "descr", 3168 "Test JIT compilation of BPF_MISC+BPF_TAX"); 3169 } 3170 3171 ATF_TC_BODY(libbpfjit_misc_tax, tc) 3172 { 3173 static struct bpf_insn insns[] = { 3174 BPF_STMT(BPF_LD+BPF_IMM, 3), 3175 BPF_STMT(BPF_MISC+BPF_TAX, 0), 3176 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 3177 BPF_STMT(BPF_RET+BPF_A, 0) 3178 }; 3179 3180 bpfjit_func_t code; 3181 uint8_t pkt[] = { 0, 11, 22, 33, 44, 55 }; 3182 3183 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3184 3185 ATF_CHECK(bpf_validate(insns, insn_count)); 3186 3187 code = bpfjit_generate_code(NULL, insns, insn_count); 3188 ATF_REQUIRE(code != NULL); 3189 3190 ATF_CHECK(jitcall(code, pkt, sizeof(pkt), sizeof(pkt)) == 55); 3191 3192 bpfjit_free_code(code); 3193 } 3194 3195 ATF_TC(libbpfjit_misc_txa); 3196 ATF_TC_HEAD(libbpfjit_misc_txa, tc) 3197 { 3198 atf_tc_set_md_var(tc, "descr", 3199 "Test JIT compilation of BPF_MISC+BPF_TXA"); 3200 } 3201 3202 ATF_TC_BODY(libbpfjit_misc_txa, tc) 3203 { 3204 static struct bpf_insn insns[] = { 3205 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 391), 3206 BPF_STMT(BPF_MISC+BPF_TXA, 0), 3207 BPF_STMT(BPF_RET+BPF_A, 0) 3208 }; 3209 3210 bpfjit_func_t code; 3211 uint8_t pkt[1]; /* the program doesn't read any data */ 3212 3213 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3214 3215 ATF_CHECK(bpf_validate(insns, insn_count)); 3216 3217 code = bpfjit_generate_code(NULL, insns, insn_count); 3218 ATF_REQUIRE(code != NULL); 3219 3220 ATF_CHECK(jitcall(code, pkt, 1, 1) == 391); 3221 3222 bpfjit_free_code(code); 3223 } 3224 3225 ATF_TC(libbpfjit_st1); 3226 ATF_TC_HEAD(libbpfjit_st1, tc) 3227 { 3228 atf_tc_set_md_var(tc, "descr", 3229 "Test JIT compilation of BPF_ST"); 3230 } 3231 3232 ATF_TC_BODY(libbpfjit_st1, tc) 3233 { 3234 static struct bpf_insn insns[] = { 3235 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3236 BPF_STMT(BPF_ST, 0), 3237 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 3238 BPF_STMT(BPF_LD+BPF_MEM, 0), 3239 BPF_STMT(BPF_RET+BPF_A, 0) 3240 }; 3241 3242 size_t i; 3243 bpfjit_func_t code; 3244 uint8_t pkt[16]; /* the program doesn't read any data */ 3245 3246 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3247 3248 ATF_CHECK(bpf_validate(insns, insn_count)); 3249 3250 code = bpfjit_generate_code(NULL, insns, insn_count); 3251 ATF_REQUIRE(code != NULL); 3252 3253 for (i = 1; i <= sizeof(pkt); i++) 3254 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 3255 3256 bpfjit_free_code(code); 3257 } 3258 3259 ATF_TC(libbpfjit_st2); 3260 ATF_TC_HEAD(libbpfjit_st2, tc) 3261 { 3262 atf_tc_set_md_var(tc, "descr", 3263 "Test JIT compilation of BPF_ST"); 3264 } 3265 3266 ATF_TC_BODY(libbpfjit_st2, tc) 3267 { 3268 static struct bpf_insn insns[] = { 3269 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3270 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3271 BPF_STMT(BPF_LD+BPF_MEM, 0), 3272 BPF_STMT(BPF_RET+BPF_A, 0) 3273 }; 3274 3275 bpfjit_func_t code; 3276 uint8_t pkt[1]; /* the program doesn't read any data */ 3277 3278 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3279 3280 ATF_CHECK(bpf_validate(insns, insn_count)); 3281 3282 code = bpfjit_generate_code(NULL, insns, insn_count); 3283 ATF_REQUIRE(code != NULL); 3284 3285 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3286 3287 bpfjit_free_code(code); 3288 } 3289 3290 ATF_TC(libbpfjit_st3); 3291 ATF_TC_HEAD(libbpfjit_st3, tc) 3292 { 3293 atf_tc_set_md_var(tc, "descr", 3294 "Test JIT compilation of BPF_ST"); 3295 } 3296 3297 ATF_TC_BODY(libbpfjit_st3, tc) 3298 { 3299 static struct bpf_insn insns[] = { 3300 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3301 BPF_STMT(BPF_ST, 0), 3302 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 3303 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3304 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 3305 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 3306 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 3307 BPF_STMT(BPF_RET+BPF_A, 0), 3308 BPF_STMT(BPF_LD+BPF_MEM, 0), 3309 BPF_STMT(BPF_RET+BPF_A, 0) 3310 }; 3311 3312 bpfjit_func_t code; 3313 uint8_t pkt[2]; /* the program doesn't read any data */ 3314 3315 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3316 3317 ATF_REQUIRE(BPF_MEMWORDS > 1); 3318 3319 ATF_CHECK(bpf_validate(insns, insn_count)); 3320 3321 code = bpfjit_generate_code(NULL, insns, insn_count); 3322 ATF_REQUIRE(code != NULL); 3323 3324 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 3325 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 3326 3327 bpfjit_free_code(code); 3328 } 3329 3330 ATF_TC(libbpfjit_st4); 3331 ATF_TC_HEAD(libbpfjit_st4, tc) 3332 { 3333 atf_tc_set_md_var(tc, "descr", 3334 "Test JIT compilation of BPF_ST"); 3335 } 3336 3337 ATF_TC_BODY(libbpfjit_st4, tc) 3338 { 3339 static struct bpf_insn insns[] = { 3340 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 3341 BPF_STMT(BPF_ST, 5), 3342 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 3343 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 3344 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 3345 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 3346 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 3347 BPF_STMT(BPF_RET+BPF_A, 0), 3348 BPF_STMT(BPF_LD+BPF_MEM, 5), 3349 BPF_STMT(BPF_RET+BPF_A, 0) 3350 }; 3351 3352 bpfjit_func_t code; 3353 uint8_t pkt[2]; /* the program doesn't read any data */ 3354 3355 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3356 3357 ATF_REQUIRE(BPF_MEMWORDS > 6); 3358 3359 ATF_CHECK(bpf_validate(insns, insn_count)); 3360 3361 code = bpfjit_generate_code(NULL, insns, insn_count); 3362 ATF_REQUIRE(code != NULL); 3363 3364 ATF_CHECK(jitcall(code, pkt, 1, 1) == 1); 3365 ATF_CHECK(jitcall(code, pkt, 2, 2) == 102); 3366 3367 bpfjit_free_code(code); 3368 } 3369 3370 ATF_TC(libbpfjit_st5); 3371 ATF_TC_HEAD(libbpfjit_st5, tc) 3372 { 3373 atf_tc_set_md_var(tc, "descr", 3374 "Test JIT compilation of BPF_ST"); 3375 } 3376 3377 ATF_TC_BODY(libbpfjit_st5, tc) 3378 { 3379 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 3380 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3381 3382 size_t k; 3383 bpfjit_func_t code; 3384 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 3385 3386 memset(insns, 0, sizeof(insns)); 3387 3388 /* for each k do M[k] = k */ 3389 for (k = 0; k < BPF_MEMWORDS; k++) { 3390 insns[2*k].code = BPF_LD+BPF_IMM; 3391 insns[2*k].k = 3*k; 3392 insns[2*k+1].code = BPF_ST; 3393 insns[2*k+1].k = k; 3394 } 3395 3396 /* load wirelen into A */ 3397 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 3398 3399 /* for each k, if (A == k + 1) return M[k] */ 3400 for (k = 0; k < BPF_MEMWORDS; k++) { 3401 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 3402 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 3403 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 3404 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 3405 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 3406 insns[2*BPF_MEMWORDS+3*k+2].k = k; 3407 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 3408 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 3409 } 3410 3411 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 3412 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 3413 3414 ATF_CHECK(bpf_validate(insns, insn_count)); 3415 3416 code = bpfjit_generate_code(NULL, insns, insn_count); 3417 ATF_REQUIRE(code != NULL); 3418 3419 for (k = 1; k <= sizeof(pkt); k++) 3420 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 3421 3422 bpfjit_free_code(code); 3423 } 3424 3425 ATF_TC(libbpfjit_stx1); 3426 ATF_TC_HEAD(libbpfjit_stx1, tc) 3427 { 3428 atf_tc_set_md_var(tc, "descr", 3429 "Test JIT compilation of BPF_STX"); 3430 } 3431 3432 ATF_TC_BODY(libbpfjit_stx1, tc) 3433 { 3434 static struct bpf_insn insns[] = { 3435 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3436 BPF_STMT(BPF_STX, 0), 3437 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 3438 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3439 BPF_STMT(BPF_RET+BPF_A, 0) 3440 }; 3441 3442 size_t i; 3443 bpfjit_func_t code; 3444 uint8_t pkt[16]; /* the program doesn't read any data */ 3445 3446 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3447 3448 ATF_CHECK(bpf_validate(insns, insn_count)); 3449 3450 code = bpfjit_generate_code(NULL, insns, insn_count); 3451 ATF_REQUIRE(code != NULL); 3452 3453 for (i = 1; i <= sizeof(pkt); i++) 3454 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == i); 3455 3456 bpfjit_free_code(code); 3457 } 3458 3459 ATF_TC(libbpfjit_stx2); 3460 ATF_TC_HEAD(libbpfjit_stx2, tc) 3461 { 3462 atf_tc_set_md_var(tc, "descr", 3463 "Test JIT compilation of BPF_STX"); 3464 } 3465 3466 ATF_TC_BODY(libbpfjit_stx2, tc) 3467 { 3468 static struct bpf_insn insns[] = { 3469 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3470 BPF_STMT(BPF_STX, BPF_MEMWORDS-1), 3471 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 3472 BPF_STMT(BPF_MISC+BPF_TXA, 0), 3473 BPF_STMT(BPF_RET+BPF_A, 0) 3474 }; 3475 3476 bpfjit_func_t code; 3477 uint8_t pkt[1]; /* the program doesn't read any data */ 3478 3479 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3480 3481 ATF_CHECK(bpf_validate(insns, insn_count)); 3482 3483 code = bpfjit_generate_code(NULL, insns, insn_count); 3484 ATF_REQUIRE(code != NULL); 3485 3486 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 3487 3488 bpfjit_free_code(code); 3489 } 3490 3491 ATF_TC(libbpfjit_stx3); 3492 ATF_TC_HEAD(libbpfjit_stx3, tc) 3493 { 3494 atf_tc_set_md_var(tc, "descr", 3495 "Test JIT compilation of BPF_STX"); 3496 } 3497 3498 ATF_TC_BODY(libbpfjit_stx3, tc) 3499 { 3500 static struct bpf_insn insns[] = { 3501 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 3502 BPF_STMT(BPF_STX, 5), 3503 BPF_STMT(BPF_STX, 2), 3504 BPF_STMT(BPF_STX, 3), 3505 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 1), 3506 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3507 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 2), 3508 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3509 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 3510 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3511 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 5), 3512 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3513 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 6), 3514 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 3515 BPF_STMT(BPF_RET+BPF_A, 0) 3516 }; 3517 3518 size_t i; 3519 bpfjit_func_t code; 3520 uint8_t pkt[16]; /* the program doesn't read any data */ 3521 3522 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3523 3524 ATF_CHECK(bpf_validate(insns, insn_count)); 3525 3526 code = bpfjit_generate_code(NULL, insns, insn_count); 3527 ATF_REQUIRE(code != NULL); 3528 3529 for (i = 1; i <= sizeof(pkt); i++) 3530 ATF_CHECK(jitcall(code, pkt, i, sizeof(pkt)) == 3 * i); 3531 3532 bpfjit_free_code(code); 3533 } 3534 3535 ATF_TC(libbpfjit_stx4); 3536 ATF_TC_HEAD(libbpfjit_stx4, tc) 3537 { 3538 atf_tc_set_md_var(tc, "descr", 3539 "Test JIT compilation of BPF_STX"); 3540 } 3541 3542 ATF_TC_BODY(libbpfjit_stx4, tc) 3543 { 3544 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 3545 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3546 3547 size_t k; 3548 bpfjit_func_t code; 3549 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 3550 3551 memset(insns, 0, sizeof(insns)); 3552 3553 /* for each k do M[k] = k */ 3554 for (k = 0; k < BPF_MEMWORDS; k++) { 3555 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM; 3556 insns[2*k].k = 3*k; 3557 insns[2*k+1].code = BPF_STX; 3558 insns[2*k+1].k = k; 3559 } 3560 3561 /* load wirelen into A */ 3562 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 3563 3564 /* for each k, if (A == k + 1) return M[k] */ 3565 for (k = 0; k < BPF_MEMWORDS; k++) { 3566 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 3567 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 3568 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 3569 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 3570 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 3571 insns[2*BPF_MEMWORDS+3*k+2].k = k; 3572 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 3573 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 3574 } 3575 3576 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 3577 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 3578 3579 ATF_CHECK(bpf_validate(insns, insn_count)); 3580 3581 code = bpfjit_generate_code(NULL, insns, insn_count); 3582 ATF_REQUIRE(code != NULL); 3583 3584 for (k = 1; k <= sizeof(pkt); k++) 3585 ATF_CHECK(jitcall(code, pkt, k, k) == 3*(k-1)); 3586 3587 bpfjit_free_code(code); 3588 } 3589 3590 ATF_TC(libbpfjit_opt_ld_abs_1); 3591 ATF_TC_HEAD(libbpfjit_opt_ld_abs_1, tc) 3592 { 3593 atf_tc_set_md_var(tc, "descr", 3594 "Test JIT compilation with length optimization " 3595 "applied to BPF_LD+BPF_ABS"); 3596 } 3597 3598 ATF_TC_BODY(libbpfjit_opt_ld_abs_1, tc) 3599 { 3600 static struct bpf_insn insns[] = { 3601 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3602 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3603 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3604 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3605 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3606 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3607 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3608 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3609 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3610 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3611 BPF_STMT(BPF_RET+BPF_K, 0), 3612 }; 3613 3614 size_t i, j; 3615 bpfjit_func_t code; 3616 uint8_t pkt[2][34] = { 3617 { 3618 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3619 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3620 0x80, 0x03, 0x70, 0x0f, 3621 0x80, 0x03, 0x70, 0x23 3622 }, 3623 { 3624 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3625 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3626 0x80, 0x03, 0x70, 0x23, 3627 0x80, 0x03, 0x70, 0x0f 3628 } 3629 }; 3630 3631 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3632 3633 ATF_CHECK(bpf_validate(insns, insn_count)); 3634 3635 code = bpfjit_generate_code(NULL, insns, insn_count); 3636 ATF_REQUIRE(code != NULL); 3637 3638 for (i = 0; i < 2; i++) { 3639 for (j = 1; j < sizeof(pkt[i]); j++) 3640 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3641 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3642 } 3643 3644 bpfjit_free_code(code); 3645 } 3646 3647 ATF_TC(libbpfjit_opt_ld_abs_2); 3648 ATF_TC_HEAD(libbpfjit_opt_ld_abs_2, tc) 3649 { 3650 atf_tc_set_md_var(tc, "descr", 3651 "Test JIT compilation with length optimization " 3652 "applied to BPF_LD+BPF_ABS"); 3653 } 3654 3655 ATF_TC_BODY(libbpfjit_opt_ld_abs_2, tc) 3656 { 3657 static struct bpf_insn insns[] = { 3658 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3659 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3660 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3661 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3662 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3663 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3664 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3665 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3666 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3667 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3668 BPF_STMT(BPF_RET+BPF_K, 0), 3669 }; 3670 3671 size_t i, j; 3672 bpfjit_func_t code; 3673 uint8_t pkt[2][34] = { 3674 { 3675 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3676 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3677 0x80, 0x03, 0x70, 0x0f, 3678 0x80, 0x03, 0x70, 0x23 3679 }, 3680 { 3681 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3682 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3683 0x80, 0x03, 0x70, 0x23, 3684 0x80, 0x03, 0x70, 0x0f 3685 } 3686 }; 3687 3688 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3689 3690 ATF_CHECK(bpf_validate(insns, insn_count)); 3691 3692 code = bpfjit_generate_code(NULL, insns, insn_count); 3693 ATF_REQUIRE(code != NULL); 3694 3695 for (i = 0; i < 2; i++) { 3696 for (j = 1; j < sizeof(pkt[i]); j++) 3697 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3698 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3699 } 3700 3701 bpfjit_free_code(code); 3702 } 3703 3704 ATF_TC(libbpfjit_opt_ld_abs_3); 3705 ATF_TC_HEAD(libbpfjit_opt_ld_abs_3, tc) 3706 { 3707 atf_tc_set_md_var(tc, "descr", 3708 "Test JIT compilation with length optimization " 3709 "applied to BPF_LD+BPF_ABS"); 3710 } 3711 3712 ATF_TC_BODY(libbpfjit_opt_ld_abs_3, tc) 3713 { 3714 static struct bpf_insn insns[] = { 3715 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3716 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3717 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3718 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 6), 3719 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 5), 3720 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3721 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3722 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3723 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3724 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3725 BPF_STMT(BPF_RET+BPF_K, 0), 3726 }; 3727 3728 size_t i, j; 3729 bpfjit_func_t code; 3730 uint8_t pkt[2][34] = { 3731 { 3732 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3733 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3734 0x80, 0x03, 0x70, 0x0f, 3735 0x80, 0x03, 0x70, 0x23 3736 }, 3737 { 3738 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3739 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3740 0x80, 0x03, 0x70, 0x23, 3741 0x80, 0x03, 0x70, 0x0f 3742 } 3743 }; 3744 3745 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3746 3747 ATF_CHECK(bpf_validate(insns, insn_count)); 3748 3749 code = bpfjit_generate_code(NULL, insns, insn_count); 3750 ATF_REQUIRE(code != NULL); 3751 3752 for (i = 0; i < 2; i++) { 3753 for (j = 1; j < sizeof(pkt[i]); j++) 3754 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3755 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3756 } 3757 3758 bpfjit_free_code(code); 3759 } 3760 3761 ATF_TC(libbpfjit_opt_ld_ind_1); 3762 ATF_TC_HEAD(libbpfjit_opt_ld_ind_1, tc) 3763 { 3764 atf_tc_set_md_var(tc, "descr", 3765 "Test JIT compilation with length optimization " 3766 "applied to BPF_LD+BPF_IND"); 3767 } 3768 3769 ATF_TC_BODY(libbpfjit_opt_ld_ind_1, tc) 3770 { 3771 static struct bpf_insn insns[] = { 3772 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 12), 3773 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 3774 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3775 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 14), 3776 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3777 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3778 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3779 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3780 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3781 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3782 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3783 BPF_STMT(BPF_RET+BPF_K, 0), 3784 }; 3785 3786 size_t i, j; 3787 bpfjit_func_t code; 3788 uint8_t pkt[2][34] = { 3789 { 3790 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3791 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3792 0x80, 0x03, 0x70, 0x0f, 3793 0x80, 0x03, 0x70, 0x23 3794 }, 3795 { 3796 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3797 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3798 0x80, 0x03, 0x70, 0x23, 3799 0x80, 0x03, 0x70, 0x0f 3800 } 3801 }; 3802 3803 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3804 3805 ATF_CHECK(bpf_validate(insns, insn_count)); 3806 3807 code = bpfjit_generate_code(NULL, insns, insn_count); 3808 ATF_REQUIRE(code != NULL); 3809 3810 for (i = 0; i < 2; i++) { 3811 for (j = 1; j < sizeof(pkt[i]); j++) 3812 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3813 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3814 } 3815 3816 bpfjit_free_code(code); 3817 } 3818 3819 ATF_TC(libbpfjit_opt_ld_ind_2); 3820 ATF_TC_HEAD(libbpfjit_opt_ld_ind_2, tc) 3821 { 3822 atf_tc_set_md_var(tc, "descr", 3823 "Test JIT compilation with length optimization " 3824 "applied to BPF_LD+BPF_IND"); 3825 } 3826 3827 ATF_TC_BODY(libbpfjit_opt_ld_ind_2, tc) 3828 { 3829 static struct bpf_insn insns[] = { 3830 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3831 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 26), 3832 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3833 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3834 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3835 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3836 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3837 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3838 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3839 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3840 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3841 BPF_STMT(BPF_RET+BPF_K, 0), 3842 }; 3843 3844 size_t i, j; 3845 bpfjit_func_t code; 3846 uint8_t pkt[2][34] = { 3847 { 3848 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3849 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3850 0x80, 0x03, 0x70, 0x0f, 3851 0x80, 0x03, 0x70, 0x23 3852 }, 3853 { 3854 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3855 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3856 0x80, 0x03, 0x70, 0x23, 3857 0x80, 0x03, 0x70, 0x0f 3858 } 3859 }; 3860 3861 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3862 3863 ATF_CHECK(bpf_validate(insns, insn_count)); 3864 3865 code = bpfjit_generate_code(NULL, insns, insn_count); 3866 ATF_REQUIRE(code != NULL); 3867 3868 for (i = 0; i < 2; i++) { 3869 for (j = 1; j < sizeof(pkt[i]); j++) 3870 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3871 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3872 } 3873 3874 bpfjit_free_code(code); 3875 } 3876 3877 ATF_TC(libbpfjit_opt_ld_ind_3); 3878 ATF_TC_HEAD(libbpfjit_opt_ld_ind_3, tc) 3879 { 3880 atf_tc_set_md_var(tc, "descr", 3881 "Test JIT compilation with length optimization " 3882 "applied to BPF_LD+BPF_IND"); 3883 } 3884 3885 ATF_TC_BODY(libbpfjit_opt_ld_ind_3, tc) 3886 { 3887 static struct bpf_insn insns[] = { 3888 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 15), 3889 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3890 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3891 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3892 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3893 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3894 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3895 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3896 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3897 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3898 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3899 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3900 BPF_STMT(BPF_RET+BPF_K, 0), 3901 }; 3902 3903 size_t i, j; 3904 bpfjit_func_t code; 3905 uint8_t pkt[2][34] = { 3906 { 3907 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3908 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3909 0x80, 0x03, 0x70, 0x0f, 3910 0x80, 0x03, 0x70, 0x23 3911 }, 3912 { 3913 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3914 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3915 0x80, 0x03, 0x70, 0x23, 3916 0x80, 0x03, 0x70, 0x0f 3917 } 3918 }; 3919 3920 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3921 3922 ATF_CHECK(bpf_validate(insns, insn_count)); 3923 3924 code = bpfjit_generate_code(NULL, insns, insn_count); 3925 ATF_REQUIRE(code != NULL); 3926 3927 for (i = 0; i < 2; i++) { 3928 for (j = 1; j < sizeof(pkt[i]); j++) 3929 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3930 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3931 } 3932 3933 bpfjit_free_code(code); 3934 } 3935 3936 ATF_TC(libbpfjit_opt_ld_ind_4); 3937 ATF_TC_HEAD(libbpfjit_opt_ld_ind_4, tc) 3938 { 3939 atf_tc_set_md_var(tc, "descr", 3940 "Test JIT compilation with length optimization " 3941 "applied to BPF_LD+BPF_IND"); 3942 } 3943 3944 ATF_TC_BODY(libbpfjit_opt_ld_ind_4, tc) 3945 { 3946 static struct bpf_insn insns[] = { 3947 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 11), 3948 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 19), 3949 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3950 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3951 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3952 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3953 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3954 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3955 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3956 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3957 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3958 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3959 BPF_STMT(BPF_RET+BPF_K, 0), 3960 }; 3961 3962 size_t i, j; 3963 bpfjit_func_t code; 3964 uint8_t pkt[2][34] = { 3965 { 3966 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3967 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3968 0x80, 0x03, 0x70, 0x0f, 3969 0x80, 0x03, 0x70, 0x23 3970 }, 3971 { 3972 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3973 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3974 0x80, 0x03, 0x70, 0x23, 3975 0x80, 0x03, 0x70, 0x0f 3976 } 3977 }; 3978 3979 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3980 3981 ATF_CHECK(bpf_validate(insns, insn_count)); 3982 3983 code = bpfjit_generate_code(NULL, insns, insn_count); 3984 ATF_REQUIRE(code != NULL); 3985 3986 for (i = 0; i < 2; i++) { 3987 for (j = 1; j < sizeof(pkt[i]); j++) 3988 ATF_CHECK(jitcall(code, pkt[i], j, j) == 0); 3989 ATF_CHECK(jitcall(code, pkt[i], j, j) == UINT32_MAX); 3990 } 3991 3992 bpfjit_free_code(code); 3993 } 3994 3995 ATF_TC(libbpfjit_abc_ja); 3996 ATF_TC_HEAD(libbpfjit_abc_ja, tc) 3997 { 3998 atf_tc_set_md_var(tc, "descr", 3999 "Test ABC optimization with a single BPF_JMP+BPF_JA"); 4000 } 4001 4002 ATF_TC_BODY(libbpfjit_abc_ja, tc) 4003 { 4004 static struct bpf_insn insns[] = { 4005 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 4006 BPF_STMT(BPF_JMP+BPF_JA, 2), 4007 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, UINT32_MAX - 1), 4008 BPF_STMT(BPF_RET+BPF_K, 0), 4009 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2), /* min. length 6 */ 4010 BPF_STMT(BPF_RET+BPF_A, 0), 4011 BPF_STMT(BPF_RET+BPF_K, 1), 4012 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 4013 BPF_STMT(BPF_RET+BPF_K, 2), 4014 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 4015 BPF_STMT(BPF_RET+BPF_K, 3), 4016 }; 4017 4018 bpfjit_func_t code; 4019 uint8_t pkt[6] = {0, 0, /* UINT32_MAX: */ 255, 255, 255, 255}; 4020 4021 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4022 4023 ATF_CHECK(bpf_validate(insns, insn_count)); 4024 4025 code = bpfjit_generate_code(NULL, insns, insn_count); 4026 ATF_REQUIRE(code != NULL); 4027 4028 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4029 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4030 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4031 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4032 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4033 ATF_CHECK(jitcall(code, pkt, 6, 6) == UINT32_MAX); 4034 4035 bpfjit_free_code(code); 4036 } 4037 4038 ATF_TC(libbpfjit_abc_ja_over); 4039 ATF_TC_HEAD(libbpfjit_abc_ja_over, tc) 4040 { 4041 atf_tc_set_md_var(tc, "descr", 4042 "Test ABC optimization when BPF_JMP+BPF_JA jumps over all loads"); 4043 } 4044 4045 ATF_TC_BODY(libbpfjit_abc_ja_over, tc) 4046 { 4047 static struct bpf_insn insns[] = { 4048 BPF_STMT(BPF_JMP+BPF_JA, 2), 4049 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), 4050 BPF_STMT(BPF_RET+BPF_K, 0), 4051 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4052 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), 4053 BPF_STMT(BPF_RET+BPF_K, 1), 4054 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 4055 BPF_STMT(BPF_RET+BPF_K, 2), 4056 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 6), 4057 BPF_STMT(BPF_RET+BPF_K, 3), 4058 }; 4059 4060 bpfjit_func_t code; 4061 uint8_t pkt[1]; /* the program doesn't read any data */ 4062 4063 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4064 4065 ATF_CHECK(bpf_validate(insns, insn_count)); 4066 4067 code = bpfjit_generate_code(NULL, insns, insn_count); 4068 ATF_REQUIRE(code != NULL); 4069 4070 ATF_CHECK(jitcall(code, pkt, 1, 1) == UINT32_MAX); 4071 4072 bpfjit_free_code(code); 4073 } 4074 4075 ATF_TC(libbpfjit_abc_ld_chain); 4076 ATF_TC_HEAD(libbpfjit_abc_ld_chain, tc) 4077 { 4078 atf_tc_set_md_var(tc, "descr", 4079 "Test ABC optimization of a chain of BPF_LD instructions " 4080 "with exits leading to a single BPF_RET"); 4081 } 4082 4083 ATF_TC_BODY(libbpfjit_abc_ld_chain, tc) 4084 { 4085 static struct bpf_insn insns[] = { 4086 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* min. length 4 */ 4087 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 4), 4088 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* min. length 6 */ 4089 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 0, 2), 4090 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 6), /* min. length 10 */ 4091 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 0, 1), 4092 BPF_STMT(BPF_RET+BPF_K, 123456789), 4093 BPF_STMT(BPF_RET+BPF_K, 987654321), 4094 }; 4095 4096 bpfjit_func_t code; 4097 uint8_t pkt[10] = {}; 4098 4099 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4100 4101 ATF_CHECK(bpf_validate(insns, insn_count)); 4102 4103 code = bpfjit_generate_code(NULL, insns, insn_count); 4104 ATF_REQUIRE(code != NULL); 4105 4106 /* Packet is too short. */ 4107 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4108 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4109 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4110 4111 /* !(pkt[3] == 8) => return 123456789 */ 4112 ATF_CHECK(jitcall(code, pkt, 4, 4) == 123456789); 4113 ATF_CHECK(jitcall(code, pkt, 5, 5) == 123456789); 4114 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 4115 ATF_CHECK(jitcall(code, pkt, 7, 7) == 123456789); 4116 ATF_CHECK(jitcall(code, pkt, 8, 8) == 123456789); 4117 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 4118 4119 /* !(pkt[4:2] >= 7) => too short or return 123456789 */ 4120 pkt[3] = 8; 4121 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4122 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4123 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4124 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4125 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4126 ATF_CHECK(jitcall(code, pkt, 6, 6) == 123456789); 4127 ATF_CHECK(jitcall(code, pkt, 9, 9) == 123456789); 4128 4129 /* !(pkt[6:4] > 6) => too short or return 987654321 */ 4130 pkt[4] = pkt[5] = 1; 4131 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4132 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4133 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4134 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4135 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4136 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4137 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4138 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4139 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4140 ATF_CHECK(jitcall(code, pkt, 10, 10) == 987654321); 4141 4142 /* (pkt[6:4] > 6) => too short or return 123456789 */ 4143 pkt[6] = pkt[7] = pkt[8] = pkt[9] = 1; 4144 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4145 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4146 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4147 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4148 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4149 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4150 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4151 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4152 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4153 ATF_CHECK(jitcall(code, pkt, 10, 10) == 123456789); 4154 4155 bpfjit_free_code(code); 4156 } 4157 4158 ATF_TC(libbpfjit_examples_1); 4159 ATF_TC_HEAD(libbpfjit_examples_1, tc) 4160 { 4161 atf_tc_set_md_var(tc, "descr", 4162 "Test the first example from bpf(4) - " 4163 "accept Reverse ARP requests"); 4164 } 4165 4166 ATF_TC_BODY(libbpfjit_examples_1, tc) 4167 { 4168 /* 4169 * The following filter is taken from the Reverse ARP 4170 * Daemon. It accepts only Reverse ARP requests. 4171 */ 4172 struct bpf_insn insns[] = { 4173 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4174 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8035, 0, 3), 4175 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 4176 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 0, 1), 4177 BPF_STMT(BPF_RET+BPF_K, 42), 4178 BPF_STMT(BPF_RET+BPF_K, 0), 4179 }; 4180 4181 bpfjit_func_t code; 4182 uint8_t pkt[22] = {}; 4183 4184 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4185 4186 ATF_CHECK(bpf_validate(insns, insn_count)); 4187 4188 code = bpfjit_generate_code(NULL, insns, insn_count); 4189 ATF_REQUIRE(code != NULL); 4190 4191 /* Packet is too short. */ 4192 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4193 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4194 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4195 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4196 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4197 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4198 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4199 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4200 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4201 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4202 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4203 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4204 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4205 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4206 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4207 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4208 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4209 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4210 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4211 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4212 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4213 4214 /* The packet doesn't match. */ 4215 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4216 4217 /* Still no match after setting the protocol field. */ 4218 pkt[12] = 0x80; pkt[13] = 0x35; 4219 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4220 4221 /* Set RARP message type. */ 4222 pkt[21] = 3; 4223 ATF_CHECK(jitcall(code, pkt, 22, 22) == 42); 4224 4225 /* Packet is too short. */ 4226 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4227 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4228 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4229 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4230 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4231 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4232 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4233 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4234 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4235 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4236 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4237 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4238 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4239 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4240 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4241 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4242 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4243 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4244 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4245 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4246 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4247 4248 /* Change RARP message type. */ 4249 pkt[20] = 3; 4250 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4251 4252 bpfjit_free_code(code); 4253 } 4254 4255 ATF_TC(libbpfjit_examples_2); 4256 ATF_TC_HEAD(libbpfjit_examples_2, tc) 4257 { 4258 atf_tc_set_md_var(tc, "descr", 4259 "Test the second example from bpf(4) - " 4260 "accept IP packets between two specified hosts"); 4261 } 4262 4263 ATF_TC_BODY(libbpfjit_examples_2, tc) 4264 { 4265 /* 4266 * This filter accepts only IP packets between host 128.3.112.15 4267 * and 128.3.112.35. 4268 */ 4269 static struct bpf_insn insns[] = { 4270 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4271 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 8), 4272 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 4273 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 4274 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 4275 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 4276 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 4277 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 4278 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 4279 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4280 BPF_STMT(BPF_RET+BPF_K, 0), 4281 }; 4282 4283 bpfjit_func_t code; 4284 uint8_t pkt[34] = {}; 4285 4286 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4287 4288 ATF_CHECK(bpf_validate(insns, insn_count)); 4289 4290 code = bpfjit_generate_code(NULL, insns, insn_count); 4291 ATF_REQUIRE(code != NULL); 4292 4293 /* Packet is too short. */ 4294 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4295 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4296 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4297 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4298 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4299 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4300 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4301 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4302 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4303 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4304 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4305 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4306 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4307 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4308 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4309 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4310 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4311 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4312 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4313 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4314 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4315 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4316 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4317 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4318 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4319 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4320 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4321 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4322 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4323 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4324 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 4325 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 4326 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 4327 4328 /* The packet doesn't match. */ 4329 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4330 4331 /* Still no match after setting the protocol field. */ 4332 pkt[12] = 8; 4333 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4334 4335 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 15; 4336 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4337 4338 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 35; 4339 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 4340 4341 /* Swap the ip addresses. */ 4342 pkt[26] = 128; pkt[27] = 3; pkt[28] = 112; pkt[29] = 35; 4343 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4344 4345 pkt[30] = 128; pkt[31] = 3; pkt[32] = 112; pkt[33] = 15; 4346 ATF_CHECK(jitcall(code, pkt, 34, 34) == UINT32_MAX); 4347 4348 /* Packet is too short. */ 4349 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4350 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4351 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4352 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4353 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4354 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4355 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4356 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4357 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4358 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4359 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4360 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4361 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4362 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4363 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4364 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4365 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4366 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4367 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4368 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4369 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4370 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4371 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4372 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4373 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4374 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4375 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4376 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4377 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4378 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4379 ATF_CHECK(jitcall(code, pkt, 31, 31) == 0); 4380 ATF_CHECK(jitcall(code, pkt, 32, 32) == 0); 4381 ATF_CHECK(jitcall(code, pkt, 33, 33) == 0); 4382 4383 /* Change the protocol field. */ 4384 pkt[13] = 8; 4385 ATF_CHECK(jitcall(code, pkt, 34, 34) == 0); 4386 4387 bpfjit_free_code(code); 4388 } 4389 4390 ATF_TC(libbpfjit_examples_3); 4391 ATF_TC_HEAD(libbpfjit_examples_3, tc) 4392 { 4393 atf_tc_set_md_var(tc, "descr", 4394 "Test the third example from bpf(4) - " 4395 "accept TCP finger packets"); 4396 } 4397 4398 ATF_TC_BODY(libbpfjit_examples_3, tc) 4399 { 4400 /* 4401 * This filter returns only TCP finger packets. 4402 */ 4403 struct bpf_insn insns[] = { 4404 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 4405 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x0800, 0, 10), 4406 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 23), 4407 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 0, 8), 4408 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), 4409 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 0x1fff, 6, 0), 4410 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 14), 4411 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 14), 4412 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 2, 0), 4413 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 16), 4414 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 79, 0, 1), 4415 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 4416 BPF_STMT(BPF_RET+BPF_K, 0), 4417 }; 4418 4419 bpfjit_func_t code; 4420 uint8_t pkt[30] = {}; 4421 4422 /* Set IP fragment offset to non-zero. */ 4423 pkt[20] = 1; pkt[21] = 1; 4424 4425 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4426 4427 ATF_CHECK(bpf_validate(insns, insn_count)); 4428 4429 code = bpfjit_generate_code(NULL, insns, insn_count); 4430 ATF_REQUIRE(code != NULL); 4431 4432 /* Packet is too short. */ 4433 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4434 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4435 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4436 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4437 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4438 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4439 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4440 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4441 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4442 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4443 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4444 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4445 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4446 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4447 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4448 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4449 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4450 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4451 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4452 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4453 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4454 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4455 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4456 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4457 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4458 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4459 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4460 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4461 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4462 4463 /* The packet doesn't match. */ 4464 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4465 4466 /* Still no match after setting the protocol field. */ 4467 pkt[12] = 8; 4468 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4469 4470 /* Get one step closer to the match. */ 4471 pkt[23] = 6; 4472 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4473 4474 /* Set IP fragment offset to zero. */ 4475 pkt[20] = 0x20; pkt[21] = 0; 4476 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4477 4478 /* Set IP header length to 12. */ 4479 pkt[14] = 0xd3; 4480 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4481 4482 /* Match one branch of the program. */ 4483 pkt[27] = 79; 4484 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 4485 4486 /* Match the other branch of the program. */ 4487 pkt[29] = 79; pkt[27] = 0; 4488 ATF_CHECK(jitcall(code, pkt, 30, 30) == UINT32_MAX); 4489 4490 /* Packet is too short. */ 4491 ATF_CHECK(jitcall(code, pkt, 1, 1) == 0); 4492 ATF_CHECK(jitcall(code, pkt, 2, 2) == 0); 4493 ATF_CHECK(jitcall(code, pkt, 3, 3) == 0); 4494 ATF_CHECK(jitcall(code, pkt, 4, 4) == 0); 4495 ATF_CHECK(jitcall(code, pkt, 5, 5) == 0); 4496 ATF_CHECK(jitcall(code, pkt, 6, 6) == 0); 4497 ATF_CHECK(jitcall(code, pkt, 7, 7) == 0); 4498 ATF_CHECK(jitcall(code, pkt, 8, 8) == 0); 4499 ATF_CHECK(jitcall(code, pkt, 9, 9) == 0); 4500 ATF_CHECK(jitcall(code, pkt, 10, 10) == 0); 4501 ATF_CHECK(jitcall(code, pkt, 11, 11) == 0); 4502 ATF_CHECK(jitcall(code, pkt, 12, 12) == 0); 4503 ATF_CHECK(jitcall(code, pkt, 13, 13) == 0); 4504 ATF_CHECK(jitcall(code, pkt, 14, 14) == 0); 4505 ATF_CHECK(jitcall(code, pkt, 15, 15) == 0); 4506 ATF_CHECK(jitcall(code, pkt, 16, 16) == 0); 4507 ATF_CHECK(jitcall(code, pkt, 17, 17) == 0); 4508 ATF_CHECK(jitcall(code, pkt, 18, 18) == 0); 4509 ATF_CHECK(jitcall(code, pkt, 19, 19) == 0); 4510 ATF_CHECK(jitcall(code, pkt, 20, 20) == 0); 4511 ATF_CHECK(jitcall(code, pkt, 21, 21) == 0); 4512 ATF_CHECK(jitcall(code, pkt, 22, 22) == 0); 4513 ATF_CHECK(jitcall(code, pkt, 23, 23) == 0); 4514 ATF_CHECK(jitcall(code, pkt, 24, 24) == 0); 4515 ATF_CHECK(jitcall(code, pkt, 25, 25) == 0); 4516 ATF_CHECK(jitcall(code, pkt, 26, 26) == 0); 4517 ATF_CHECK(jitcall(code, pkt, 27, 27) == 0); 4518 ATF_CHECK(jitcall(code, pkt, 28, 28) == 0); 4519 ATF_CHECK(jitcall(code, pkt, 29, 29) == 0); 4520 4521 /* Set IP header length to 16. Packet is too short. */ 4522 pkt[14] = 4; 4523 ATF_CHECK(jitcall(code, pkt, 30, 30) == 0); 4524 4525 bpfjit_free_code(code); 4526 } 4527 4528 ATF_TC(libbpfjit_cop_no_ctx); 4529 ATF_TC_HEAD(libbpfjit_cop_no_ctx, tc) 4530 { 4531 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COP " 4532 "instruction can't be accepted without a context"); 4533 } 4534 4535 ATF_TC_BODY(libbpfjit_cop_no_ctx, tc) 4536 { 4537 static struct bpf_insn insns[] = { 4538 BPF_STMT(BPF_MISC+BPF_COP, 0), 4539 BPF_STMT(BPF_RET+BPF_K, 7) 4540 }; 4541 4542 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4543 4544 ATF_CHECK(!bpf_validate(insns, insn_count)); 4545 4546 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 4547 } 4548 4549 ATF_TC(libbpfjit_copx_no_ctx); 4550 ATF_TC_HEAD(libbpfjit_copx_no_ctx, tc) 4551 { 4552 atf_tc_set_md_var(tc, "descr", "Test that BPF_MISC|BPF_COPX " 4553 "instruction can't be accepted without a context"); 4554 } 4555 4556 ATF_TC_BODY(libbpfjit_copx_no_ctx, tc) 4557 { 4558 static struct bpf_insn insns[] = { 4559 BPF_STMT(BPF_MISC+BPF_COPX, 0), 4560 BPF_STMT(BPF_RET+BPF_K, 7) 4561 }; 4562 4563 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 4564 4565 ATF_CHECK(!bpf_validate(insns, insn_count)); 4566 4567 ATF_CHECK(bpfjit_generate_code(NULL, insns, insn_count) == NULL); 4568 } 4569 4570 ATF_TP_ADD_TCS(tp) 4571 { 4572 4573 /* 4574 * For every new test please also add a similar test 4575 * to ../../net/bpfjit/t_bpfjit.c 4576 */ 4577 ATF_TP_ADD_TC(tp, libbpfjit_empty); 4578 ATF_TP_ADD_TC(tp, libbpfjit_ret_k); 4579 ATF_TP_ADD_TC(tp, libbpfjit_bad_ret_k); 4580 ATF_TP_ADD_TC(tp, libbpfjit_alu_add_k); 4581 ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_k); 4582 ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_k); 4583 ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_k); 4584 ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_k); 4585 ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_k); 4586 ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_k); 4587 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_k); 4588 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_k); 4589 ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_k); 4590 ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_k); 4591 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod0_k); 4592 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod1_k); 4593 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod2_k); 4594 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod4_k); 4595 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10_k); 4596 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10000_k); 4597 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod7609801_k); 4598 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod80000000_k); 4599 ATF_TP_ADD_TC(tp, libbpfjit_alu_and_k); 4600 ATF_TP_ADD_TC(tp, libbpfjit_alu_or_k); 4601 ATF_TP_ADD_TC(tp, libbpfjit_alu_xor_k); 4602 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_k); 4603 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_k); 4604 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_k); 4605 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_k); 4606 ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_k); 4607 ATF_TP_ADD_TC(tp, libbpfjit_alu_add_x); 4608 ATF_TP_ADD_TC(tp, libbpfjit_alu_sub_x); 4609 ATF_TP_ADD_TC(tp, libbpfjit_alu_mul_x); 4610 ATF_TP_ADD_TC(tp, libbpfjit_alu_div0_x); 4611 ATF_TP_ADD_TC(tp, libbpfjit_alu_div1_x); 4612 ATF_TP_ADD_TC(tp, libbpfjit_alu_div2_x); 4613 ATF_TP_ADD_TC(tp, libbpfjit_alu_div4_x); 4614 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10_x); 4615 ATF_TP_ADD_TC(tp, libbpfjit_alu_div10000_x); 4616 ATF_TP_ADD_TC(tp, libbpfjit_alu_div7609801_x); 4617 ATF_TP_ADD_TC(tp, libbpfjit_alu_div80000000_x); 4618 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod0_x); 4619 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod1_x); 4620 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod2_x); 4621 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod4_x); 4622 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10_x); 4623 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod10000_x); 4624 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod7609801_x); 4625 ATF_TP_ADD_TC(tp, libbpfjit_alu_mod80000000_x); 4626 ATF_TP_ADD_TC(tp, libbpfjit_alu_and_x); 4627 ATF_TP_ADD_TC(tp, libbpfjit_alu_or_x); 4628 ATF_TP_ADD_TC(tp, libbpfjit_alu_xor_x); 4629 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh_x); 4630 ATF_TP_ADD_TC(tp, libbpfjit_alu_lsh0_x); 4631 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh_x); 4632 ATF_TP_ADD_TC(tp, libbpfjit_alu_rsh0_x); 4633 ATF_TP_ADD_TC(tp, libbpfjit_alu_modulo_x); 4634 ATF_TP_ADD_TC(tp, libbpfjit_alu_neg); 4635 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja); 4636 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja_invalid); 4637 ATF_TP_ADD_TC(tp, libbpfjit_jmp_ja_overflow); 4638 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_k); 4639 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_k); 4640 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_k); 4641 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_k); 4642 ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_k); 4643 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jgt_x); 4644 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jge_x); 4645 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jeq_x); 4646 ATF_TP_ADD_TC(tp, libbpfjit_jmp_jset_x); 4647 ATF_TP_ADD_TC(tp, libbpfjit_jmp_x_uninitialised); 4648 ATF_TP_ADD_TC(tp, libbpfjit_jmp_modulo_x); 4649 ATF_TP_ADD_TC(tp, libbpfjit_ld_abs); 4650 ATF_TP_ADD_TC(tp, libbpfjit_ld_abs_k_overflow); 4651 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind); 4652 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_k_overflow); 4653 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow1); 4654 ATF_TP_ADD_TC(tp, libbpfjit_ld_ind_x_overflow2); 4655 ATF_TP_ADD_TC(tp, libbpfjit_ld_len); 4656 ATF_TP_ADD_TC(tp, libbpfjit_ld_imm); 4657 ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm1); 4658 ATF_TP_ADD_TC(tp, libbpfjit_ldx_imm2); 4659 ATF_TP_ADD_TC(tp, libbpfjit_ldx_len1); 4660 ATF_TP_ADD_TC(tp, libbpfjit_ldx_len2); 4661 ATF_TP_ADD_TC(tp, libbpfjit_ldx_msh); 4662 ATF_TP_ADD_TC(tp, libbpfjit_misc_tax); 4663 ATF_TP_ADD_TC(tp, libbpfjit_misc_txa); 4664 ATF_TP_ADD_TC(tp, libbpfjit_st1); 4665 ATF_TP_ADD_TC(tp, libbpfjit_st2); 4666 ATF_TP_ADD_TC(tp, libbpfjit_st3); 4667 ATF_TP_ADD_TC(tp, libbpfjit_st4); 4668 ATF_TP_ADD_TC(tp, libbpfjit_st5); 4669 ATF_TP_ADD_TC(tp, libbpfjit_stx1); 4670 ATF_TP_ADD_TC(tp, libbpfjit_stx2); 4671 ATF_TP_ADD_TC(tp, libbpfjit_stx3); 4672 ATF_TP_ADD_TC(tp, libbpfjit_stx4); 4673 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_1); 4674 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_2); 4675 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_abs_3); 4676 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_1); 4677 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_2); 4678 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_3); 4679 ATF_TP_ADD_TC(tp, libbpfjit_opt_ld_ind_4); 4680 ATF_TP_ADD_TC(tp, libbpfjit_abc_ja); 4681 ATF_TP_ADD_TC(tp, libbpfjit_abc_ja_over); 4682 ATF_TP_ADD_TC(tp, libbpfjit_abc_ld_chain); 4683 ATF_TP_ADD_TC(tp, libbpfjit_examples_1); 4684 ATF_TP_ADD_TC(tp, libbpfjit_examples_2); 4685 ATF_TP_ADD_TC(tp, libbpfjit_examples_3); 4686 ATF_TP_ADD_TC(tp, libbpfjit_cop_no_ctx); 4687 ATF_TP_ADD_TC(tp, libbpfjit_copx_no_ctx); 4688 4689 return atf_no_error(); 4690 } 4691
Indexes created Mon Sep 22 05:09:51 GMT 2025