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