t_bpfjit.c revision 1.1
1 /* $NetBSD: t_bpfjit.c,v 1.1 2012/11/11 17:37:34 alnsn Exp $ */ 2 3 /*- 4 * Copyright (c) 2011-2012 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.1 2012/11/11 17:37:34 alnsn Exp $"); 34 35 #include <net/bpfjit.h> 36 37 #include <atf-c.h> 38 #include <stdint.h> 39 #include <string.h> 40 41 static uint8_t deadbeef_at_5[16] = { 42 0, 0xf1, 2, 0xf3, 4, 0xde, 0xad, 0xbe, 0xef, 0xff 43 }; 44 45 ATF_TC(bpfjit_empty); 46 ATF_TC_HEAD(bpfjit_empty, tc) 47 { 48 atf_tc_set_md_var(tc, "descr", 49 "Test that JIT compilation for an empty bpf program fails"); 50 } 51 52 ATF_TC_BODY(bpfjit_empty, tc) 53 { 54 struct bpf_insn dummy; 55 56 ATF_CHECK(bpfjit_generate_code(&dummy, 0) == NULL); 57 } 58 59 ATF_TC(bpfjit_alu_add_k); 60 ATF_TC_HEAD(bpfjit_alu_add_k, tc) 61 { 62 atf_tc_set_md_var(tc, "descr", 63 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_K"); 64 } 65 66 ATF_TC_BODY(bpfjit_alu_add_k, tc) 67 { 68 static struct bpf_insn insns[] = { 69 BPF_STMT(BPF_LD+BPF_IMM, 3), 70 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 2), 71 BPF_STMT(BPF_RET+BPF_A, 0) 72 }; 73 74 bpfjit_function_t code; 75 uint8_t pkt[1]; /* the program doesn't read any data */ 76 77 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 78 79 ATF_CHECK(bpf_validate(insns, insn_count)); 80 81 code = bpfjit_generate_code(insns, insn_count); 82 ATF_REQUIRE(code != NULL); 83 84 ATF_CHECK(code(pkt, 1, 1) == 5); 85 86 bpfjit_free_code(code); 87 } 88 89 ATF_TC(bpfjit_alu_sub_k); 90 ATF_TC_HEAD(bpfjit_alu_sub_k, tc) 91 { 92 atf_tc_set_md_var(tc, "descr", 93 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_K"); 94 } 95 96 ATF_TC_BODY(bpfjit_alu_sub_k, tc) 97 { 98 static struct bpf_insn insns[] = { 99 BPF_STMT(BPF_LD+BPF_IMM, 1), 100 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, 2), 101 BPF_STMT(BPF_RET+BPF_A, 0) 102 }; 103 104 bpfjit_function_t code; 105 uint8_t pkt[1]; /* the program doesn't read any data */ 106 107 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 108 109 ATF_CHECK(bpf_validate(insns, insn_count)); 110 111 code = bpfjit_generate_code(insns, insn_count); 112 ATF_REQUIRE(code != NULL); 113 114 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 115 116 bpfjit_free_code(code); 117 } 118 119 ATF_TC(bpfjit_alu_mul_k); 120 ATF_TC_HEAD(bpfjit_alu_mul_k, tc) 121 { 122 atf_tc_set_md_var(tc, "descr", 123 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_K"); 124 } 125 126 ATF_TC_BODY(bpfjit_alu_mul_k, tc) 127 { 128 static struct bpf_insn insns[] = { 129 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 130 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, 3), 131 BPF_STMT(BPF_RET+BPF_A, 0) 132 }; 133 134 bpfjit_function_t code; 135 uint8_t pkt[1]; /* the program doesn't read any data */ 136 137 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 138 139 ATF_CHECK(bpf_validate(insns, insn_count)); 140 141 code = bpfjit_generate_code(insns, insn_count); 142 ATF_REQUIRE(code != NULL); 143 144 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0xfffffffd)); 145 146 bpfjit_free_code(code); 147 } 148 149 ATF_TC(bpfjit_alu_div0_k); 150 ATF_TC_HEAD(bpfjit_alu_div0_k, tc) 151 { 152 atf_tc_set_md_var(tc, "descr", 153 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0"); 154 } 155 156 ATF_TC_BODY(bpfjit_alu_div0_k, tc) 157 { 158 static struct bpf_insn insns[] = { 159 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 0), 160 BPF_STMT(BPF_RET+BPF_A, 0) 161 }; 162 163 bpfjit_function_t code; 164 uint8_t pkt[1]; /* the program doesn't read any data */ 165 166 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 167 168 //ATF_CHECK(bpf_validate(insns, insn_count)); 169 170 code = bpfjit_generate_code(insns, insn_count); 171 ATF_REQUIRE(code != NULL); 172 173 ATF_CHECK(code(pkt, 1, 1) == 0); 174 175 bpfjit_free_code(code); 176 } 177 178 ATF_TC(bpfjit_alu_div1_k); 179 ATF_TC_HEAD(bpfjit_alu_div1_k, tc) 180 { 181 atf_tc_set_md_var(tc, "descr", 182 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=1"); 183 } 184 185 ATF_TC_BODY(bpfjit_alu_div1_k, tc) 186 { 187 static struct bpf_insn insns[] = { 188 BPF_STMT(BPF_LD+BPF_IMM, 7), 189 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 1), 190 BPF_STMT(BPF_RET+BPF_A, 0) 191 }; 192 193 bpfjit_function_t code; 194 uint8_t pkt[1]; /* the program doesn't read any data */ 195 196 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 197 198 ATF_CHECK(bpf_validate(insns, insn_count)); 199 200 code = bpfjit_generate_code(insns, insn_count); 201 ATF_REQUIRE(code != NULL); 202 203 ATF_CHECK(code(pkt, 1, 1) == 7); 204 205 bpfjit_free_code(code); 206 } 207 208 ATF_TC(bpfjit_alu_div2_k); 209 ATF_TC_HEAD(bpfjit_alu_div2_k, tc) 210 { 211 atf_tc_set_md_var(tc, "descr", 212 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=2"); 213 } 214 215 ATF_TC_BODY(bpfjit_alu_div2_k, tc) 216 { 217 static struct bpf_insn insns[] = { 218 BPF_STMT(BPF_LD+BPF_IMM, 7), 219 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 2), 220 BPF_STMT(BPF_RET+BPF_A, 0) 221 }; 222 223 bpfjit_function_t code; 224 uint8_t pkt[1]; /* the program doesn't read any data */ 225 226 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 227 228 ATF_CHECK(bpf_validate(insns, insn_count)); 229 230 code = bpfjit_generate_code(insns, insn_count); 231 ATF_REQUIRE(code != NULL); 232 233 ATF_CHECK(code(pkt, 1, 1) == 3); 234 235 bpfjit_free_code(code); 236 } 237 238 ATF_TC(bpfjit_alu_div4_k); 239 ATF_TC_HEAD(bpfjit_alu_div4_k, tc) 240 { 241 atf_tc_set_md_var(tc, "descr", 242 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=4"); 243 } 244 245 ATF_TC_BODY(bpfjit_alu_div4_k, tc) 246 { 247 static struct bpf_insn insns[] = { 248 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 249 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), 250 BPF_STMT(BPF_RET+BPF_A, 0) 251 }; 252 253 bpfjit_function_t code; 254 uint8_t pkt[1]; /* the program doesn't read any data */ 255 256 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 257 258 ATF_CHECK(bpf_validate(insns, insn_count)); 259 260 code = bpfjit_generate_code(insns, insn_count); 261 ATF_REQUIRE(code != NULL); 262 263 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x3fffffff)); 264 265 bpfjit_free_code(code); 266 } 267 268 ATF_TC(bpfjit_alu_div10_k); 269 ATF_TC_HEAD(bpfjit_alu_div10_k, tc) 270 { 271 atf_tc_set_md_var(tc, "descr", 272 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10"); 273 } 274 275 ATF_TC_BODY(bpfjit_alu_div10_k, tc) 276 { 277 static struct bpf_insn insns[] = { 278 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 279 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10), 280 BPF_STMT(BPF_RET+BPF_A, 0) 281 }; 282 283 bpfjit_function_t code; 284 uint8_t pkt[1]; /* the program doesn't read any data */ 285 286 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 287 288 ATF_CHECK(bpf_validate(insns, insn_count)); 289 290 code = bpfjit_generate_code(insns, insn_count); 291 ATF_REQUIRE(code != NULL); 292 293 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484384)); 294 295 bpfjit_free_code(code); 296 } 297 298 ATF_TC(bpfjit_alu_div10000_k); 299 ATF_TC_HEAD(bpfjit_alu_div10000_k, tc) 300 { 301 atf_tc_set_md_var(tc, "descr", 302 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10000"); 303 } 304 305 ATF_TC_BODY(bpfjit_alu_div10000_k, tc) 306 { 307 static struct bpf_insn insns[] = { 308 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 309 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10000), 310 BPF_STMT(BPF_RET+BPF_A, 0) 311 }; 312 313 bpfjit_function_t code; 314 uint8_t pkt[1]; /* the program doesn't read any data */ 315 316 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 317 318 ATF_CHECK(bpf_validate(insns, insn_count)); 319 320 code = bpfjit_generate_code(insns, insn_count); 321 ATF_REQUIRE(code != NULL); 322 323 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484)); 324 325 bpfjit_free_code(code); 326 } 327 328 ATF_TC(bpfjit_alu_div7609801_k); 329 ATF_TC_HEAD(bpfjit_alu_div7609801_k, tc) 330 { 331 atf_tc_set_md_var(tc, "descr", 332 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=7609801"); 333 } 334 335 ATF_TC_BODY(bpfjit_alu_div7609801_k, tc) 336 { 337 static struct bpf_insn insns[] = { 338 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 339 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(7609801)), 340 BPF_STMT(BPF_RET+BPF_A, 0) 341 }; 342 343 bpfjit_function_t code; 344 uint8_t pkt[1]; /* the program doesn't read any data */ 345 346 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 347 348 ATF_CHECK(bpf_validate(insns, insn_count)); 349 350 code = bpfjit_generate_code(insns, insn_count); 351 ATF_REQUIRE(code != NULL); 352 353 ATF_CHECK(code(pkt, 1, 1) == 564); 354 355 bpfjit_free_code(code); 356 } 357 358 ATF_TC(bpfjit_alu_div80000000_k); 359 ATF_TC_HEAD(bpfjit_alu_div80000000_k, tc) 360 { 361 atf_tc_set_md_var(tc, "descr", 362 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0x80000000"); 363 } 364 365 ATF_TC_BODY(bpfjit_alu_div80000000_k, tc) 366 { 367 static struct bpf_insn insns[] = { 368 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)), 369 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0x80000000)), 370 BPF_STMT(BPF_RET+BPF_A, 0) 371 }; 372 373 bpfjit_function_t code; 374 uint8_t pkt[1]; /* the program doesn't read any data */ 375 376 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 377 378 ATF_CHECK(bpf_validate(insns, insn_count)); 379 380 code = bpfjit_generate_code(insns, insn_count); 381 ATF_REQUIRE(code != NULL); 382 383 ATF_CHECK(code(pkt, 1, 1) == 1); 384 385 bpfjit_free_code(code); 386 } 387 388 ATF_TC(bpfjit_alu_and_k); 389 ATF_TC_HEAD(bpfjit_alu_and_k, tc) 390 { 391 atf_tc_set_md_var(tc, "descr", 392 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_K"); 393 } 394 395 ATF_TC_BODY(bpfjit_alu_and_k, tc) 396 { 397 static struct bpf_insn insns[] = { 398 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 399 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xbeef), 400 BPF_STMT(BPF_RET+BPF_A, 0) 401 }; 402 403 bpfjit_function_t code; 404 uint8_t pkt[1]; /* the program doesn't read any data */ 405 406 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 407 408 ATF_CHECK(bpf_validate(insns, insn_count)); 409 410 code = bpfjit_generate_code(insns, insn_count); 411 ATF_REQUIRE(code != NULL); 412 413 ATF_CHECK(code(pkt, 1, 1) == (0xdead&0xbeef)); 414 415 bpfjit_free_code(code); 416 } 417 418 ATF_TC(bpfjit_alu_or_k); 419 ATF_TC_HEAD(bpfjit_alu_or_k, tc) 420 { 421 atf_tc_set_md_var(tc, "descr", 422 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_K"); 423 } 424 425 ATF_TC_BODY(bpfjit_alu_or_k, tc) 426 { 427 static struct bpf_insn insns[] = { 428 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 429 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, 0x0000beef), 430 BPF_STMT(BPF_RET+BPF_A, 0) 431 }; 432 433 bpfjit_function_t code; 434 uint8_t pkt[1]; /* the program doesn't read any data */ 435 436 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 437 438 ATF_CHECK(bpf_validate(insns, insn_count)); 439 440 code = bpfjit_generate_code(insns, insn_count); 441 ATF_REQUIRE(code != NULL); 442 443 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 444 445 bpfjit_free_code(code); 446 } 447 448 ATF_TC(bpfjit_alu_lsh_k); 449 ATF_TC_HEAD(bpfjit_alu_lsh_k, tc) 450 { 451 atf_tc_set_md_var(tc, "descr", 452 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K"); 453 } 454 455 ATF_TC_BODY(bpfjit_alu_lsh_k, tc) 456 { 457 static struct bpf_insn insns[] = { 458 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 459 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 16), 460 BPF_STMT(BPF_RET+BPF_A, 0) 461 }; 462 463 bpfjit_function_t code; 464 uint8_t pkt[1]; /* the program doesn't read any data */ 465 466 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 467 468 ATF_CHECK(bpf_validate(insns, insn_count)); 469 470 code = bpfjit_generate_code(insns, insn_count); 471 ATF_REQUIRE(code != NULL); 472 473 ATF_CHECK(code(pkt, 1, 1) == 0xbeef0000); 474 475 bpfjit_free_code(code); 476 } 477 478 ATF_TC(bpfjit_alu_lsh0_k); 479 ATF_TC_HEAD(bpfjit_alu_lsh0_k, tc) 480 { 481 atf_tc_set_md_var(tc, "descr", 482 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K with k=0"); 483 } 484 485 ATF_TC_BODY(bpfjit_alu_lsh0_k, tc) 486 { 487 static struct bpf_insn insns[] = { 488 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 489 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 0), 490 BPF_STMT(BPF_RET+BPF_A, 0) 491 }; 492 493 bpfjit_function_t code; 494 uint8_t pkt[1]; /* the program doesn't read any data */ 495 496 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 497 498 ATF_CHECK(bpf_validate(insns, insn_count)); 499 500 code = bpfjit_generate_code(insns, insn_count); 501 ATF_REQUIRE(code != NULL); 502 503 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 504 505 bpfjit_free_code(code); 506 } 507 508 ATF_TC(bpfjit_alu_rsh_k); 509 ATF_TC_HEAD(bpfjit_alu_rsh_k, tc) 510 { 511 atf_tc_set_md_var(tc, "descr", 512 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K"); 513 } 514 515 ATF_TC_BODY(bpfjit_alu_rsh_k, tc) 516 { 517 static struct bpf_insn insns[] = { 518 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 519 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 16), 520 BPF_STMT(BPF_RET+BPF_A, 0) 521 }; 522 523 bpfjit_function_t code; 524 uint8_t pkt[1]; /* the program doesn't read any data */ 525 526 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 527 528 ATF_CHECK(bpf_validate(insns, insn_count)); 529 530 code = bpfjit_generate_code(insns, insn_count); 531 ATF_REQUIRE(code != NULL); 532 533 ATF_CHECK(code(pkt, 1, 1) == 0x0000dead); 534 535 bpfjit_free_code(code); 536 } 537 538 ATF_TC(bpfjit_alu_rsh0_k); 539 ATF_TC_HEAD(bpfjit_alu_rsh0_k, tc) 540 { 541 atf_tc_set_md_var(tc, "descr", 542 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K with k=0"); 543 } 544 545 ATF_TC_BODY(bpfjit_alu_rsh0_k, tc) 546 { 547 static struct bpf_insn insns[] = { 548 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 549 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 0), 550 BPF_STMT(BPF_RET+BPF_A, 0) 551 }; 552 553 bpfjit_function_t code; 554 uint8_t pkt[1]; /* the program doesn't read any data */ 555 556 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 557 558 ATF_CHECK(bpf_validate(insns, insn_count)); 559 560 code = bpfjit_generate_code(insns, insn_count); 561 ATF_REQUIRE(code != NULL); 562 563 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 564 565 bpfjit_free_code(code); 566 } 567 568 ATF_TC(bpfjit_alu_modulo_k); 569 ATF_TC_HEAD(bpfjit_alu_modulo_k, tc) 570 { 571 atf_tc_set_md_var(tc, "descr", 572 "Test JIT compilation of modulo logic of BPF_ALU+BPF_K operations"); 573 } 574 575 ATF_TC_BODY(bpfjit_alu_modulo_k, tc) 576 { 577 static struct bpf_insn insns[] = { 578 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 579 580 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 581 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x0fffff77)), 582 583 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 584 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 1), 585 586 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 587 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xdddddddd)), 588 589 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 590 BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, UINT32_C(0xffffffff)), 591 592 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 593 BPF_STMT(BPF_ALU+BPF_OR+BPF_K, UINT32_C(0x0000030c)), 594 595 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 596 BPF_STMT(BPF_ALU+BPF_NEG, 0), 597 598 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 599 BPF_STMT(BPF_ALU+BPF_AND+BPF_K, UINT32_C(0xffffff0f)), 600 601 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 602 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 603 BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 3), 604 605 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 606 BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x7fffff77)), 607 608 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 609 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 610 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0xdead)), 611 612 BPF_STMT(BPF_RET+BPF_A, 0) 613 }; 614 615 bpfjit_function_t code; 616 uint8_t pkt[1]; /* the program doesn't read any data */ 617 618 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 619 620 ATF_CHECK(bpf_validate(insns, insn_count)); 621 622 code = bpfjit_generate_code(insns, insn_count); 623 ATF_REQUIRE(code != NULL); 624 625 ATF_CHECK(code(pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 626 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x0000a994)); 627 628 629 bpfjit_free_code(code); 630 } 631 632 ATF_TC(bpfjit_alu_add_x); 633 ATF_TC_HEAD(bpfjit_alu_add_x, tc) 634 { 635 atf_tc_set_md_var(tc, "descr", 636 "Test JIT compilation of BPF_ALU+BPF_ADD+BPF_X"); 637 } 638 639 ATF_TC_BODY(bpfjit_alu_add_x, tc) 640 { 641 static struct bpf_insn insns[] = { 642 BPF_STMT(BPF_LD+BPF_IMM, 3), 643 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 644 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 645 BPF_STMT(BPF_RET+BPF_A, 0) 646 }; 647 648 bpfjit_function_t code; 649 uint8_t pkt[1]; /* the program doesn't read any data */ 650 651 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 652 653 ATF_CHECK(bpf_validate(insns, insn_count)); 654 655 code = bpfjit_generate_code(insns, insn_count); 656 ATF_REQUIRE(code != NULL); 657 658 ATF_CHECK(code(pkt, 1, 1) == 5); 659 660 bpfjit_free_code(code); 661 } 662 663 ATF_TC(bpfjit_alu_sub_x); 664 ATF_TC_HEAD(bpfjit_alu_sub_x, tc) 665 { 666 atf_tc_set_md_var(tc, "descr", 667 "Test JIT compilation of BPF_ALU+BPF_SUB+BPF_X"); 668 } 669 670 ATF_TC_BODY(bpfjit_alu_sub_x, tc) 671 { 672 static struct bpf_insn insns[] = { 673 BPF_STMT(BPF_LD+BPF_IMM, 1), 674 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 675 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 676 BPF_STMT(BPF_RET+BPF_A, 0) 677 }; 678 679 bpfjit_function_t code; 680 uint8_t pkt[1]; /* the program doesn't read any data */ 681 682 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 683 684 ATF_CHECK(bpf_validate(insns, insn_count)); 685 686 code = bpfjit_generate_code(insns, insn_count); 687 ATF_REQUIRE(code != NULL); 688 689 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 690 691 bpfjit_free_code(code); 692 } 693 694 ATF_TC(bpfjit_alu_mul_x); 695 ATF_TC_HEAD(bpfjit_alu_mul_x, tc) 696 { 697 atf_tc_set_md_var(tc, "descr", 698 "Test JIT compilation of BPF_ALU+BPF_MUL+BPF_X"); 699 } 700 701 ATF_TC_BODY(bpfjit_alu_mul_x, tc) 702 { 703 static struct bpf_insn insns[] = { 704 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 705 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 706 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 707 BPF_STMT(BPF_RET+BPF_A, 0) 708 }; 709 710 bpfjit_function_t code; 711 uint8_t pkt[1]; /* the program doesn't read any data */ 712 713 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 714 715 ATF_CHECK(bpf_validate(insns, insn_count)); 716 717 code = bpfjit_generate_code(insns, insn_count); 718 ATF_REQUIRE(code != NULL); 719 720 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0xfffffffd)); 721 722 bpfjit_free_code(code); 723 } 724 725 ATF_TC(bpfjit_alu_div0_x); 726 ATF_TC_HEAD(bpfjit_alu_div0_x, tc) 727 { 728 atf_tc_set_md_var(tc, "descr", 729 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0"); 730 } 731 732 ATF_TC_BODY(bpfjit_alu_div0_x, tc) 733 { 734 static struct bpf_insn insns[] = { 735 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 736 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 737 BPF_STMT(BPF_RET+BPF_A, 0) 738 }; 739 740 bpfjit_function_t code; 741 uint8_t pkt[1]; /* the program doesn't read any data */ 742 743 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 744 745 ATF_CHECK(bpf_validate(insns, insn_count)); 746 747 code = bpfjit_generate_code(insns, insn_count); 748 ATF_REQUIRE(code != NULL); 749 750 ATF_CHECK(code(pkt, 1, 1) == 0); 751 752 bpfjit_free_code(code); 753 } 754 755 ATF_TC(bpfjit_alu_div1_x); 756 ATF_TC_HEAD(bpfjit_alu_div1_x, tc) 757 { 758 atf_tc_set_md_var(tc, "descr", 759 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=1"); 760 } 761 762 ATF_TC_BODY(bpfjit_alu_div1_x, tc) 763 { 764 static struct bpf_insn insns[] = { 765 BPF_STMT(BPF_LD+BPF_IMM, 7), 766 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 767 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 768 BPF_STMT(BPF_RET+BPF_A, 0) 769 }; 770 771 bpfjit_function_t code; 772 uint8_t pkt[1]; /* the program doesn't read any data */ 773 774 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 775 776 ATF_CHECK(bpf_validate(insns, insn_count)); 777 778 code = bpfjit_generate_code(insns, insn_count); 779 ATF_REQUIRE(code != NULL); 780 781 ATF_CHECK(code(pkt, 1, 1) == 7); 782 783 bpfjit_free_code(code); 784 } 785 786 ATF_TC(bpfjit_alu_div2_x); 787 ATF_TC_HEAD(bpfjit_alu_div2_x, tc) 788 { 789 atf_tc_set_md_var(tc, "descr", 790 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=2"); 791 } 792 793 ATF_TC_BODY(bpfjit_alu_div2_x, tc) 794 { 795 static struct bpf_insn insns[] = { 796 BPF_STMT(BPF_LD+BPF_IMM, 7), 797 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 798 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 799 BPF_STMT(BPF_RET+BPF_A, 0) 800 }; 801 802 bpfjit_function_t code; 803 uint8_t pkt[1]; /* the program doesn't read any data */ 804 805 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 806 807 ATF_CHECK(bpf_validate(insns, insn_count)); 808 809 code = bpfjit_generate_code(insns, insn_count); 810 ATF_REQUIRE(code != NULL); 811 812 ATF_CHECK(code(pkt, 1, 1) == 3); 813 814 bpfjit_free_code(code); 815 } 816 817 ATF_TC(bpfjit_alu_div4_x); 818 ATF_TC_HEAD(bpfjit_alu_div4_x, tc) 819 { 820 atf_tc_set_md_var(tc, "descr", 821 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=4"); 822 } 823 824 ATF_TC_BODY(bpfjit_alu_div4_x, tc) 825 { 826 static struct bpf_insn insns[] = { 827 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)), 828 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 829 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 830 BPF_STMT(BPF_RET+BPF_A, 0) 831 }; 832 833 bpfjit_function_t code; 834 uint8_t pkt[1]; /* the program doesn't read any data */ 835 836 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 837 838 ATF_CHECK(bpf_validate(insns, insn_count)); 839 840 code = bpfjit_generate_code(insns, insn_count); 841 ATF_REQUIRE(code != NULL); 842 843 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x3fffffff)); 844 845 bpfjit_free_code(code); 846 } 847 848 ATF_TC(bpfjit_alu_div10_x); 849 ATF_TC_HEAD(bpfjit_alu_div10_x, tc) 850 { 851 atf_tc_set_md_var(tc, "descr", 852 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10"); 853 } 854 855 ATF_TC_BODY(bpfjit_alu_div10_x, tc) 856 { 857 static struct bpf_insn insns[] = { 858 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 859 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10), 860 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 861 BPF_STMT(BPF_RET+BPF_A, 0) 862 }; 863 864 bpfjit_function_t code; 865 uint8_t pkt[1]; /* the program doesn't read any data */ 866 867 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 868 869 ATF_CHECK(bpf_validate(insns, insn_count)); 870 871 code = bpfjit_generate_code(insns, insn_count); 872 ATF_REQUIRE(code != NULL); 873 874 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484384)); 875 876 bpfjit_free_code(code); 877 } 878 879 ATF_TC(bpfjit_alu_div10000_x); 880 ATF_TC_HEAD(bpfjit_alu_div10000_x, tc) 881 { 882 atf_tc_set_md_var(tc, "descr", 883 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10000"); 884 } 885 886 ATF_TC_BODY(bpfjit_alu_div10000_x, tc) 887 { 888 static struct bpf_insn insns[] = { 889 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)), 890 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000), 891 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 892 BPF_STMT(BPF_RET+BPF_A, 0) 893 }; 894 895 bpfjit_function_t code; 896 uint8_t pkt[1]; /* the program doesn't read any data */ 897 898 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 899 900 ATF_CHECK(bpf_validate(insns, insn_count)); 901 902 code = bpfjit_generate_code(insns, insn_count); 903 ATF_REQUIRE(code != NULL); 904 905 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484)); 906 907 bpfjit_free_code(code); 908 } 909 910 ATF_TC(bpfjit_alu_div7609801_x); 911 ATF_TC_HEAD(bpfjit_alu_div7609801_x, tc) 912 { 913 atf_tc_set_md_var(tc, "descr", 914 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=7609801"); 915 } 916 917 ATF_TC_BODY(bpfjit_alu_div7609801_x, tc) 918 { 919 static struct bpf_insn insns[] = { 920 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)), 921 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)), 922 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 923 BPF_STMT(BPF_RET+BPF_A, 0) 924 }; 925 926 bpfjit_function_t code; 927 uint8_t pkt[1]; /* the program doesn't read any data */ 928 929 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 930 931 ATF_CHECK(bpf_validate(insns, insn_count)); 932 933 code = bpfjit_generate_code(insns, insn_count); 934 ATF_REQUIRE(code != NULL); 935 936 ATF_CHECK(code(pkt, 1, 1) == 564); 937 938 bpfjit_free_code(code); 939 } 940 941 ATF_TC(bpfjit_alu_div80000000_x); 942 ATF_TC_HEAD(bpfjit_alu_div80000000_x, tc) 943 { 944 atf_tc_set_md_var(tc, "descr", 945 "Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0x80000000"); 946 } 947 948 ATF_TC_BODY(bpfjit_alu_div80000000_x, tc) 949 { 950 static struct bpf_insn insns[] = { 951 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX - 33), 952 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)), 953 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 954 BPF_STMT(BPF_RET+BPF_A, 0) 955 }; 956 957 bpfjit_function_t code; 958 uint8_t pkt[1]; /* the program doesn't read any data */ 959 960 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 961 962 ATF_CHECK(bpf_validate(insns, insn_count)); 963 964 code = bpfjit_generate_code(insns, insn_count); 965 ATF_REQUIRE(code != NULL); 966 967 ATF_CHECK(code(pkt, 1, 1) == 1); 968 969 bpfjit_free_code(code); 970 } 971 972 ATF_TC(bpfjit_alu_and_x); 973 ATF_TC_HEAD(bpfjit_alu_and_x, tc) 974 { 975 atf_tc_set_md_var(tc, "descr", 976 "Test JIT compilation of BPF_ALU+BPF_AND+BPF_X"); 977 } 978 979 ATF_TC_BODY(bpfjit_alu_and_x, tc) 980 { 981 static struct bpf_insn insns[] = { 982 BPF_STMT(BPF_LD+BPF_IMM, 0xdead), 983 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0xbeef), 984 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 985 BPF_STMT(BPF_RET+BPF_A, 0) 986 }; 987 988 bpfjit_function_t code; 989 uint8_t pkt[1]; /* the program doesn't read any data */ 990 991 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 992 993 ATF_CHECK(bpf_validate(insns, insn_count)); 994 995 code = bpfjit_generate_code(insns, insn_count); 996 ATF_REQUIRE(code != NULL); 997 998 ATF_CHECK(code(pkt, 1, 1) == (0xdead&0xbeef)); 999 1000 bpfjit_free_code(code); 1001 } 1002 1003 ATF_TC(bpfjit_alu_or_x); 1004 ATF_TC_HEAD(bpfjit_alu_or_x, tc) 1005 { 1006 atf_tc_set_md_var(tc, "descr", 1007 "Test JIT compilation of BPF_ALU+BPF_OR+BPF_X"); 1008 } 1009 1010 ATF_TC_BODY(bpfjit_alu_or_x, tc) 1011 { 1012 static struct bpf_insn insns[] = { 1013 BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000), 1014 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0x0000beef), 1015 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1016 BPF_STMT(BPF_RET+BPF_A, 0) 1017 }; 1018 1019 bpfjit_function_t code; 1020 uint8_t pkt[1]; /* the program doesn't read any data */ 1021 1022 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1023 1024 ATF_CHECK(bpf_validate(insns, insn_count)); 1025 1026 code = bpfjit_generate_code(insns, insn_count); 1027 ATF_REQUIRE(code != NULL); 1028 1029 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 1030 1031 bpfjit_free_code(code); 1032 } 1033 1034 ATF_TC(bpfjit_alu_lsh_x); 1035 ATF_TC_HEAD(bpfjit_alu_lsh_x, tc) 1036 { 1037 atf_tc_set_md_var(tc, "descr", 1038 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X"); 1039 } 1040 1041 ATF_TC_BODY(bpfjit_alu_lsh_x, tc) 1042 { 1043 static struct bpf_insn insns[] = { 1044 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1045 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1046 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1047 BPF_STMT(BPF_RET+BPF_A, 0) 1048 }; 1049 1050 bpfjit_function_t code; 1051 uint8_t pkt[1]; /* the program doesn't read any data */ 1052 1053 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1054 1055 ATF_CHECK(bpf_validate(insns, insn_count)); 1056 1057 code = bpfjit_generate_code(insns, insn_count); 1058 ATF_REQUIRE(code != NULL); 1059 1060 ATF_CHECK(code(pkt, 1, 1) == 0xbeef0000); 1061 1062 bpfjit_free_code(code); 1063 } 1064 1065 ATF_TC(bpfjit_alu_lsh0_x); 1066 ATF_TC_HEAD(bpfjit_alu_lsh0_x, tc) 1067 { 1068 atf_tc_set_md_var(tc, "descr", 1069 "Test JIT compilation of BPF_ALU+BPF_LSH+BPF_X with k=0"); 1070 } 1071 1072 ATF_TC_BODY(bpfjit_alu_lsh0_x, tc) 1073 { 1074 static struct bpf_insn insns[] = { 1075 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1076 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1077 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1078 BPF_STMT(BPF_RET+BPF_A, 0) 1079 }; 1080 1081 bpfjit_function_t code; 1082 uint8_t pkt[1]; /* the program doesn't read any data */ 1083 1084 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1085 1086 ATF_CHECK(bpf_validate(insns, insn_count)); 1087 1088 code = bpfjit_generate_code(insns, insn_count); 1089 ATF_REQUIRE(code != NULL); 1090 1091 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 1092 1093 bpfjit_free_code(code); 1094 } 1095 1096 ATF_TC(bpfjit_alu_rsh_x); 1097 ATF_TC_HEAD(bpfjit_alu_rsh_x, tc) 1098 { 1099 atf_tc_set_md_var(tc, "descr", 1100 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X"); 1101 } 1102 1103 ATF_TC_BODY(bpfjit_alu_rsh_x, tc) 1104 { 1105 static struct bpf_insn insns[] = { 1106 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1107 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 16), 1108 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1109 BPF_STMT(BPF_RET+BPF_A, 0) 1110 }; 1111 1112 bpfjit_function_t code; 1113 uint8_t pkt[1]; /* the program doesn't read any data */ 1114 1115 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1116 1117 ATF_CHECK(bpf_validate(insns, insn_count)); 1118 1119 code = bpfjit_generate_code(insns, insn_count); 1120 ATF_REQUIRE(code != NULL); 1121 1122 ATF_CHECK(code(pkt, 1, 1) == 0x0000dead); 1123 1124 bpfjit_free_code(code); 1125 } 1126 1127 ATF_TC(bpfjit_alu_rsh0_x); 1128 ATF_TC_HEAD(bpfjit_alu_rsh0_x, tc) 1129 { 1130 atf_tc_set_md_var(tc, "descr", 1131 "Test JIT compilation of BPF_ALU+BPF_RSH+BPF_X with k=0"); 1132 } 1133 1134 ATF_TC_BODY(bpfjit_alu_rsh0_x, tc) 1135 { 1136 static struct bpf_insn insns[] = { 1137 BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef), 1138 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1139 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1140 BPF_STMT(BPF_RET+BPF_A, 0) 1141 }; 1142 1143 bpfjit_function_t code; 1144 uint8_t pkt[1]; /* the program doesn't read any data */ 1145 1146 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1147 1148 ATF_CHECK(bpf_validate(insns, insn_count)); 1149 1150 code = bpfjit_generate_code(insns, insn_count); 1151 ATF_REQUIRE(code != NULL); 1152 1153 ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef); 1154 1155 bpfjit_free_code(code); 1156 } 1157 1158 ATF_TC(bpfjit_alu_modulo_x); 1159 ATF_TC_HEAD(bpfjit_alu_modulo_x, tc) 1160 { 1161 atf_tc_set_md_var(tc, "descr", 1162 "Test JIT compilation of modulo logic of BPF_ALU+BPF_X operations"); 1163 } 1164 1165 ATF_TC_BODY(bpfjit_alu_modulo_x, tc) 1166 { 1167 static struct bpf_insn insns[] = { 1168 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1169 1170 /* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */ 1171 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0fffff77)), 1172 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1173 1174 /* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */ 1175 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 1), 1176 BPF_STMT(BPF_ALU+BPF_LSH+BPF_X, 0), 1177 1178 /* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */ 1179 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdddddddd)), 1180 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 1181 1182 /* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */ 1183 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffffff)), 1184 BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0), 1185 1186 /* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */ 1187 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x0000030c)), 1188 BPF_STMT(BPF_ALU+BPF_OR+BPF_X, 0), 1189 1190 /* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */ 1191 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1192 1193 /* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */ 1194 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xffffff0f)), 1195 BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0), 1196 1197 /* F000009A,42218C74 >> 3 = 1E000013,48443180 */ 1198 /* 00000000,42218C74 >> 3 = 00000000,08443180 */ 1199 BPF_STMT(BPF_LDX+BPF_W+BPF_K, 3), 1200 BPF_STMT(BPF_ALU+BPF_RSH+BPF_X, 0), 1201 1202 /* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */ 1203 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0x7fffff77)), 1204 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), 1205 1206 /* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */ 1207 /* 00000000,93818280 / DEAD = 00000000,0000A994 */ 1208 BPF_STMT(BPF_LDX+BPF_W+BPF_K, UINT32_C(0xdead)), 1209 BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0), 1210 1211 BPF_STMT(BPF_RET+BPF_A, 0) 1212 }; 1213 1214 bpfjit_function_t code; 1215 uint8_t pkt[1]; /* the program doesn't read any data */ 1216 1217 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1218 1219 ATF_CHECK(bpf_validate(insns, insn_count)); 1220 1221 code = bpfjit_generate_code(insns, insn_count); 1222 ATF_REQUIRE(code != NULL); 1223 1224 ATF_CHECK(code(pkt, 1, 1) != UINT32_C(0x71cbbbc3)); 1225 ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x0000a994)); 1226 1227 1228 bpfjit_free_code(code); 1229 } 1230 1231 ATF_TC(bpfjit_alu_neg); 1232 ATF_TC_HEAD(bpfjit_alu_neg, tc) 1233 { 1234 atf_tc_set_md_var(tc, "descr", 1235 "Test JIT compilation of BPF_ALU+BPF_NEG"); 1236 } 1237 1238 ATF_TC_BODY(bpfjit_alu_neg, tc) 1239 { 1240 static struct bpf_insn insns[] = { 1241 BPF_STMT(BPF_LD+BPF_IMM, 777), 1242 BPF_STMT(BPF_ALU+BPF_NEG, 0), 1243 BPF_STMT(BPF_RET+BPF_A, 0) 1244 }; 1245 1246 bpfjit_function_t code; 1247 uint8_t pkt[1]; /* the program doesn't read any data */ 1248 1249 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1250 1251 ATF_CHECK(bpf_validate(insns, insn_count)); 1252 1253 code = bpfjit_generate_code(insns, insn_count); 1254 ATF_REQUIRE(code != NULL); 1255 1256 ATF_CHECK(code(pkt, 1, 1) == 0u-777u); 1257 1258 bpfjit_free_code(code); 1259 } 1260 1261 ATF_TC(bpfjit_jmp_ja); 1262 ATF_TC_HEAD(bpfjit_jmp_ja, tc) 1263 { 1264 atf_tc_set_md_var(tc, "descr", 1265 "Test JIT compilation of BPF_JMP+BPF_JA"); 1266 } 1267 1268 ATF_TC_BODY(bpfjit_jmp_ja, tc) 1269 { 1270 static struct bpf_insn insns[] = { 1271 BPF_STMT(BPF_JMP+BPF_JA, 1), 1272 BPF_STMT(BPF_RET+BPF_K, 0), 1273 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1274 BPF_STMT(BPF_RET+BPF_K, 1), 1275 BPF_STMT(BPF_RET+BPF_K, 2), 1276 BPF_STMT(BPF_RET+BPF_K, 3), 1277 }; 1278 1279 bpfjit_function_t code; 1280 uint8_t pkt[1]; /* the program doesn't read any data */ 1281 1282 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1283 1284 ATF_CHECK(bpf_validate(insns, insn_count)); 1285 1286 code = bpfjit_generate_code(insns, insn_count); 1287 ATF_REQUIRE(code != NULL); 1288 1289 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 1290 1291 bpfjit_free_code(code); 1292 } 1293 1294 ATF_TC(bpfjit_jmp_jgt_k); 1295 ATF_TC_HEAD(bpfjit_jmp_jgt_k, tc) 1296 { 1297 atf_tc_set_md_var(tc, "descr", 1298 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_K"); 1299 } 1300 1301 ATF_TC_BODY(bpfjit_jmp_jgt_k, tc) 1302 { 1303 static struct bpf_insn insns[] = { 1304 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1305 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 7, 0, 1), 1306 BPF_STMT(BPF_RET+BPF_K, 0), 1307 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 2, 2, 0), 1308 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 9, 0, 0), 1309 BPF_STMT(BPF_RET+BPF_K, 1), 1310 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 4, 1, 1), 1311 BPF_STMT(BPF_RET+BPF_K, 2), 1312 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 6, 2, 3), 1313 BPF_STMT(BPF_RET+BPF_K, 3), 1314 BPF_STMT(BPF_RET+BPF_K, 4), 1315 BPF_STMT(BPF_RET+BPF_K, 5), 1316 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 5, 3, 1), 1317 BPF_STMT(BPF_RET+BPF_K, 6), 1318 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, 0, 0, 0), 1319 BPF_STMT(BPF_RET+BPF_K, 7), 1320 BPF_STMT(BPF_RET+BPF_K, 8) 1321 }; 1322 1323 bpfjit_function_t code; 1324 uint8_t pkt[8]; /* the program doesn't read any data */ 1325 1326 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1327 1328 ATF_CHECK(bpf_validate(insns, insn_count)); 1329 1330 code = bpfjit_generate_code(insns, insn_count); 1331 ATF_REQUIRE(code != NULL); 1332 1333 ATF_CHECK(code(pkt, 1, 1) == 1); 1334 ATF_CHECK(code(pkt, 2, 2) == 1); 1335 ATF_CHECK(code(pkt, 3, 3) == 7); 1336 ATF_CHECK(code(pkt, 4, 4) == 7); 1337 ATF_CHECK(code(pkt, 5, 5) == 7); 1338 ATF_CHECK(code(pkt, 6, 6) == 8); 1339 ATF_CHECK(code(pkt, 7, 7) == 5); 1340 ATF_CHECK(code(pkt, 8, 8) == 0); 1341 1342 bpfjit_free_code(code); 1343 } 1344 1345 ATF_TC(bpfjit_jmp_jge_k); 1346 ATF_TC_HEAD(bpfjit_jmp_jge_k, tc) 1347 { 1348 atf_tc_set_md_var(tc, "descr", 1349 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_K"); 1350 } 1351 1352 ATF_TC_BODY(bpfjit_jmp_jge_k, tc) 1353 { 1354 static struct bpf_insn insns[] = { 1355 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1356 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 8, 0, 1), 1357 BPF_STMT(BPF_RET+BPF_K, 0), 1358 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 3, 2, 0), 1359 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 9, 0, 0), 1360 BPF_STMT(BPF_RET+BPF_K, 1), 1361 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 5, 1, 1), 1362 BPF_STMT(BPF_RET+BPF_K, 2), 1363 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 7, 2, 3), 1364 BPF_STMT(BPF_RET+BPF_K, 3), 1365 BPF_STMT(BPF_RET+BPF_K, 4), 1366 BPF_STMT(BPF_RET+BPF_K, 5), 1367 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 6, 3, 1), 1368 BPF_STMT(BPF_RET+BPF_K, 6), 1369 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 1, 0, 0), 1370 BPF_STMT(BPF_RET+BPF_K, 7), 1371 BPF_STMT(BPF_RET+BPF_K, 8) 1372 }; 1373 1374 bpfjit_function_t code; 1375 uint8_t pkt[8]; /* the program doesn't read any data */ 1376 1377 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1378 1379 ATF_CHECK(bpf_validate(insns, insn_count)); 1380 1381 code = bpfjit_generate_code(insns, insn_count); 1382 ATF_REQUIRE(code != NULL); 1383 1384 ATF_CHECK(code(pkt, 1, 1) == 1); 1385 ATF_CHECK(code(pkt, 2, 2) == 1); 1386 ATF_CHECK(code(pkt, 3, 3) == 7); 1387 ATF_CHECK(code(pkt, 4, 4) == 7); 1388 ATF_CHECK(code(pkt, 5, 5) == 7); 1389 ATF_CHECK(code(pkt, 6, 6) == 8); 1390 ATF_CHECK(code(pkt, 7, 7) == 5); 1391 ATF_CHECK(code(pkt, 8, 8) == 0); 1392 1393 bpfjit_free_code(code); 1394 } 1395 1396 ATF_TC(bpfjit_jmp_jeq_k); 1397 ATF_TC_HEAD(bpfjit_jmp_jeq_k, tc) 1398 { 1399 atf_tc_set_md_var(tc, "descr", 1400 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_K"); 1401 } 1402 1403 ATF_TC_BODY(bpfjit_jmp_jeq_k, tc) 1404 { 1405 static struct bpf_insn insns[] = { 1406 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1407 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 8, 0, 1), 1408 BPF_STMT(BPF_RET+BPF_K, 0), 1409 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 3, 1, 0), 1410 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 9, 1, 1), 1411 BPF_STMT(BPF_RET+BPF_K, 1), 1412 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 5, 1, 1), 1413 BPF_STMT(BPF_RET+BPF_K, 2), 1414 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 7, 2, 3), 1415 BPF_STMT(BPF_RET+BPF_K, 3), 1416 BPF_STMT(BPF_RET+BPF_K, 4), 1417 BPF_STMT(BPF_RET+BPF_K, 5), 1418 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 6, 3, 1), 1419 BPF_STMT(BPF_RET+BPF_K, 6), 1420 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 1, 0, 0), 1421 BPF_STMT(BPF_RET+BPF_K, 7), 1422 BPF_STMT(BPF_RET+BPF_K, 8) 1423 }; 1424 1425 bpfjit_function_t code; 1426 uint8_t pkt[8]; /* the program doesn't read any data */ 1427 1428 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1429 1430 ATF_CHECK(bpf_validate(insns, insn_count)); 1431 1432 code = bpfjit_generate_code(insns, insn_count); 1433 ATF_REQUIRE(code != NULL); 1434 1435 ATF_CHECK(code(pkt, 1, 1) == 7); 1436 ATF_CHECK(code(pkt, 2, 2) == 7); 1437 ATF_CHECK(code(pkt, 3, 3) == 1); 1438 ATF_CHECK(code(pkt, 4, 4) == 7); 1439 ATF_CHECK(code(pkt, 5, 5) == 7); 1440 ATF_CHECK(code(pkt, 6, 6) == 8); 1441 ATF_CHECK(code(pkt, 7, 7) == 5); 1442 ATF_CHECK(code(pkt, 8, 8) == 0); 1443 1444 bpfjit_free_code(code); 1445 } 1446 1447 ATF_TC(bpfjit_jmp_jset_k); 1448 ATF_TC_HEAD(bpfjit_jmp_jset_k, tc) 1449 { 1450 atf_tc_set_md_var(tc, "descr", 1451 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_K"); 1452 } 1453 1454 ATF_TC_BODY(bpfjit_jmp_jset_k, tc) 1455 { 1456 static struct bpf_insn insns[] = { 1457 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1458 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 8, 0, 1), 1459 BPF_STMT(BPF_RET+BPF_K, 0), 1460 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 4, 2, 0), 1461 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 3, 0, 0), 1462 BPF_STMT(BPF_RET+BPF_K, 1), 1463 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 1, 1), 1464 BPF_STMT(BPF_RET+BPF_K, 2), 1465 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 1, 2, 3), 1466 BPF_STMT(BPF_RET+BPF_K, 3), 1467 BPF_STMT(BPF_RET+BPF_K, 4), 1468 BPF_STMT(BPF_RET+BPF_K, 5), 1469 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 2, 3, 1), 1470 BPF_STMT(BPF_RET+BPF_K, 6), 1471 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 7, 0, 0), 1472 BPF_STMT(BPF_RET+BPF_K, 7), 1473 BPF_STMT(BPF_RET+BPF_K, 8) 1474 }; 1475 1476 bpfjit_function_t code; 1477 uint8_t pkt[8]; /* the program doesn't read any data */ 1478 1479 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1480 1481 ATF_CHECK(bpf_validate(insns, insn_count)); 1482 1483 code = bpfjit_generate_code(insns, insn_count); 1484 ATF_REQUIRE(code != NULL); 1485 1486 ATF_CHECK(code(pkt, 1, 1) == 1); 1487 ATF_CHECK(code(pkt, 2, 2) == 1); 1488 ATF_CHECK(code(pkt, 3, 3) == 1); 1489 ATF_CHECK(code(pkt, 4, 4) == 7); 1490 ATF_CHECK(code(pkt, 5, 5) == 5); 1491 ATF_CHECK(code(pkt, 6, 6) == 8); 1492 ATF_CHECK(code(pkt, 7, 7) == 5); 1493 ATF_CHECK(code(pkt, 8, 8) == 0); 1494 1495 bpfjit_free_code(code); 1496 } 1497 1498 ATF_TC(bpfjit_jmp_modulo_k); 1499 ATF_TC_HEAD(bpfjit_jmp_modulo_k, tc) 1500 { 1501 atf_tc_set_md_var(tc, "descr", 1502 "Test JIT compilation of modulo logic of BPF_JMP+BPF_K operations"); 1503 } 1504 1505 ATF_TC_BODY(bpfjit_jmp_modulo_k, tc) 1506 { 1507 static struct bpf_insn insns[] = { 1508 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1509 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 1510 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 1, 0), 1511 BPF_STMT(BPF_RET+BPF_K, 0), 1512 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 0, 1), 1513 BPF_STMT(BPF_RET+BPF_K, 1), 1514 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 0, 1), 1515 BPF_STMT(BPF_RET+BPF_K, 2), 1516 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xfffff770), 0, 3), 1517 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xfffff770), 2, 0), 1518 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xfffff771), 1, 0), 1519 BPF_STMT(BPF_JMP+BPF_JA, 1), 1520 BPF_STMT(BPF_RET+BPF_K, 3), 1521 1522 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 1523 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 1524 1525 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 1, 0), 1526 BPF_STMT(BPF_RET+BPF_K, 4), 1527 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 0, 1), 1528 BPF_STMT(BPF_RET+BPF_K, 5), 1529 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 0, 1), 1530 BPF_STMT(BPF_RET+BPF_K, 6), 1531 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, UINT32_C(0xffffeee0), 0, 3), 1532 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, UINT32_C(0xffffeee0), 2, 0), 1533 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, UINT32_C(0xffffeee1), 1, 0), 1534 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1535 BPF_STMT(BPF_RET+BPF_K, 7) 1536 }; 1537 1538 bpfjit_function_t code; 1539 uint8_t pkt[1]; /* the program doesn't read any data */ 1540 1541 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1542 1543 ATF_CHECK(bpf_validate(insns, insn_count)); 1544 1545 code = bpfjit_generate_code(insns, insn_count); 1546 ATF_REQUIRE(code != NULL); 1547 1548 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 1549 1550 bpfjit_free_code(code); 1551 } 1552 1553 ATF_TC(bpfjit_jmp_jgt_x); 1554 ATF_TC_HEAD(bpfjit_jmp_jgt_x, tc) 1555 { 1556 atf_tc_set_md_var(tc, "descr", 1557 "Test JIT compilation of BPF_JMP+BPF_JGT+BPF_X"); 1558 } 1559 1560 ATF_TC_BODY(bpfjit_jmp_jgt_x, tc) 1561 { 1562 static struct bpf_insn insns[] = { 1563 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1564 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1565 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1566 BPF_STMT(BPF_RET+BPF_K, 0), 1567 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1568 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1569 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1570 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 1571 BPF_STMT(BPF_RET+BPF_K, 1), 1572 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1573 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 1, 1), 1574 BPF_STMT(BPF_RET+BPF_K, 2), 1575 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1576 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 2, 3), 1577 BPF_STMT(BPF_RET+BPF_K, 3), 1578 BPF_STMT(BPF_RET+BPF_K, 4), 1579 BPF_STMT(BPF_RET+BPF_K, 5), 1580 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1581 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 4, 1), 1582 BPF_STMT(BPF_RET+BPF_K, 6), 1583 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 1584 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 0), 1585 BPF_STMT(BPF_RET+BPF_K, 7), 1586 BPF_STMT(BPF_RET+BPF_K, 8) 1587 }; 1588 1589 bpfjit_function_t code; 1590 uint8_t pkt[8]; /* the program doesn't read any data */ 1591 1592 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1593 1594 ATF_CHECK(bpf_validate(insns, insn_count)); 1595 1596 code = bpfjit_generate_code(insns, insn_count); 1597 ATF_REQUIRE(code != NULL); 1598 1599 ATF_CHECK(code(pkt, 1, 1) == 1); 1600 ATF_CHECK(code(pkt, 2, 2) == 1); 1601 ATF_CHECK(code(pkt, 3, 3) == 7); 1602 ATF_CHECK(code(pkt, 4, 4) == 7); 1603 ATF_CHECK(code(pkt, 5, 5) == 7); 1604 ATF_CHECK(code(pkt, 6, 6) == 8); 1605 ATF_CHECK(code(pkt, 7, 7) == 5); 1606 ATF_CHECK(code(pkt, 8, 8) == 0); 1607 1608 bpfjit_free_code(code); 1609 } 1610 1611 ATF_TC(bpfjit_jmp_jge_x); 1612 ATF_TC_HEAD(bpfjit_jmp_jge_x, tc) 1613 { 1614 atf_tc_set_md_var(tc, "descr", 1615 "Test JIT compilation of BPF_JMP+BPF_JGE+BPF_X"); 1616 } 1617 1618 ATF_TC_BODY(bpfjit_jmp_jge_x, tc) 1619 { 1620 static struct bpf_insn insns[] = { 1621 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1622 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1623 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1624 BPF_STMT(BPF_RET+BPF_K, 0), 1625 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 1626 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 3, 0), 1627 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1628 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 1629 BPF_STMT(BPF_RET+BPF_K, 1), 1630 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1631 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 1), 1632 BPF_STMT(BPF_RET+BPF_K, 2), 1633 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1634 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 2, 3), 1635 BPF_STMT(BPF_RET+BPF_K, 3), 1636 BPF_STMT(BPF_RET+BPF_K, 4), 1637 BPF_STMT(BPF_RET+BPF_K, 5), 1638 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1639 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 4, 1), 1640 BPF_STMT(BPF_RET+BPF_K, 6), 1641 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1642 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 0), 1643 BPF_STMT(BPF_RET+BPF_K, 7), 1644 BPF_STMT(BPF_RET+BPF_K, 8) 1645 }; 1646 1647 bpfjit_function_t code; 1648 uint8_t pkt[8]; /* the program doesn't read any data */ 1649 1650 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1651 1652 ATF_CHECK(bpf_validate(insns, insn_count)); 1653 1654 code = bpfjit_generate_code(insns, insn_count); 1655 ATF_REQUIRE(code != NULL); 1656 1657 ATF_CHECK(code(pkt, 1, 1) == 1); 1658 ATF_CHECK(code(pkt, 2, 2) == 1); 1659 ATF_CHECK(code(pkt, 3, 3) == 7); 1660 ATF_CHECK(code(pkt, 4, 4) == 7); 1661 ATF_CHECK(code(pkt, 5, 5) == 7); 1662 ATF_CHECK(code(pkt, 6, 6) == 8); 1663 ATF_CHECK(code(pkt, 7, 7) == 5); 1664 ATF_CHECK(code(pkt, 8, 8) == 0); 1665 1666 bpfjit_free_code(code); 1667 } 1668 1669 ATF_TC(bpfjit_jmp_jeq_x); 1670 ATF_TC_HEAD(bpfjit_jmp_jeq_x, tc) 1671 { 1672 atf_tc_set_md_var(tc, "descr", 1673 "Test JIT compilation of BPF_JMP+BPF_JEQ+BPF_X"); 1674 } 1675 1676 ATF_TC_BODY(bpfjit_jmp_jeq_x, tc) 1677 { 1678 static struct bpf_insn insns[] = { 1679 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1680 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1681 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 1), 1682 BPF_STMT(BPF_RET+BPF_K, 0), 1683 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 1684 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 0), 1685 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 9), 1686 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 1687 BPF_STMT(BPF_RET+BPF_K, 1), 1688 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 1689 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 1), 1690 BPF_STMT(BPF_RET+BPF_K, 2), 1691 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1692 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 2, 3), 1693 BPF_STMT(BPF_RET+BPF_K, 3), 1694 BPF_STMT(BPF_RET+BPF_K, 4), 1695 BPF_STMT(BPF_RET+BPF_K, 5), 1696 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 6), 1697 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 3, 1), 1698 BPF_STMT(BPF_RET+BPF_K, 6), 1699 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 1, 0, 0), 1700 BPF_STMT(BPF_RET+BPF_K, 7), 1701 BPF_STMT(BPF_RET+BPF_K, 8) 1702 }; 1703 1704 bpfjit_function_t code; 1705 uint8_t pkt[8]; /* the program doesn't read any data */ 1706 1707 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1708 1709 ATF_CHECK(bpf_validate(insns, insn_count)); 1710 1711 code = bpfjit_generate_code(insns, insn_count); 1712 ATF_REQUIRE(code != NULL); 1713 1714 ATF_CHECK(code(pkt, 1, 1) == 7); 1715 ATF_CHECK(code(pkt, 2, 2) == 7); 1716 ATF_CHECK(code(pkt, 3, 3) == 1); 1717 ATF_CHECK(code(pkt, 4, 4) == 7); 1718 ATF_CHECK(code(pkt, 5, 5) == 7); 1719 ATF_CHECK(code(pkt, 6, 6) == 8); 1720 ATF_CHECK(code(pkt, 7, 7) == 5); 1721 ATF_CHECK(code(pkt, 8, 8) == 0); 1722 1723 bpfjit_free_code(code); 1724 } 1725 1726 ATF_TC(bpfjit_jmp_jset_x); 1727 ATF_TC_HEAD(bpfjit_jmp_jset_x, tc) 1728 { 1729 atf_tc_set_md_var(tc, "descr", 1730 "Test JIT compilation of BPF_JMP+BPF_JSET+BPF_X"); 1731 } 1732 1733 ATF_TC_BODY(bpfjit_jmp_jset_x, tc) 1734 { 1735 static struct bpf_insn insns[] = { 1736 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 1737 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 8), 1738 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 1), 1739 BPF_STMT(BPF_RET+BPF_K, 0), 1740 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 1741 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 0), 1742 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 3, 0, 0), 1743 BPF_STMT(BPF_RET+BPF_K, 1), 1744 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1745 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 1, 1), 1746 BPF_STMT(BPF_RET+BPF_K, 2), 1747 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 1748 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 2, 3), 1749 BPF_STMT(BPF_RET+BPF_K, 3), 1750 BPF_STMT(BPF_RET+BPF_K, 4), 1751 BPF_STMT(BPF_RET+BPF_K, 5), 1752 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), 1753 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 4, 1), 1754 BPF_STMT(BPF_RET+BPF_K, 6), 1755 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 7), 1756 BPF_JUMP(BPF_JMP+BPF_JSET+BPF_X, 0, 0, 0), 1757 BPF_STMT(BPF_RET+BPF_K, 7), 1758 BPF_STMT(BPF_RET+BPF_K, 8) 1759 }; 1760 1761 bpfjit_function_t code; 1762 uint8_t pkt[8]; /* the program doesn't read any data */ 1763 1764 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1765 1766 ATF_CHECK(bpf_validate(insns, insn_count)); 1767 1768 code = bpfjit_generate_code(insns, insn_count); 1769 ATF_REQUIRE(code != NULL); 1770 1771 ATF_CHECK(code(pkt, 1, 1) == 1); 1772 ATF_CHECK(code(pkt, 2, 2) == 1); 1773 ATF_CHECK(code(pkt, 3, 3) == 1); 1774 ATF_CHECK(code(pkt, 4, 4) == 7); 1775 ATF_CHECK(code(pkt, 5, 5) == 5); 1776 ATF_CHECK(code(pkt, 6, 6) == 8); 1777 ATF_CHECK(code(pkt, 7, 7) == 5); 1778 ATF_CHECK(code(pkt, 8, 8) == 0); 1779 1780 bpfjit_free_code(code); 1781 } 1782 1783 ATF_TC(bpfjit_jmp_modulo_x); 1784 ATF_TC_HEAD(bpfjit_jmp_modulo_x, tc) 1785 { 1786 atf_tc_set_md_var(tc, "descr", 1787 "Test JIT compilation of modulo logic of BPF_JMP+BPF_X operations"); 1788 } 1789 1790 ATF_TC_BODY(bpfjit_jmp_modulo_x, tc) 1791 { 1792 static struct bpf_insn insns[] = { 1793 BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)), 1794 /* FFFFF770 << 4 = FFFFF770 */ 1795 BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 4), 1796 1797 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 1798 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 1799 BPF_STMT(BPF_RET+BPF_K, 0), 1800 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1801 BPF_STMT(BPF_RET+BPF_K, 1), 1802 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 1803 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1804 BPF_STMT(BPF_RET+BPF_K, 2), 1805 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff770)), 1806 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 1807 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1808 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xfffff771)), 1809 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 1810 BPF_STMT(BPF_JMP+BPF_JA, 1), 1811 BPF_STMT(BPF_RET+BPF_K, 3), 1812 1813 /* FFFFF770+FFFFF770 = 00000001,FFFFEEE0 */ 1814 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xfffff770)), 1815 1816 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 1817 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 1818 BPF_STMT(BPF_RET+BPF_K, 4), 1819 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 0, 1), 1820 BPF_STMT(BPF_RET+BPF_K, 5), 1821 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 1822 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 0, 1), 1823 BPF_STMT(BPF_RET+BPF_K, 6), 1824 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee0)), 1825 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 0, 4), 1826 BPF_JUMP(BPF_JMP+BPF_JGT+BPF_X, 0, 3, 0), 1827 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0xffffeee1)), 1828 BPF_JUMP(BPF_JMP+BPF_JGE+BPF_X, 0, 1, 0), 1829 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 1830 BPF_STMT(BPF_RET+BPF_K, 7) 1831 }; 1832 1833 bpfjit_function_t code; 1834 uint8_t pkt[1]; /* the program doesn't read any data */ 1835 1836 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 1837 1838 ATF_CHECK(bpf_validate(insns, insn_count)); 1839 1840 code = bpfjit_generate_code(insns, insn_count); 1841 ATF_REQUIRE(code != NULL); 1842 1843 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 1844 1845 bpfjit_free_code(code); 1846 } 1847 1848 ATF_TC(bpfjit_ld_abs); 1849 ATF_TC_HEAD(bpfjit_ld_abs, tc) 1850 { 1851 atf_tc_set_md_var(tc, "descr", 1852 "Test JIT compilation of BPF_LD+BPF_ABS"); 1853 } 1854 1855 ATF_TC_BODY(bpfjit_ld_abs, tc) 1856 { 1857 static struct bpf_insn insns[3][2] = { 1858 { 1859 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 1860 BPF_STMT(BPF_RET+BPF_A, 0) 1861 }, 1862 { 1863 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 5), 1864 BPF_STMT(BPF_RET+BPF_A, 0) 1865 }, 1866 { 1867 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 5), 1868 BPF_STMT(BPF_RET+BPF_A, 0) 1869 } 1870 }; 1871 1872 static size_t lengths[3] = { 1, 2, 4 }; 1873 static unsigned int expected[3] = { 0xde, 0xdead, 0xdeadbeef }; 1874 1875 size_t i, l; 1876 uint8_t *pkt = deadbeef_at_5; 1877 size_t pktsize = sizeof(deadbeef_at_5); 1878 1879 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 1880 1881 for (i = 0; i < 3; i++) { 1882 bpfjit_function_t code; 1883 1884 ATF_CHECK(bpf_validate(insns[i], insn_count)); 1885 1886 code = bpfjit_generate_code(insns[i], insn_count); 1887 ATF_REQUIRE(code != NULL); 1888 1889 for (l = 0; l < 5 + lengths[i]; l++) { 1890 ATF_CHECK(code(pkt, l, l) == 0); 1891 ATF_CHECK(code(pkt, pktsize, l) == 0); 1892 } 1893 1894 l = 5 + lengths[i]; 1895 ATF_CHECK(code(pkt, l, l) == expected[i]); 1896 ATF_CHECK(code(pkt, pktsize, l) == expected[i]); 1897 1898 l = pktsize; 1899 ATF_CHECK(code(pkt, l, l) == expected[i]); 1900 1901 bpfjit_free_code(code); 1902 } 1903 } 1904 1905 ATF_TC(bpfjit_ld_abs_k_overflow); 1906 ATF_TC_HEAD(bpfjit_ld_abs_k_overflow, tc) 1907 { 1908 atf_tc_set_md_var(tc, "descr", 1909 "Test JIT compilation of BPF_LD+BPF_ABS with overflow in k+4"); 1910 } 1911 1912 ATF_TC_BODY(bpfjit_ld_abs_k_overflow, tc) 1913 { 1914 static struct bpf_insn insns[12][3] = { 1915 { 1916 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 1917 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1918 BPF_STMT(BPF_RET+BPF_K, 1) 1919 }, 1920 { 1921 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 1922 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1923 BPF_STMT(BPF_RET+BPF_K, 1) 1924 }, 1925 { 1926 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 1927 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1928 BPF_STMT(BPF_RET+BPF_K, 1) 1929 }, 1930 { 1931 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 1932 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1933 BPF_STMT(BPF_RET+BPF_K, 1) 1934 }, 1935 { 1936 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 1937 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1938 BPF_STMT(BPF_RET+BPF_K, 1) 1939 }, 1940 { 1941 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 1942 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1943 BPF_STMT(BPF_RET+BPF_K, 1) 1944 }, 1945 { 1946 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1947 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX), 1948 BPF_STMT(BPF_RET+BPF_K, 1) 1949 }, 1950 { 1951 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1952 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, UINT32_MAX - 1), 1953 BPF_STMT(BPF_RET+BPF_K, 1) 1954 }, 1955 { 1956 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1957 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX), 1958 BPF_STMT(BPF_RET+BPF_K, 1) 1959 }, 1960 { 1961 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1962 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 1), 1963 BPF_STMT(BPF_RET+BPF_K, 1) 1964 }, 1965 { 1966 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1967 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 2), 1968 BPF_STMT(BPF_RET+BPF_K, 1) 1969 }, 1970 { 1971 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 7), 1972 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, UINT32_MAX - 3), 1973 BPF_STMT(BPF_RET+BPF_K, 1) 1974 } 1975 }; 1976 1977 int i; 1978 uint8_t pkt[8] = { 0 }; 1979 1980 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 1981 1982 for (i = 0; i < 3; i++) { 1983 bpfjit_function_t code; 1984 1985 ATF_CHECK(bpf_validate(insns[i], insn_count)); 1986 1987 code = bpfjit_generate_code(insns[i], insn_count); 1988 ATF_REQUIRE(code != NULL); 1989 1990 ATF_CHECK(code(pkt, 8, 8) == 0); 1991 1992 bpfjit_free_code(code); 1993 } 1994 } 1995 1996 ATF_TC(bpfjit_ld_ind); 1997 ATF_TC_HEAD(bpfjit_ld_ind, tc) 1998 { 1999 atf_tc_set_md_var(tc, "descr", 2000 "Test JIT compilation of BPF_LD+BPF_IND"); 2001 } 2002 2003 ATF_TC_BODY(bpfjit_ld_ind, tc) 2004 { 2005 static struct bpf_insn insns[6][3] = { 2006 { 2007 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2008 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2009 BPF_STMT(BPF_RET+BPF_A, 0) 2010 }, 2011 { 2012 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2013 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), 2014 BPF_STMT(BPF_RET+BPF_A, 0) 2015 }, 2016 { 2017 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 2018 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2), 2019 BPF_STMT(BPF_RET+BPF_A, 0) 2020 }, 2021 { 2022 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2023 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2024 BPF_STMT(BPF_RET+BPF_A, 0) 2025 }, 2026 { 2027 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2028 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 2029 BPF_STMT(BPF_RET+BPF_A, 0) 2030 }, 2031 { 2032 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2033 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), 2034 BPF_STMT(BPF_RET+BPF_A, 0) 2035 } 2036 }; 2037 2038 static size_t lengths[6] = { 1, 2, 4, 1, 2, 4 }; 2039 2040 static unsigned int expected[6] = { 2041 0xde, 0xdead, 0xdeadbeef, 2042 0xde, 0xdead, 0xdeadbeef 2043 }; 2044 2045 size_t i, l; 2046 uint8_t *pkt = deadbeef_at_5; 2047 size_t pktsize = sizeof(deadbeef_at_5); 2048 2049 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2050 2051 for (i = 0; i < 3; i++) { 2052 bpfjit_function_t code; 2053 2054 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2055 2056 code = bpfjit_generate_code(insns[i], insn_count); 2057 ATF_REQUIRE(code != NULL); 2058 2059 for (l = 0; l < 5 + lengths[i]; l++) { 2060 ATF_CHECK(code(pkt, l, l) == 0); 2061 ATF_CHECK(code(pkt, pktsize, l) == 0); 2062 } 2063 2064 l = 5 + lengths[i]; 2065 ATF_CHECK(code(pkt, l, l) == expected[i]); 2066 ATF_CHECK(code(pkt, pktsize, l) == expected[i]); 2067 2068 l = pktsize; 2069 ATF_CHECK(code(pkt, l, l) == expected[i]); 2070 2071 bpfjit_free_code(code); 2072 } 2073 } 2074 2075 ATF_TC(bpfjit_ld_ind_k_overflow); 2076 ATF_TC_HEAD(bpfjit_ld_ind_k_overflow, tc) 2077 { 2078 atf_tc_set_md_var(tc, "descr", 2079 "Test JIT compilation of BPF_LD+BPF_IND with overflow in k+4"); 2080 } 2081 2082 ATF_TC_BODY(bpfjit_ld_ind_k_overflow, tc) 2083 { 2084 static struct bpf_insn insns[12][3] = { 2085 { 2086 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2087 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2088 BPF_STMT(BPF_RET+BPF_K, 1) 2089 }, 2090 { 2091 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2092 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2093 BPF_STMT(BPF_RET+BPF_K, 1) 2094 }, 2095 { 2096 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2097 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2098 BPF_STMT(BPF_RET+BPF_K, 1) 2099 }, 2100 { 2101 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2102 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2103 BPF_STMT(BPF_RET+BPF_K, 1) 2104 }, 2105 { 2106 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2107 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2108 BPF_STMT(BPF_RET+BPF_K, 1) 2109 }, 2110 { 2111 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2112 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2113 BPF_STMT(BPF_RET+BPF_K, 1) 2114 }, 2115 { 2116 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2117 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX), 2118 BPF_STMT(BPF_RET+BPF_K, 1) 2119 }, 2120 { 2121 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2122 BPF_STMT(BPF_LD+BPF_H+BPF_IND, UINT32_MAX - 1), 2123 BPF_STMT(BPF_RET+BPF_K, 1) 2124 }, 2125 { 2126 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2127 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX), 2128 BPF_STMT(BPF_RET+BPF_K, 1) 2129 }, 2130 { 2131 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2132 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 1), 2133 BPF_STMT(BPF_RET+BPF_K, 1) 2134 }, 2135 { 2136 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2137 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 2), 2138 BPF_STMT(BPF_RET+BPF_K, 1) 2139 }, 2140 { 2141 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 7), 2142 BPF_STMT(BPF_LD+BPF_W+BPF_IND, UINT32_MAX - 3), 2143 BPF_STMT(BPF_RET+BPF_K, 1) 2144 } 2145 }; 2146 2147 int i; 2148 uint8_t pkt[8] = { 0 }; 2149 2150 size_t insn_count = sizeof(insns[0]) / sizeof(insns[0][0]); 2151 2152 for (i = 0; i < 3; i++) { 2153 bpfjit_function_t code; 2154 2155 ATF_CHECK(bpf_validate(insns[i], insn_count)); 2156 2157 code = bpfjit_generate_code(insns[i], insn_count); 2158 ATF_REQUIRE(code != NULL); 2159 2160 ATF_CHECK(code(pkt, 8, 8) == 0); 2161 2162 bpfjit_free_code(code); 2163 } 2164 } 2165 2166 ATF_TC(bpfjit_ld_ind_x_overflow1); 2167 ATF_TC_HEAD(bpfjit_ld_ind_x_overflow1, tc) 2168 { 2169 atf_tc_set_md_var(tc, "descr", 2170 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2171 } 2172 2173 ATF_TC_BODY(bpfjit_ld_ind_x_overflow1, tc) 2174 { 2175 static struct bpf_insn insns[] = { 2176 BPF_STMT(BPF_LD+BPF_LEN, 0), 2177 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2178 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2179 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2180 BPF_STMT(BPF_RET+BPF_A, 0) 2181 }; 2182 2183 size_t i; 2184 bpfjit_function_t code; 2185 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2186 2187 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2188 2189 ATF_CHECK(bpf_validate(insns, insn_count)); 2190 2191 code = bpfjit_generate_code(insns, insn_count); 2192 ATF_REQUIRE(code != NULL); 2193 2194 for (i = 1; i <= sizeof(pkt); i++) { 2195 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2196 ATF_CHECK(code(pkt, i, i) == 10 * i); 2197 } 2198 2199 bpfjit_free_code(code); 2200 } 2201 2202 ATF_TC(bpfjit_ld_ind_x_overflow2); 2203 ATF_TC_HEAD(bpfjit_ld_ind_x_overflow2, tc) 2204 { 2205 atf_tc_set_md_var(tc, "descr", 2206 "Test JIT compilation of BPF_LD+BPF_IND with overflow in X+4"); 2207 } 2208 2209 ATF_TC_BODY(bpfjit_ld_ind_x_overflow2, tc) 2210 { 2211 static struct bpf_insn insns[] = { 2212 BPF_STMT(BPF_LD+BPF_LEN, 0), 2213 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xffffffff)), 2214 BPF_STMT(BPF_ST, 3), 2215 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2216 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), 2217 BPF_STMT(BPF_RET+BPF_A, 0) 2218 }; 2219 2220 size_t i; 2221 bpfjit_function_t code; 2222 uint8_t pkt[8] = { 10, 20, 30, 40, 50, 60, 70, 80 }; 2223 2224 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2225 2226 ATF_CHECK(bpf_validate(insns, insn_count)); 2227 2228 code = bpfjit_generate_code(insns, insn_count); 2229 ATF_REQUIRE(code != NULL); 2230 2231 for (i = 1; i <= sizeof(pkt); i++) { 2232 ATF_CHECK(bpf_filter(insns, pkt, i, i) == 10 * i); 2233 ATF_CHECK(code(pkt, i, i) == 10 * i); 2234 } 2235 2236 bpfjit_free_code(code); 2237 } 2238 2239 ATF_TC(bpfjit_ld_len); 2240 ATF_TC_HEAD(bpfjit_ld_len, tc) 2241 { 2242 atf_tc_set_md_var(tc, "descr", 2243 "Test JIT compilation of BPF_LD+BPF_W+BPF_LEN"); 2244 } 2245 2246 ATF_TC_BODY(bpfjit_ld_len, tc) 2247 { 2248 static struct bpf_insn insns[] = { 2249 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2250 BPF_STMT(BPF_RET+BPF_A, 0) 2251 }; 2252 2253 size_t i; 2254 bpfjit_function_t code; 2255 uint8_t pkt[32]; /* the program doesn't read any data */ 2256 2257 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2258 2259 ATF_CHECK(bpf_validate(insns, insn_count)); 2260 2261 code = bpfjit_generate_code(insns, insn_count); 2262 ATF_REQUIRE(code != NULL); 2263 2264 for (i = 0; i < sizeof(pkt); i++) 2265 ATF_CHECK(code(pkt, i, 1) == i); 2266 2267 bpfjit_free_code(code); 2268 } 2269 2270 ATF_TC(bpfjit_ld_imm); 2271 ATF_TC_HEAD(bpfjit_ld_imm, tc) 2272 { 2273 atf_tc_set_md_var(tc, "descr", 2274 "Test JIT compilation of BPF_LD+BPF_IMM"); 2275 } 2276 2277 ATF_TC_BODY(bpfjit_ld_imm, tc) 2278 { 2279 static struct bpf_insn insns[] = { 2280 BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX), 2281 BPF_STMT(BPF_RET+BPF_A, 0) 2282 }; 2283 2284 bpfjit_function_t code; 2285 uint8_t pkt[1]; /* the program doesn't read any data */ 2286 2287 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2288 2289 ATF_CHECK(bpf_validate(insns, insn_count)); 2290 2291 code = bpfjit_generate_code(insns, insn_count); 2292 ATF_REQUIRE(code != NULL); 2293 2294 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 2295 2296 bpfjit_free_code(code); 2297 } 2298 2299 ATF_TC(bpfjit_ldx_imm1); 2300 ATF_TC_HEAD(bpfjit_ldx_imm1, tc) 2301 { 2302 atf_tc_set_md_var(tc, "descr", 2303 "Test JIT compilation of BPF_LDX+BPF_IMM"); 2304 } 2305 2306 ATF_TC_BODY(bpfjit_ldx_imm1, tc) 2307 { 2308 static struct bpf_insn insns[] = { 2309 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX - 5), 2310 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2311 BPF_STMT(BPF_RET+BPF_A, 0) 2312 }; 2313 2314 bpfjit_function_t code; 2315 uint8_t pkt[1]; /* the program doesn't read any data */ 2316 2317 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2318 2319 ATF_CHECK(bpf_validate(insns, insn_count)); 2320 2321 code = bpfjit_generate_code(insns, insn_count); 2322 ATF_REQUIRE(code != NULL); 2323 2324 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX - 5); 2325 2326 bpfjit_free_code(code); 2327 } 2328 2329 ATF_TC(bpfjit_ldx_imm2); 2330 ATF_TC_HEAD(bpfjit_ldx_imm2, tc) 2331 { 2332 atf_tc_set_md_var(tc, "descr", 2333 "Test JIT compilation of BPF_LDX+BPF_IMM"); 2334 } 2335 2336 ATF_TC_BODY(bpfjit_ldx_imm2, tc) 2337 { 2338 static struct bpf_insn insns[] = { 2339 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 5), 2340 BPF_STMT(BPF_LD+BPF_IMM, 5), 2341 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2342 BPF_STMT(BPF_RET+BPF_K, 7), 2343 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 2344 }; 2345 2346 bpfjit_function_t code; 2347 uint8_t pkt[1]; /* the program doesn't read any data */ 2348 2349 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2350 2351 ATF_CHECK(bpf_validate(insns, insn_count)); 2352 2353 code = bpfjit_generate_code(insns, insn_count); 2354 ATF_REQUIRE(code != NULL); 2355 2356 ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX); 2357 2358 bpfjit_free_code(code); 2359 } 2360 2361 ATF_TC(bpfjit_ldx_len1); 2362 ATF_TC_HEAD(bpfjit_ldx_len1, tc) 2363 { 2364 atf_tc_set_md_var(tc, "descr", 2365 "Test JIT compilation of BPF_LDX+BPF_LEN"); 2366 } 2367 2368 ATF_TC_BODY(bpfjit_ldx_len1, tc) 2369 { 2370 static struct bpf_insn insns[] = { 2371 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2372 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2373 BPF_STMT(BPF_RET+BPF_A, 0) 2374 }; 2375 2376 size_t i; 2377 bpfjit_function_t code; 2378 uint8_t pkt[5]; /* the program doesn't read any data */ 2379 2380 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2381 2382 ATF_CHECK(bpf_validate(insns, insn_count)); 2383 2384 code = bpfjit_generate_code(insns, insn_count); 2385 ATF_REQUIRE(code != NULL); 2386 2387 for (i = 1; i < sizeof(pkt); i++) { 2388 ATF_CHECK(code(pkt, i, 1) == i); 2389 ATF_CHECK(code(pkt, i + 1, i) == i + 1); 2390 } 2391 2392 bpfjit_free_code(code); 2393 } 2394 2395 ATF_TC(bpfjit_ldx_len2); 2396 ATF_TC_HEAD(bpfjit_ldx_len2, tc) 2397 { 2398 atf_tc_set_md_var(tc, "descr", 2399 "Test JIT compilation of BPF_LDX+BPF_LEN"); 2400 } 2401 2402 ATF_TC_BODY(bpfjit_ldx_len2, tc) 2403 { 2404 static struct bpf_insn insns[] = { 2405 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2406 BPF_STMT(BPF_LD+BPF_IMM, 5), 2407 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_X, 0, 1, 0), 2408 BPF_STMT(BPF_RET+BPF_K, 7), 2409 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX) 2410 }; 2411 2412 bpfjit_function_t code; 2413 uint8_t pkt[5]; /* the program doesn't read any data */ 2414 2415 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2416 2417 ATF_CHECK(bpf_validate(insns, insn_count)); 2418 2419 code = bpfjit_generate_code(insns, insn_count); 2420 ATF_REQUIRE(code != NULL); 2421 2422 ATF_CHECK(code(pkt, 5, 1) == UINT32_MAX); 2423 ATF_CHECK(code(pkt, 6, 5) == 7); 2424 2425 bpfjit_free_code(code); 2426 } 2427 2428 ATF_TC(bpfjit_ldx_msh); 2429 ATF_TC_HEAD(bpfjit_ldx_msh, tc) 2430 { 2431 atf_tc_set_md_var(tc, "descr", 2432 "Test JIT compilation of BPF_LDX+BPF_MSH"); 2433 } 2434 2435 ATF_TC_BODY(bpfjit_ldx_msh, tc) 2436 { 2437 static struct bpf_insn insns[] = { 2438 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), 2439 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2440 BPF_STMT(BPF_RET+BPF_A, 0) 2441 }; 2442 2443 bpfjit_function_t code; 2444 uint8_t pkt[2] = { 0, 0x7a }; 2445 2446 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2447 2448 ATF_CHECK(bpf_validate(insns, insn_count)); 2449 2450 code = bpfjit_generate_code(insns, insn_count); 2451 ATF_REQUIRE(code != NULL); 2452 2453 ATF_CHECK(code(pkt, 2, 2) == 40); 2454 2455 bpfjit_free_code(code); 2456 } 2457 2458 ATF_TC(bpfjit_misc_tax); 2459 ATF_TC_HEAD(bpfjit_misc_tax, tc) 2460 { 2461 atf_tc_set_md_var(tc, "descr", 2462 "Test JIT compilation of BPF_MISC+BPF_TAX"); 2463 } 2464 2465 ATF_TC_BODY(bpfjit_misc_tax, tc) 2466 { 2467 static struct bpf_insn insns[] = { 2468 BPF_STMT(BPF_LD+BPF_IMM, 3), 2469 BPF_STMT(BPF_MISC+BPF_TAX, 0), 2470 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), 2471 BPF_STMT(BPF_RET+BPF_A, 0) 2472 }; 2473 2474 bpfjit_function_t code; 2475 uint8_t pkt[] = { 0, 11, 22, 33, 44, 55 }; 2476 2477 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2478 2479 ATF_CHECK(bpf_validate(insns, insn_count)); 2480 2481 code = bpfjit_generate_code(insns, insn_count); 2482 ATF_REQUIRE(code != NULL); 2483 2484 ATF_CHECK(code(pkt, sizeof(pkt), sizeof(pkt)) == 55); 2485 2486 bpfjit_free_code(code); 2487 } 2488 2489 ATF_TC(bpfjit_misc_txa); 2490 ATF_TC_HEAD(bpfjit_misc_txa, tc) 2491 { 2492 atf_tc_set_md_var(tc, "descr", 2493 "Test JIT compilation of BPF_MISC+BPF_TXA"); 2494 } 2495 2496 ATF_TC_BODY(bpfjit_misc_txa, tc) 2497 { 2498 static struct bpf_insn insns[] = { 2499 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 391), 2500 BPF_STMT(BPF_MISC+BPF_TXA, 0), 2501 BPF_STMT(BPF_RET+BPF_A, 0) 2502 }; 2503 2504 bpfjit_function_t code; 2505 uint8_t pkt[1]; /* the program doesn't read any data */ 2506 2507 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2508 2509 ATF_CHECK(bpf_validate(insns, insn_count)); 2510 2511 code = bpfjit_generate_code(insns, insn_count); 2512 ATF_REQUIRE(code != NULL); 2513 2514 ATF_CHECK(code(pkt, 1, 1) == 391); 2515 2516 bpfjit_free_code(code); 2517 } 2518 2519 ATF_TC(bpfjit_st1); 2520 ATF_TC_HEAD(bpfjit_st1, tc) 2521 { 2522 atf_tc_set_md_var(tc, "descr", 2523 "Test JIT compilation of BPF_ST"); 2524 } 2525 2526 ATF_TC_BODY(bpfjit_st1, tc) 2527 { 2528 static struct bpf_insn insns[] = { 2529 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2530 BPF_STMT(BPF_ST, 0), 2531 BPF_STMT(BPF_LD+BPF_MEM, 0), 2532 BPF_STMT(BPF_RET+BPF_A, 0) 2533 }; 2534 2535 size_t i; 2536 bpfjit_function_t code; 2537 uint8_t pkt[16]; /* the program doesn't read any data */ 2538 2539 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2540 2541 ATF_CHECK(bpf_validate(insns, insn_count)); 2542 2543 code = bpfjit_generate_code(insns, insn_count); 2544 ATF_REQUIRE(code != NULL); 2545 2546 for (i = 1; i <= sizeof(pkt); i++) 2547 ATF_CHECK(code(pkt, i, sizeof(pkt)) == i); 2548 2549 bpfjit_free_code(code); 2550 } 2551 2552 ATF_TC(bpfjit_st2); 2553 ATF_TC_HEAD(bpfjit_st2, tc) 2554 { 2555 atf_tc_set_md_var(tc, "descr", 2556 "Test JIT compilation of BPF_ST"); 2557 } 2558 2559 ATF_TC_BODY(bpfjit_st2, tc) 2560 { 2561 static struct bpf_insn insns[] = { 2562 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2563 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2564 BPF_STMT(BPF_LD+BPF_MEM, 0), 2565 BPF_STMT(BPF_RET+BPF_A, 0) 2566 }; 2567 2568 bpfjit_function_t code; 2569 uint8_t pkt[1]; /* the program doesn't read any data */ 2570 2571 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2572 2573 ATF_CHECK(bpf_validate(insns, insn_count)); 2574 2575 code = bpfjit_generate_code(insns, insn_count); 2576 ATF_REQUIRE(code != NULL); 2577 2578 ATF_CHECK(code(pkt, 1, 1) == 0); 2579 2580 bpfjit_free_code(code); 2581 } 2582 2583 ATF_TC(bpfjit_st3); 2584 ATF_TC_HEAD(bpfjit_st3, tc) 2585 { 2586 atf_tc_set_md_var(tc, "descr", 2587 "Test JIT compilation of BPF_ST"); 2588 } 2589 2590 ATF_TC_BODY(bpfjit_st3, tc) 2591 { 2592 static struct bpf_insn insns[] = { 2593 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2594 BPF_STMT(BPF_ST, 0), 2595 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 2596 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2597 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 2598 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 2599 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 2600 BPF_STMT(BPF_RET+BPF_A, 0), 2601 BPF_STMT(BPF_LD+BPF_MEM, 0), 2602 BPF_STMT(BPF_RET+BPF_A, 0) 2603 }; 2604 2605 bpfjit_function_t code; 2606 uint8_t pkt[2]; /* the program doesn't read any data */ 2607 2608 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2609 2610 ATF_REQUIRE(BPF_MEMWORDS > 1); 2611 2612 ATF_CHECK(bpf_validate(insns, insn_count)); 2613 2614 code = bpfjit_generate_code(insns, insn_count); 2615 ATF_REQUIRE(code != NULL); 2616 2617 ATF_CHECK(code(pkt, 1, 1) == 1); 2618 ATF_CHECK(code(pkt, 2, 2) == 102); 2619 2620 bpfjit_free_code(code); 2621 } 2622 2623 ATF_TC(bpfjit_st4); 2624 ATF_TC_HEAD(bpfjit_st4, tc) 2625 { 2626 atf_tc_set_md_var(tc, "descr", 2627 "Test JIT compilation of BPF_ST"); 2628 } 2629 2630 ATF_TC_BODY(bpfjit_st4, tc) 2631 { 2632 static struct bpf_insn insns[] = { 2633 BPF_STMT(BPF_LD+BPF_W+BPF_LEN, 0), 2634 BPF_STMT(BPF_ST, 5), 2635 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 100), 2636 BPF_STMT(BPF_ST, BPF_MEMWORDS-1), 2637 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 200), 2638 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 301, 2, 0), 2639 BPF_STMT(BPF_LD+BPF_MEM, BPF_MEMWORDS-1), 2640 BPF_STMT(BPF_RET+BPF_A, 0), 2641 BPF_STMT(BPF_LD+BPF_MEM, 5), 2642 BPF_STMT(BPF_RET+BPF_A, 0) 2643 }; 2644 2645 bpfjit_function_t code; 2646 uint8_t pkt[2]; /* the program doesn't read any data */ 2647 2648 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2649 2650 ATF_REQUIRE(BPF_MEMWORDS > 6); 2651 2652 ATF_CHECK(bpf_validate(insns, insn_count)); 2653 2654 code = bpfjit_generate_code(insns, insn_count); 2655 ATF_REQUIRE(code != NULL); 2656 2657 ATF_CHECK(code(pkt, 1, 1) == 1); 2658 ATF_CHECK(code(pkt, 2, 2) == 102); 2659 2660 bpfjit_free_code(code); 2661 } 2662 2663 ATF_TC(bpfjit_st5); 2664 ATF_TC_HEAD(bpfjit_st5, tc) 2665 { 2666 atf_tc_set_md_var(tc, "descr", 2667 "Test JIT compilation of BPF_ST"); 2668 } 2669 2670 ATF_TC_BODY(bpfjit_st5, tc) 2671 { 2672 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 2673 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2674 2675 size_t k; 2676 bpfjit_function_t code; 2677 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 2678 2679 memset(insns, 0, sizeof(insns)); 2680 2681 /* for each k do M[k] = k */ 2682 for (k = 0; k < BPF_MEMWORDS; k++) { 2683 insns[2*k].code = BPF_LD+BPF_IMM; 2684 insns[2*k].k = 3*k; 2685 insns[2*k+1].code = BPF_ST; 2686 insns[2*k+1].k = k; 2687 } 2688 2689 /* load wirelen into A */ 2690 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 2691 2692 /* for each k, if (A == k + 1) return M[k] */ 2693 for (k = 0; k < BPF_MEMWORDS; k++) { 2694 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 2695 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 2696 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 2697 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 2698 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 2699 insns[2*BPF_MEMWORDS+3*k+2].k = k; 2700 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 2701 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 2702 } 2703 2704 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 2705 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 2706 2707 ATF_CHECK(bpf_validate(insns, insn_count)); 2708 2709 code = bpfjit_generate_code(insns, insn_count); 2710 ATF_REQUIRE(code != NULL); 2711 2712 for (k = 1; k <= sizeof(pkt); k++) 2713 ATF_CHECK(code(pkt, k, k) == 3*(k-1)); 2714 2715 bpfjit_free_code(code); 2716 } 2717 2718 ATF_TC(bpfjit_stx1); 2719 ATF_TC_HEAD(bpfjit_stx1, tc) 2720 { 2721 atf_tc_set_md_var(tc, "descr", 2722 "Test JIT compilation of BPF_STX"); 2723 } 2724 2725 ATF_TC_BODY(bpfjit_stx1, tc) 2726 { 2727 static struct bpf_insn insns[] = { 2728 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2729 BPF_STMT(BPF_STX, 0), 2730 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 2731 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2732 BPF_STMT(BPF_RET+BPF_A, 0) 2733 }; 2734 2735 size_t i; 2736 bpfjit_function_t code; 2737 uint8_t pkt[16]; /* the program doesn't read any data */ 2738 2739 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2740 2741 ATF_CHECK(bpf_validate(insns, insn_count)); 2742 2743 code = bpfjit_generate_code(insns, insn_count); 2744 ATF_REQUIRE(code != NULL); 2745 2746 for (i = 1; i <= sizeof(pkt); i++) 2747 ATF_CHECK(code(pkt, i, sizeof(pkt)) == i); 2748 2749 bpfjit_free_code(code); 2750 } 2751 2752 ATF_TC(bpfjit_stx2); 2753 ATF_TC_HEAD(bpfjit_stx2, tc) 2754 { 2755 atf_tc_set_md_var(tc, "descr", 2756 "Test JIT compilation of BPF_STX"); 2757 } 2758 2759 ATF_TC_BODY(bpfjit_stx2, tc) 2760 { 2761 static struct bpf_insn insns[] = { 2762 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2763 BPF_STMT(BPF_STX, BPF_MEMWORDS-1), 2764 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), 2765 BPF_STMT(BPF_MISC+BPF_TXA, 0), 2766 BPF_STMT(BPF_RET+BPF_A, 0) 2767 }; 2768 2769 bpfjit_function_t code; 2770 uint8_t pkt[1]; /* the program doesn't read any data */ 2771 2772 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2773 2774 ATF_CHECK(bpf_validate(insns, insn_count)); 2775 2776 code = bpfjit_generate_code(insns, insn_count); 2777 ATF_REQUIRE(code != NULL); 2778 2779 ATF_CHECK(code(pkt, 1, 1) == 0); 2780 2781 bpfjit_free_code(code); 2782 } 2783 2784 ATF_TC(bpfjit_stx3); 2785 ATF_TC_HEAD(bpfjit_stx3, tc) 2786 { 2787 atf_tc_set_md_var(tc, "descr", 2788 "Test JIT compilation of BPF_STX"); 2789 } 2790 2791 ATF_TC_BODY(bpfjit_stx3, tc) 2792 { 2793 static struct bpf_insn insns[] = { 2794 BPF_STMT(BPF_LDX+BPF_W+BPF_LEN, 0), 2795 BPF_STMT(BPF_STX, 5), 2796 BPF_STMT(BPF_STX, 2), 2797 BPF_STMT(BPF_STX, 3), 2798 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 1), 2799 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2800 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 2), 2801 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2802 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 3), 2803 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2804 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 5), 2805 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2806 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 6), 2807 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 2808 BPF_STMT(BPF_RET+BPF_A, 0) 2809 }; 2810 2811 size_t i; 2812 bpfjit_function_t code; 2813 uint8_t pkt[16]; /* the program doesn't read any data */ 2814 2815 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2816 2817 ATF_CHECK(bpf_validate(insns, insn_count)); 2818 2819 code = bpfjit_generate_code(insns, insn_count); 2820 ATF_REQUIRE(code != NULL); 2821 2822 for (i = 1; i <= sizeof(pkt); i++) 2823 ATF_CHECK(code(pkt, i, sizeof(pkt)) == 3 * i); 2824 2825 bpfjit_free_code(code); 2826 } 2827 2828 ATF_TC(bpfjit_stx4); 2829 ATF_TC_HEAD(bpfjit_stx4, tc) 2830 { 2831 atf_tc_set_md_var(tc, "descr", 2832 "Test JIT compilation of BPF_STX"); 2833 } 2834 2835 ATF_TC_BODY(bpfjit_stx4, tc) 2836 { 2837 struct bpf_insn insns[5*BPF_MEMWORDS+2]; 2838 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2839 2840 size_t k; 2841 bpfjit_function_t code; 2842 uint8_t pkt[BPF_MEMWORDS]; /* the program doesn't read any data */ 2843 2844 memset(insns, 0, sizeof(insns)); 2845 2846 /* for each k do M[k] = k */ 2847 for (k = 0; k < BPF_MEMWORDS; k++) { 2848 insns[2*k].code = BPF_LDX+BPF_W+BPF_IMM; 2849 insns[2*k].k = 3*k; 2850 insns[2*k+1].code = BPF_STX; 2851 insns[2*k+1].k = k; 2852 } 2853 2854 /* load wirelen into A */ 2855 insns[2*BPF_MEMWORDS].code = BPF_LD+BPF_W+BPF_LEN; 2856 2857 /* for each k, if (A == k + 1) return M[k] */ 2858 for (k = 0; k < BPF_MEMWORDS; k++) { 2859 insns[2*BPF_MEMWORDS+3*k+1].code = BPF_JMP+BPF_JEQ+BPF_K; 2860 insns[2*BPF_MEMWORDS+3*k+1].k = k+1; 2861 insns[2*BPF_MEMWORDS+3*k+1].jt = 0; 2862 insns[2*BPF_MEMWORDS+3*k+1].jf = 2; 2863 insns[2*BPF_MEMWORDS+3*k+2].code = BPF_LD+BPF_MEM; 2864 insns[2*BPF_MEMWORDS+3*k+2].k = k; 2865 insns[2*BPF_MEMWORDS+3*k+3].code = BPF_RET+BPF_A; 2866 insns[2*BPF_MEMWORDS+3*k+3].k = 0; 2867 } 2868 2869 insns[5*BPF_MEMWORDS+1].code = BPF_RET+BPF_K; 2870 insns[5*BPF_MEMWORDS+1].k = UINT32_MAX; 2871 2872 ATF_CHECK(bpf_validate(insns, insn_count)); 2873 2874 code = bpfjit_generate_code(insns, insn_count); 2875 ATF_REQUIRE(code != NULL); 2876 2877 for (k = 1; k <= sizeof(pkt); k++) 2878 ATF_CHECK(code(pkt, k, k) == 3*(k-1)); 2879 2880 bpfjit_free_code(code); 2881 } 2882 2883 ATF_TC(bpfjit_opt_ld_abs_1); 2884 ATF_TC_HEAD(bpfjit_opt_ld_abs_1, tc) 2885 { 2886 atf_tc_set_md_var(tc, "descr", 2887 "Test JIT compilation with length optimization " 2888 "applied to BPF_LD+BPF_ABS"); 2889 } 2890 2891 ATF_TC_BODY(bpfjit_opt_ld_abs_1, tc) 2892 { 2893 static struct bpf_insn insns[] = { 2894 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 2895 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 2896 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 2897 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 2898 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2899 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 2900 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 2901 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2902 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 2903 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2904 BPF_STMT(BPF_RET+BPF_K, 0), 2905 }; 2906 2907 size_t i, j; 2908 bpfjit_function_t code; 2909 uint8_t pkt[2][34] = { 2910 { 2911 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2912 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2913 0x80, 0x03, 0x70, 0x0f, 2914 0x80, 0x03, 0x70, 0x23 2915 }, 2916 { 2917 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2918 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2919 0x80, 0x03, 0x70, 0x23, 2920 0x80, 0x03, 0x70, 0x0f 2921 } 2922 }; 2923 2924 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2925 2926 ATF_CHECK(bpf_validate(insns, insn_count)); 2927 2928 code = bpfjit_generate_code(insns, insn_count); 2929 ATF_REQUIRE(code != NULL); 2930 2931 for (i = 0; i < 2; i++) { 2932 for (j = 1; j < sizeof(pkt[i]); j++) 2933 ATF_CHECK(code(pkt[i], j, j) == 0); 2934 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 2935 } 2936 2937 bpfjit_free_code(code); 2938 } 2939 2940 ATF_TC(bpfjit_opt_ld_abs_2); 2941 ATF_TC_HEAD(bpfjit_opt_ld_abs_2, tc) 2942 { 2943 atf_tc_set_md_var(tc, "descr", 2944 "Test JIT compilation with length optimization " 2945 "applied to BPF_LD+BPF_ABS"); 2946 } 2947 2948 ATF_TC_BODY(bpfjit_opt_ld_abs_2, tc) 2949 { 2950 static struct bpf_insn insns[] = { 2951 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 2952 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 2953 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2954 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 2955 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 2956 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 2957 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 2958 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 2959 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 2960 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 2961 BPF_STMT(BPF_RET+BPF_K, 0), 2962 }; 2963 2964 size_t i, j; 2965 bpfjit_function_t code; 2966 uint8_t pkt[2][34] = { 2967 { 2968 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2969 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2970 0x80, 0x03, 0x70, 0x0f, 2971 0x80, 0x03, 0x70, 0x23 2972 }, 2973 { 2974 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 2975 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2976 0x80, 0x03, 0x70, 0x23, 2977 0x80, 0x03, 0x70, 0x0f 2978 } 2979 }; 2980 2981 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 2982 2983 ATF_CHECK(bpf_validate(insns, insn_count)); 2984 2985 code = bpfjit_generate_code(insns, insn_count); 2986 ATF_REQUIRE(code != NULL); 2987 2988 for (i = 0; i < 2; i++) { 2989 for (j = 1; j < sizeof(pkt[i]); j++) 2990 ATF_CHECK(code(pkt[i], j, j) == 0); 2991 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 2992 } 2993 2994 bpfjit_free_code(code); 2995 } 2996 2997 ATF_TC(bpfjit_opt_ld_abs_3); 2998 ATF_TC_HEAD(bpfjit_opt_ld_abs_3, tc) 2999 { 3000 atf_tc_set_md_var(tc, "descr", 3001 "Test JIT compilation with length optimization " 3002 "applied to BPF_LD+BPF_ABS"); 3003 } 3004 3005 ATF_TC_BODY(bpfjit_opt_ld_abs_3, tc) 3006 { 3007 static struct bpf_insn insns[] = { 3008 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 30), 3009 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3010 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3011 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 6), 3012 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 5), 3013 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 26), 3014 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3015 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), 3016 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3017 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3018 BPF_STMT(BPF_RET+BPF_K, 0), 3019 }; 3020 3021 size_t i, j; 3022 bpfjit_function_t code; 3023 uint8_t pkt[2][34] = { 3024 { 3025 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3026 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3027 0x80, 0x03, 0x70, 0x0f, 3028 0x80, 0x03, 0x70, 0x23 3029 }, 3030 { 3031 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3032 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3033 0x80, 0x03, 0x70, 0x23, 3034 0x80, 0x03, 0x70, 0x0f 3035 } 3036 }; 3037 3038 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3039 3040 ATF_CHECK(bpf_validate(insns, insn_count)); 3041 3042 code = bpfjit_generate_code(insns, insn_count); 3043 ATF_REQUIRE(code != NULL); 3044 3045 for (i = 0; i < 2; i++) { 3046 for (j = 1; j < sizeof(pkt[i]); j++) 3047 ATF_CHECK(code(pkt[i], j, j) == 0); 3048 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 3049 } 3050 3051 bpfjit_free_code(code); 3052 } 3053 3054 ATF_TC(bpfjit_opt_ld_ind_1); 3055 ATF_TC_HEAD(bpfjit_opt_ld_ind_1, tc) 3056 { 3057 atf_tc_set_md_var(tc, "descr", 3058 "Test JIT compilation with length optimization " 3059 "applied to BPF_LD+BPF_IND"); 3060 } 3061 3062 ATF_TC_BODY(bpfjit_opt_ld_ind_1, tc) 3063 { 3064 static struct bpf_insn insns[] = { 3065 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 12), 3066 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), 3067 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 8), 3068 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 14), 3069 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3070 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3071 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 4), 3072 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 3), 3073 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 18), 3074 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 1), 3075 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3076 BPF_STMT(BPF_RET+BPF_K, 0), 3077 }; 3078 3079 size_t i, j; 3080 bpfjit_function_t code; 3081 uint8_t pkt[2][34] = { 3082 { 3083 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3084 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3085 0x80, 0x03, 0x70, 0x0f, 3086 0x80, 0x03, 0x70, 0x23 3087 }, 3088 { 3089 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3090 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3091 0x80, 0x03, 0x70, 0x23, 3092 0x80, 0x03, 0x70, 0x0f 3093 } 3094 }; 3095 3096 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3097 3098 ATF_CHECK(bpf_validate(insns, insn_count)); 3099 3100 code = bpfjit_generate_code(insns, insn_count); 3101 ATF_REQUIRE(code != NULL); 3102 3103 for (i = 0; i < 2; i++) { 3104 for (j = 1; j < sizeof(pkt[i]); j++) 3105 ATF_CHECK(code(pkt[i], j, j) == 0); 3106 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 3107 } 3108 3109 bpfjit_free_code(code); 3110 } 3111 3112 ATF_TC(bpfjit_opt_ld_ind_2); 3113 ATF_TC_HEAD(bpfjit_opt_ld_ind_2, tc) 3114 { 3115 atf_tc_set_md_var(tc, "descr", 3116 "Test JIT compilation with length optimization " 3117 "applied to BPF_LD+BPF_IND"); 3118 } 3119 3120 ATF_TC_BODY(bpfjit_opt_ld_ind_2, tc) 3121 { 3122 static struct bpf_insn insns[] = { 3123 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3124 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 26), 3125 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 2), 3126 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3127 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 3, 6), 3128 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 5), 3129 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 30), 3130 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 3), 3131 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3132 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3133 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3134 BPF_STMT(BPF_RET+BPF_K, 0), 3135 }; 3136 3137 size_t i, j; 3138 bpfjit_function_t code; 3139 uint8_t pkt[2][34] = { 3140 { 3141 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3142 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3143 0x80, 0x03, 0x70, 0x0f, 3144 0x80, 0x03, 0x70, 0x23 3145 }, 3146 { 3147 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3148 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3149 0x80, 0x03, 0x70, 0x23, 3150 0x80, 0x03, 0x70, 0x0f 3151 } 3152 }; 3153 3154 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3155 3156 ATF_CHECK(bpf_validate(insns, insn_count)); 3157 3158 code = bpfjit_generate_code(insns, insn_count); 3159 ATF_REQUIRE(code != NULL); 3160 3161 for (i = 0; i < 2; i++) { 3162 for (j = 1; j < sizeof(pkt[i]); j++) 3163 ATF_CHECK(code(pkt[i], j, j) == 0); 3164 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 3165 } 3166 3167 bpfjit_free_code(code); 3168 } 3169 3170 ATF_TC(bpfjit_opt_ld_ind_3); 3171 ATF_TC_HEAD(bpfjit_opt_ld_ind_3, tc) 3172 { 3173 atf_tc_set_md_var(tc, "descr", 3174 "Test JIT compilation with length optimization " 3175 "applied to BPF_LD+BPF_IND"); 3176 } 3177 3178 ATF_TC_BODY(bpfjit_opt_ld_ind_3, tc) 3179 { 3180 static struct bpf_insn insns[] = { 3181 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 15), 3182 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3183 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3184 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3185 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3186 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3187 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 11), 3188 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3189 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3190 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3191 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3192 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3193 BPF_STMT(BPF_RET+BPF_K, 0), 3194 }; 3195 3196 size_t i, j; 3197 bpfjit_function_t code; 3198 uint8_t pkt[2][34] = { 3199 { 3200 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3201 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3202 0x80, 0x03, 0x70, 0x0f, 3203 0x80, 0x03, 0x70, 0x23 3204 }, 3205 { 3206 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3207 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3208 0x80, 0x03, 0x70, 0x23, 3209 0x80, 0x03, 0x70, 0x0f 3210 } 3211 }; 3212 3213 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3214 3215 ATF_CHECK(bpf_validate(insns, insn_count)); 3216 3217 code = bpfjit_generate_code(insns, insn_count); 3218 ATF_REQUIRE(code != NULL); 3219 3220 for (i = 0; i < 2; i++) { 3221 for (j = 1; j < sizeof(pkt[i]); j++) 3222 ATF_CHECK(code(pkt[i], j, j) == 0); 3223 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 3224 } 3225 3226 bpfjit_free_code(code); 3227 } 3228 3229 ATF_TC(bpfjit_opt_ld_ind_4); 3230 ATF_TC_HEAD(bpfjit_opt_ld_ind_4, tc) 3231 { 3232 atf_tc_set_md_var(tc, "descr", 3233 "Test JIT compilation with length optimization " 3234 "applied to BPF_LD+BPF_IND"); 3235 } 3236 3237 ATF_TC_BODY(bpfjit_opt_ld_ind_4, tc) 3238 { 3239 static struct bpf_insn insns[] = { 3240 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 11), 3241 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 19), 3242 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 2), 3243 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3244 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 3, 7), 3245 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x8003700f, 0, 6), 3246 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 15), 3247 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x80037023, 0, 4), 3248 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), 3249 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 12), 3250 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x800, 0, 1), 3251 BPF_STMT(BPF_RET+BPF_K, UINT32_MAX), 3252 BPF_STMT(BPF_RET+BPF_K, 0), 3253 }; 3254 3255 size_t i, j; 3256 bpfjit_function_t code; 3257 uint8_t pkt[2][34] = { 3258 { 3259 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3260 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3261 0x80, 0x03, 0x70, 0x0f, 3262 0x80, 0x03, 0x70, 0x23 3263 }, 3264 { 3265 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x08, 0x00, 3266 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3267 0x80, 0x03, 0x70, 0x23, 3268 0x80, 0x03, 0x70, 0x0f 3269 } 3270 }; 3271 3272 size_t insn_count = sizeof(insns) / sizeof(insns[0]); 3273 3274 ATF_CHECK(bpf_validate(insns, insn_count)); 3275 3276 code = bpfjit_generate_code(insns, insn_count); 3277 ATF_REQUIRE(code != NULL); 3278 3279 for (i = 0; i < 2; i++) { 3280 for (j = 1; j < sizeof(pkt[i]); j++) 3281 ATF_CHECK(code(pkt[i], j, j) == 0); 3282 ATF_CHECK(code(pkt[i], j, j) == UINT32_MAX); 3283 } 3284 3285 bpfjit_free_code(code); 3286 } 3287 3288 ATF_TP_ADD_TCS(tp) 3289 { 3290 3291 ATF_TP_ADD_TC(tp, bpfjit_empty); 3292 ATF_TP_ADD_TC(tp, bpfjit_alu_add_k); 3293 ATF_TP_ADD_TC(tp, bpfjit_alu_sub_k); 3294 ATF_TP_ADD_TC(tp, bpfjit_alu_mul_k); 3295 ATF_TP_ADD_TC(tp, bpfjit_alu_div0_k); 3296 ATF_TP_ADD_TC(tp, bpfjit_alu_div1_k); 3297 ATF_TP_ADD_TC(tp, bpfjit_alu_div2_k); 3298 ATF_TP_ADD_TC(tp, bpfjit_alu_div4_k); 3299 ATF_TP_ADD_TC(tp, bpfjit_alu_div10_k); 3300 ATF_TP_ADD_TC(tp, bpfjit_alu_div10000_k); 3301 ATF_TP_ADD_TC(tp, bpfjit_alu_div7609801_k); 3302 ATF_TP_ADD_TC(tp, bpfjit_alu_div80000000_k); 3303 ATF_TP_ADD_TC(tp, bpfjit_alu_and_k); 3304 ATF_TP_ADD_TC(tp, bpfjit_alu_or_k); 3305 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh_k); 3306 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh0_k); 3307 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh_k); 3308 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh0_k); 3309 ATF_TP_ADD_TC(tp, bpfjit_alu_modulo_k); 3310 ATF_TP_ADD_TC(tp, bpfjit_alu_add_x); 3311 ATF_TP_ADD_TC(tp, bpfjit_alu_sub_x); 3312 ATF_TP_ADD_TC(tp, bpfjit_alu_mul_x); 3313 ATF_TP_ADD_TC(tp, bpfjit_alu_div0_x); 3314 ATF_TP_ADD_TC(tp, bpfjit_alu_div1_x); 3315 ATF_TP_ADD_TC(tp, bpfjit_alu_div2_x); 3316 ATF_TP_ADD_TC(tp, bpfjit_alu_div4_x); 3317 ATF_TP_ADD_TC(tp, bpfjit_alu_div10_x); 3318 ATF_TP_ADD_TC(tp, bpfjit_alu_div10000_x); 3319 ATF_TP_ADD_TC(tp, bpfjit_alu_div7609801_x); 3320 ATF_TP_ADD_TC(tp, bpfjit_alu_div80000000_x); 3321 ATF_TP_ADD_TC(tp, bpfjit_alu_and_x); 3322 ATF_TP_ADD_TC(tp, bpfjit_alu_or_x); 3323 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh_x); 3324 ATF_TP_ADD_TC(tp, bpfjit_alu_lsh0_x); 3325 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh_x); 3326 ATF_TP_ADD_TC(tp, bpfjit_alu_rsh0_x); 3327 ATF_TP_ADD_TC(tp, bpfjit_alu_modulo_x); 3328 ATF_TP_ADD_TC(tp, bpfjit_alu_neg); 3329 ATF_TP_ADD_TC(tp, bpfjit_jmp_ja); 3330 ATF_TP_ADD_TC(tp, bpfjit_jmp_jgt_k); 3331 ATF_TP_ADD_TC(tp, bpfjit_jmp_jge_k); 3332 ATF_TP_ADD_TC(tp, bpfjit_jmp_jeq_k); 3333 ATF_TP_ADD_TC(tp, bpfjit_jmp_jset_k); 3334 ATF_TP_ADD_TC(tp, bpfjit_jmp_modulo_k); 3335 ATF_TP_ADD_TC(tp, bpfjit_jmp_jgt_x); 3336 ATF_TP_ADD_TC(tp, bpfjit_jmp_jge_x); 3337 ATF_TP_ADD_TC(tp, bpfjit_jmp_jeq_x); 3338 ATF_TP_ADD_TC(tp, bpfjit_jmp_jset_x); 3339 ATF_TP_ADD_TC(tp, bpfjit_jmp_modulo_x); 3340 ATF_TP_ADD_TC(tp, bpfjit_ld_abs); 3341 ATF_TP_ADD_TC(tp, bpfjit_ld_abs_k_overflow); 3342 ATF_TP_ADD_TC(tp, bpfjit_ld_ind); 3343 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_k_overflow); 3344 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_x_overflow1); 3345 ATF_TP_ADD_TC(tp, bpfjit_ld_ind_x_overflow2); 3346 ATF_TP_ADD_TC(tp, bpfjit_ld_len); 3347 ATF_TP_ADD_TC(tp, bpfjit_ld_imm); 3348 ATF_TP_ADD_TC(tp, bpfjit_ldx_imm1); 3349 ATF_TP_ADD_TC(tp, bpfjit_ldx_imm2); 3350 ATF_TP_ADD_TC(tp, bpfjit_ldx_len1); 3351 ATF_TP_ADD_TC(tp, bpfjit_ldx_len2); 3352 ATF_TP_ADD_TC(tp, bpfjit_ldx_msh); 3353 ATF_TP_ADD_TC(tp, bpfjit_misc_tax); 3354 ATF_TP_ADD_TC(tp, bpfjit_misc_txa); 3355 ATF_TP_ADD_TC(tp, bpfjit_st1); 3356 ATF_TP_ADD_TC(tp, bpfjit_st2); 3357 ATF_TP_ADD_TC(tp, bpfjit_st3); 3358 ATF_TP_ADD_TC(tp, bpfjit_st4); 3359 ATF_TP_ADD_TC(tp, bpfjit_st5); 3360 ATF_TP_ADD_TC(tp, bpfjit_stx1); 3361 ATF_TP_ADD_TC(tp, bpfjit_stx2); 3362 ATF_TP_ADD_TC(tp, bpfjit_stx3); 3363 ATF_TP_ADD_TC(tp, bpfjit_stx4); 3364 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_1); 3365 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_2); 3366 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_abs_3); 3367 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_1); 3368 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_2); 3369 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_3); 3370 ATF_TP_ADD_TC(tp, bpfjit_opt_ld_ind_4); 3371 /* XXX: bpfjit_opt_ldx_msh */ 3372 3373 return atf_no_error(); 3374 } 3375
Indexes created Tue Sep 23 07:09:52 GMT 2025