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