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