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