Source-Changes-HG archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
[src/trunk]: src/tests/net/bpfjit Move bpfjit mbuf tests to t_mbuf.c.
details: https://anonhg.NetBSD.org/src/rev/e940c0e64574
branches: trunk
changeset: 797202:e940c0e64574
user: alnsn <alnsn%NetBSD.org@localhost>
date: Tue Jul 08 21:45:55 2014 +0000
description:
Move bpfjit mbuf tests to t_mbuf.c.
diffstat:
tests/net/bpfjit/t_mbuf.c | 982 ++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 982 insertions(+), 0 deletions(-)
diffs (truncated from 986 to 300 lines):
diff -r 775ce69aa63c -r e940c0e64574 tests/net/bpfjit/t_mbuf.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/net/bpfjit/t_mbuf.c Tue Jul 08 21:45:55 2014 +0000
@@ -0,0 +1,982 @@
+/* $NetBSD: t_mbuf.c,v 1.1 2014/07/08 21:45:55 alnsn Exp $ */
+
+/*-
+ * Copyright (c) 2014 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 AUTHOR ``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 AUTHOR 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_mbuf.c,v 1.1 2014/07/08 21:45:55 alnsn Exp $");
+
+#include <sys/param.h>
+#include <sys/mbuf.h>
+
+#include <net/bpf.h>
+#include <net/bpfjit.h>
+
+#include <stdint.h>
+#include <string.h>
+
+#include <rump/rump.h>
+#include <rump/rump_syscalls.h>
+
+#include "../../net/bpf/h_bpf.h"
+
+/* XXX: atf-c.h has collisions with mbuf */
+#undef m_type
+#undef m_data
+#include <atf-c.h>
+
+#include "../../h_macros.h"
+
+static bool
+test_ldb_abs(size_t split)
+{
+ /* Return a product of all packet bytes. */
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 0), /* A <- P[0] */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 1), /* A <- P[1] */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 2), /* A <- P[2] */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* A <- P[3] */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), /* A <- P[4] */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 120;
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldh_abs(size_t split)
+{
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 0), /* A <- P[0:2] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 1), /* A <- P[1:2] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 2), /* A <- P[2:2] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 3), /* A <- P[3:2] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 0x0a0e; /* 10 14 */
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldw_abs(size_t split)
+{
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 0), /* A <- P[0:4] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
+
+ BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 1), /* A <- P[1:4] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 0x03050709;
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldb_ind(size_t split)
+{
+ /* Return a sum of all packet bytes. */
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), /* A <- P[0+X] */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), /* A <- P[2+X] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_B+BPF_IND, 3), /* A <- P[3+X] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 15;
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldw_ind(size_t split)
+{
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), /* X <- 0 */
+ BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1), /* A <- P[X+1:4] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 0x05080b0e;
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldh_ind(size_t split)
+{
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), /* A <- P[X+0:2] */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_ST, 0), /* M[0] <- A */
+
+ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
+ BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), /* A <- P[X+2:2] */
+ BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
+ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 0x0a0e; /* 10 14 */
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_msh(size_t split)
+{
+ /* Return a product of all packet bytes. */
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_IMM, 1), /* A <- 1 */
+
+ BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 0), /* X <- 4*(P[0]&0xf) */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
+
+ BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), /* X <- 4*(P[1]&0xf) */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
+
+ BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 2), /* X <- 4*(P[2]&0xf) */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
+
+ BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 3), /* X <- 4*(P[3]&0xf) */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
+
+ BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 4), /* X <- 4*(P[4]&0xf) */
+ BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
+ BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
+
+ BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
+ };
+
+ static unsigned char P[] = { 1, 2, 3, 4, 5 };
+ const unsigned int res = 120;
+ const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
+
+ if (!prog_validate(insns, insn_count))
+ return false;
+
+ return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
+}
+
+static bool
+test_ldb_abs_overflow(size_t split)
+{
+ static struct bpf_insn insns[] = {
+ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5),
Home |
Main Index |
Thread Index |
Old Index