8000 minix/tests/lib/libbpfjit/t_bpfjit.c at v3.3.0 · fyy3/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
3379 lines (2685 loc) · 83.7 KB

t_bpfjit.c

File metadata and controls

3379 lines (2685 loc) · 83.7 KB
/* $NetBSD: t_bpfjit.c,v 1.2 2013/11/15 00:12:45 rmind Exp $ */
/*-
* Copyright (c) 2011-2012 Alexander Nasonov.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: t_bpfjit.c,v 1.2 2013/11/15 00:12:45 rmind Exp $");
#include <atf-c.h>
#include <stdint.h>
#include <string.h>
#define __BPF_PRIVATE
#include <net/bpf.h>
#include <net/bpfjit.h>
static uint8_t deadbeef_at_5[16] = {
0, 0xf1, 2, 0xf3, 4, 0xde, 0xad, 0xbe, 0xef, 0xff
};
static bpf_ctx_t bc_zeroed;
static bpf_ctx_t *bc = &bc_zeroed;
ATF_TC(bpfjit_empty);
ATF_TC_HEAD(bpfjit_empty, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test that JIT compilation for an empty bpf program fails");
}
ATF_TC_BODY(bpfjit_empty, tc)
{
struct bpf_insn dummy;
ATF_CHECK(bpfjit_generate_code(bc, &dummy, 0) == NULL);
}
ATF_TC(bpfjit_alu_add_k);
ATF_TC_HEAD(bpfjit_alu_add_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_ADD+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_add_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 3),
BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 2),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 5);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_sub_k);
ATF_TC_HEAD(bpfjit_alu_sub_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_SUB+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_sub_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 1),
BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, 2),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_mul_k);
ATF_TC_HEAD(bpfjit_alu_mul_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_MUL+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_mul_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, 3),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0xfffffffd));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div0_k);
ATF_TC_HEAD(bpfjit_alu_div0_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0");
}
ATF_TC_BODY(bpfjit_alu_div0_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
//ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div1_k);
ATF_TC_HEAD(bpfjit_alu_div1_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=1");
}
ATF_TC_BODY(bpfjit_alu_div1_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 7),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 1),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 7);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div2_k);
ATF_TC_HEAD(bpfjit_alu_div2_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=2");
}
ATF_TC_BODY(bpfjit_alu_div2_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 7),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 2),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 3);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div4_k);
ATF_TC_HEAD(bpfjit_alu_div4_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=4");
}
ATF_TC_BODY(bpfjit_alu_div4_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x3fffffff));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div10_k);
ATF_TC_HEAD(bpfjit_alu_div10_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10");
}
ATF_TC_BODY(bpfjit_alu_div10_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484384));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div10000_k);
ATF_TC_HEAD(bpfjit_alu_div10000_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=10000");
}
ATF_TC_BODY(bpfjit_alu_div10000_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 10000),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div7609801_k);
ATF_TC_HEAD(bpfjit_alu_div7609801_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=7609801");
}
ATF_TC_BODY(bpfjit_alu_div7609801_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(7609801)),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 564);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div80000000_k);
ATF_TC_HEAD(bpfjit_alu_div80000000_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_K with k=0x80000000");
}
ATF_TC_BODY(bpfjit_alu_div80000000_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffde)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0x80000000)),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 1);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_and_k);
ATF_TC_HEAD(bpfjit_alu_and_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_AND+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_and_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdead),
BPF_STMT(BPF_ALU+BPF_AND+BPF_K, 0xbeef),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == (0xdead&0xbeef));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_or_k);
ATF_TC_HEAD(bpfjit_alu_or_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_OR+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_or_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdead0000),
BPF_STMT(BPF_ALU+BPF_OR+BPF_K, 0x0000beef),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_lsh_k);
ATF_TC_HEAD(bpfjit_alu_lsh_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_lsh_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 16),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0xbeef0000);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_lsh0_k);
ATF_TC_HEAD(bpfjit_alu_lsh0_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_LSH+BPF_K with k=0");
}
ATF_TC_BODY(bpfjit_alu_lsh0_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_rsh_k);
ATF_TC_HEAD(bpfjit_alu_rsh_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K");
}
ATF_TC_BODY(bpfjit_alu_rsh_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 16),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0x0000dead);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_rsh0_k);
ATF_TC_HEAD(bpfjit_alu_rsh0_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_RSH+BPF_K with k=0");
}
ATF_TC_BODY(bpfjit_alu_rsh0_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdeadbeef),
BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0xdeadbeef);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_modulo_k);
ATF_TC_HEAD(bpfjit_alu_modulo_k, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of modulo logic of BPF_ALU+BPF_K operations");
}
ATF_TC_BODY(bpfjit_alu_modulo_k, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0x7fffff77)),
/* (7FFFFF77 * 0FFFFF77) = 07FFFFB2,F0004951 */
BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x0fffff77)),
/* 07FFFFB2,F0004951 << 1 = 0FFFFF65,E00092A2 */
BPF_STMT(BPF_ALU+BPF_LSH+BPF_K, 1),
/* 0FFFFF65,E00092A2 + DDDDDDDD = 0FFFFF66,BDDE707F */
BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, UINT32_C(0xdddddddd)),
/* 0FFFFF66,BDDE707F - FFFFFFFF = 0FFFFF65,BDDE7080 */
BPF_STMT(BPF_ALU+BPF_SUB+BPF_K, UINT32_C(0xffffffff)),
/* 0FFFFF65,BDDE7080 | 0000030C = 0FFFFF65,BDDE738C */
BPF_STMT(BPF_ALU+BPF_OR+BPF_K, UINT32_C(0x0000030c)),
/* -0FFFFF65,BDDE738C mod(2^64) = F000009A,42218C74 */
BPF_STMT(BPF_ALU+BPF_NEG, 0),
/* F000009A,42218C74 & FFFFFF0F = F000009A,42218C04 */
BPF_STMT(BPF_ALU+BPF_AND+BPF_K, UINT32_C(0xffffff0f)),
/* F000009A,42218C74 >> 3 = 1E000013,48443180 */
/* 00000000,42218C74 >> 3 = 00000000,08443180 */
BPF_STMT(BPF_ALU+BPF_RSH+BPF_K, 3),
/* 00000000,08443180 * 7FFFFF77 = 042218BB,93818280 */
BPF_STMT(BPF_ALU+BPF_MUL+BPF_K, UINT32_C(0x7fffff77)),
/* 042218BB,93818280 / DEAD = 000004C0,71CBBBC3 */
/* 00000000,93818280 / DEAD = 00000000,0000A994 */
BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, UINT32_C(0xdead)),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) != UINT32_C(0x71cbbbc3));
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x0000a994));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_add_x);
ATF_TC_HEAD(bpfjit_alu_add_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_ADD+BPF_X");
}
ATF_TC_BODY(bpfjit_alu_add_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 3),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 5);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_sub_x);
ATF_TC_HEAD(bpfjit_alu_sub_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_SUB+BPF_X");
}
ATF_TC_BODY(bpfjit_alu_sub_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 1),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
BPF_STMT(BPF_ALU+BPF_SUB+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_MAX);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_mul_x);
ATF_TC_HEAD(bpfjit_alu_mul_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_MUL+BPF_X");
}
ATF_TC_BODY(bpfjit_alu_mul_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0xfffffffd));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div0_x);
ATF_TC_HEAD(bpfjit_alu_div0_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0");
}
ATF_TC_BODY(bpfjit_alu_div0_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 0);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div1_x);
ATF_TC_HEAD(bpfjit_alu_div1_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=1");
}
ATF_TC_BODY(bpfjit_alu_div1_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 7),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 7);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div2_x);
ATF_TC_HEAD(bpfjit_alu_div2_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=2");
}
ATF_TC_BODY(bpfjit_alu_div2_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 7),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 3);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div4_x);
ATF_TC_HEAD(bpfjit_alu_div4_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=4");
}
ATF_TC_BODY(bpfjit_alu_div4_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(0xffffffff)),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(0x3fffffff));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div10_x);
ATF_TC_HEAD(bpfjit_alu_div10_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10");
}
ATF_TC_BODY(bpfjit_alu_div10_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484384));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div10000_x);
ATF_TC_HEAD(bpfjit_alu_div10000_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=10000");
}
ATF_TC_BODY(bpfjit_alu_div10000_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294843849)),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 10000),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == UINT32_C(429484));
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div7609801_x);
ATF_TC_HEAD(bpfjit_alu_div7609801_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=7609801");
}
ATF_TC_BODY(bpfjit_alu_div7609801_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_C(4294967295)),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(7609801)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 564);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_div80000000_x);
ATF_TC_HEAD(bpfjit_alu_div80000000_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_DIV+BPF_X with X=0x80000000");
}
ATF_TC_BODY(bpfjit_alu_div80000000_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, UINT32_MAX - 33),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_C(0x80000000)),
BPF_STMT(BPF_ALU+BPF_DIV+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
ATF_REQUIRE(code != NULL);
ATF_CHECK(code(pkt, 1, 1) == 1);
bpfjit_free_code(code);
}
ATF_TC(bpfjit_alu_and_x);
ATF_TC_HEAD(bpfjit_alu_and_x, tc)
{
atf_tc_set_md_var(tc, "descr",
"Test JIT compilation of BPF_ALU+BPF_AND+BPF_X");
}
ATF_TC_BODY(bpfjit_alu_and_x, tc)
{
static struct bpf_insn insns[] = {
BPF_STMT(BPF_LD+BPF_IMM, 0xdead),
BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0xbeef),
BPF_STMT(BPF_ALU+BPF_AND+BPF_X, 0),
BPF_STMT(BPF_RET+BPF_A, 0)
};
bpfjit_func_t code;
uint8_t pkt[1]; /* the program doesn't read any data */
size_t insn_count = sizeof(insns) / sizeof(insns[0]);
ATF_CHECK(bpf_validate(insns, insn_count));
code = bpfjit_generate_code(bc, insns, insn_count);
0