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