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