1314818Sngie/* $NetBSD: t_mbuf.c,v 1.2 2017/01/13 21:30:42 christos Exp $ */ 2272343Sngie 3272343Sngie/*- 4272343Sngie * Copyright (c) 2014 Alexander Nasonov. 5272343Sngie * All rights reserved. 6272343Sngie * 7272343Sngie * Redistribution and use in source and binary forms, with or without 8272343Sngie * modification, are permitted provided that the following conditions 9272343Sngie * are met: 10272343Sngie * 1. Redistributions of source code must retain the above copyright 11272343Sngie * notice, this list of conditions and the following disclaimer. 12272343Sngie * 2. Redistributions in binary form must reproduce the above copyright 13272343Sngie * notice, this list of conditions and the following disclaimer in the 14272343Sngie * documentation and/or other materials provided with the distribution. 15272343Sngie * 16272343Sngie * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 17272343Sngie * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18272343Sngie * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19272343Sngie * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20272343Sngie * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21272343Sngie * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22272343Sngie * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23272343Sngie * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24272343Sngie * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25272343Sngie * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26272343Sngie * SUCH DAMAGE. 27272343Sngie */ 28272343Sngie 29272343Sngie#include <sys/cdefs.h> 30314818Sngie__RCSID("$NetBSD: t_mbuf.c,v 1.2 2017/01/13 21:30:42 christos Exp $"); 31272343Sngie 32272343Sngie#include <sys/param.h> 33272343Sngie#include <sys/mbuf.h> 34272343Sngie 35272343Sngie#include <net/bpf.h> 36272343Sngie#include <net/bpfjit.h> 37272343Sngie 38272343Sngie#include <stdint.h> 39272343Sngie#include <string.h> 40272343Sngie 41272343Sngie#include <rump/rump.h> 42272343Sngie#include <rump/rump_syscalls.h> 43272343Sngie 44272343Sngie#include "../../net/bpf/h_bpf.h" 45272343Sngie 46272343Sngie/* XXX: atf-c.h has collisions with mbuf */ 47272343Sngie#undef m_type 48272343Sngie#undef m_data 49272343Sngie#include <atf-c.h> 50272343Sngie 51314818Sngie#include "h_macros.h" 52272343Sngie 53272343Sngiestatic bool 54272343Sngietest_ldb_abs(size_t split) 55272343Sngie{ 56272343Sngie /* Return a product of all packet bytes. */ 57272343Sngie static struct bpf_insn insns[] = { 58272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 59272343Sngie 60272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 0), /* A <- P[0] */ 61272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 62272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 63272343Sngie 64272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 1), /* A <- P[1] */ 65272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 66272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 67272343Sngie 68272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 2), /* A <- P[2] */ 69272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 70272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 71272343Sngie 72272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* A <- P[3] */ 73272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 74272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 75272343Sngie 76272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), /* A <- P[4] */ 77272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 78272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 79272343Sngie }; 80272343Sngie 81272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 82272343Sngie const unsigned int res = 120; 83272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 84272343Sngie 85272343Sngie if (!prog_validate(insns, insn_count)) 86272343Sngie return false; 87272343Sngie 88272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 89272343Sngie} 90272343Sngie 91272343Sngiestatic bool 92272343Sngietest_ldh_abs(size_t split) 93272343Sngie{ 94272343Sngie static struct bpf_insn insns[] = { 95272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 0), /* A <- P[0:2] */ 96272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 97272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 98272343Sngie 99272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 1), /* A <- P[1:2] */ 100272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 101272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 102272343Sngie 103272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 2), /* A <- P[2:2] */ 104272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 105272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 106272343Sngie 107272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 3), /* A <- P[3:2] */ 108272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 109272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 110272343Sngie }; 111272343Sngie 112272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 113272343Sngie const unsigned int res = 0x0a0e; /* 10 14 */ 114272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 115272343Sngie 116272343Sngie if (!prog_validate(insns, insn_count)) 117272343Sngie return false; 118272343Sngie 119272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 120272343Sngie} 121272343Sngie 122272343Sngiestatic bool 123272343Sngietest_ldw_abs(size_t split) 124272343Sngie{ 125272343Sngie static struct bpf_insn insns[] = { 126272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 0), /* A <- P[0:4] */ 127272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 128272343Sngie BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */ 129272343Sngie 130272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 1), /* A <- P[1:4] */ 131272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 132272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 133272343Sngie }; 134272343Sngie 135272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 136272343Sngie const unsigned int res = 0x03050709; 137272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 138272343Sngie 139272343Sngie if (!prog_validate(insns, insn_count)) 140272343Sngie return false; 141272343Sngie 142272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 143272343Sngie} 144272343Sngie 145272343Sngiestatic bool 146272343Sngietest_ldb_ind(size_t split) 147272343Sngie{ 148272343Sngie /* Return a sum of all packet bytes. */ 149272343Sngie static struct bpf_insn insns[] = { 150272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), /* A <- P[0+X] */ 151272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 152272343Sngie 153272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */ 154272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 155272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 156272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 157272343Sngie 158272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 159272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */ 160272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 161272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 162272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 163272343Sngie 164272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 165272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), /* A <- P[2+X] */ 166272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 167272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 168272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 169272343Sngie 170272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 171272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 3), /* A <- P[3+X] */ 172272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 173272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 174272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 175272343Sngie }; 176272343Sngie 177272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 178272343Sngie const unsigned int res = 15; 179272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 180272343Sngie 181272343Sngie if (!prog_validate(insns, insn_count)) 182272343Sngie return false; 183272343Sngie 184272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 185272343Sngie} 186272343Sngie 187272343Sngiestatic bool 188272343Sngietest_ldw_ind(size_t split) 189272343Sngie{ 190272343Sngie static struct bpf_insn insns[] = { 191272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */ 192272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 193272343Sngie 194272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 195272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */ 196272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 197272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 198272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 199272343Sngie 200272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), /* X <- 0 */ 201272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1), /* A <- P[X+1:4] */ 202272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 203272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 204272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 205272343Sngie }; 206272343Sngie 207272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 208272343Sngie const unsigned int res = 0x05080b0e; 209272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 210272343Sngie 211272343Sngie if (!prog_validate(insns, insn_count)) 212272343Sngie return false; 213272343Sngie 214272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 215272343Sngie} 216272343Sngie 217272343Sngiestatic bool 218272343Sngietest_ldh_ind(size_t split) 219272343Sngie{ 220272343Sngie static struct bpf_insn insns[] = { 221272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), /* A <- P[X+0:2] */ 222272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 223272343Sngie 224272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */ 225272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 226272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 227272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 228272343Sngie 229272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 230272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */ 231272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 232272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 233272343Sngie BPF_STMT(BPF_ST, 0), /* M[0] <- A */ 234272343Sngie 235272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */ 236272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), /* A <- P[X+2:2] */ 237272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */ 238272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ 239272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 240272343Sngie }; 241272343Sngie 242272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 243272343Sngie const unsigned int res = 0x0a0e; /* 10 14 */ 244272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 245272343Sngie 246272343Sngie if (!prog_validate(insns, insn_count)) 247272343Sngie return false; 248272343Sngie 249272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 250272343Sngie} 251272343Sngie 252272343Sngiestatic bool 253272343Sngietest_msh(size_t split) 254272343Sngie{ 255272343Sngie /* Return a product of all packet bytes. */ 256272343Sngie static struct bpf_insn insns[] = { 257272343Sngie BPF_STMT(BPF_LD+BPF_IMM, 1), /* A <- 1 */ 258272343Sngie 259272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 0), /* X <- 4*(P[0]&0xf) */ 260272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 261272343Sngie BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */ 262272343Sngie 263272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), /* X <- 4*(P[1]&0xf) */ 264272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 265272343Sngie BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */ 266272343Sngie 267272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 2), /* X <- 4*(P[2]&0xf) */ 268272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 269272343Sngie BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */ 270272343Sngie 271272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 3), /* X <- 4*(P[3]&0xf) */ 272272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 273272343Sngie BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */ 274272343Sngie 275272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 4), /* X <- 4*(P[4]&0xf) */ 276272343Sngie BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */ 277272343Sngie BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */ 278272343Sngie 279272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */ 280272343Sngie }; 281272343Sngie 282272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 283272343Sngie const unsigned int res = 120; 284272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 285272343Sngie 286272343Sngie if (!prog_validate(insns, insn_count)) 287272343Sngie return false; 288272343Sngie 289272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res; 290272343Sngie} 291272343Sngie 292272343Sngiestatic bool 293272343Sngietest_ldb_abs_overflow(size_t split) 294272343Sngie{ 295272343Sngie static struct bpf_insn insns[] = { 296272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5), 297272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 298272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 299272343Sngie }; 300272343Sngie 301272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 302272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 303272343Sngie 304272343Sngie if (!prog_validate(insns, insn_count)) 305272343Sngie return false; 306272343Sngie 307272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 308272343Sngie} 309272343Sngie 310272343Sngiestatic bool 311272343Sngietest_ldh_abs_overflow(size_t split) 312272343Sngie{ 313272343Sngie static struct bpf_insn insns[] = { 314272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), 315272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 316272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 317272343Sngie }; 318272343Sngie 319272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 320272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 321272343Sngie 322272343Sngie if (!prog_validate(insns, insn_count)) 323272343Sngie return false; 324272343Sngie 325272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 326272343Sngie} 327272343Sngie 328272343Sngiestatic bool 329272343Sngietest_ldw_abs_overflow(size_t split) 330272343Sngie{ 331272343Sngie static struct bpf_insn insns[] = { 332272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2), 333272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 334272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 335272343Sngie }; 336272343Sngie 337272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 338272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 339272343Sngie 340272343Sngie if (!prog_validate(insns, insn_count)) 341272343Sngie return false; 342272343Sngie 343272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 344272343Sngie} 345272343Sngie 346272343Sngiestatic bool 347272343Sngietest_ldb_ind_overflow1(size_t split) 348272343Sngie{ 349272343Sngie static struct bpf_insn insns[] = { 350272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 5), 351272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 352272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 353272343Sngie }; 354272343Sngie 355272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 356272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 357272343Sngie 358272343Sngie if (!prog_validate(insns, insn_count)) 359272343Sngie return false; 360272343Sngie 361272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 362272343Sngie} 363272343Sngie 364272343Sngiestatic bool 365272343Sngietest_ldb_ind_overflow2(size_t split) 366272343Sngie{ 367272343Sngie static struct bpf_insn insns[] = { 368272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4), 369272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), 370272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 371272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 372272343Sngie }; 373272343Sngie 374272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 375272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 376272343Sngie 377272343Sngie if (!prog_validate(insns, insn_count)) 378272343Sngie return false; 379272343Sngie 380272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 381272343Sngie} 382272343Sngie 383272343Sngiestatic bool 384272343Sngietest_ldb_ind_overflow3(size_t split) 385272343Sngie{ 386272343Sngie static struct bpf_insn insns[] = { 387272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX), 388272343Sngie BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), 389272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 390272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 391272343Sngie }; 392272343Sngie 393272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 394272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 395272343Sngie 396272343Sngie if (!prog_validate(insns, insn_count)) 397272343Sngie return false; 398272343Sngie 399272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 400272343Sngie} 401272343Sngie 402272343Sngiestatic bool 403272343Sngietest_ldh_ind_overflow1(size_t split) 404272343Sngie{ 405272343Sngie static struct bpf_insn insns[] = { 406272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 4), 407272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 408272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 409272343Sngie }; 410272343Sngie 411272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 412272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 413272343Sngie 414272343Sngie if (!prog_validate(insns, insn_count)) 415272343Sngie return false; 416272343Sngie 417272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 418272343Sngie} 419272343Sngie 420272343Sngiestatic bool 421272343Sngietest_ldh_ind_overflow2(size_t split) 422272343Sngie{ 423272343Sngie static struct bpf_insn insns[] = { 424272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3), 425272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), 426272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 427272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 428272343Sngie }; 429272343Sngie 430272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 431272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 432272343Sngie 433272343Sngie if (!prog_validate(insns, insn_count)) 434272343Sngie return false; 435272343Sngie 436272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 437272343Sngie} 438272343Sngie 439272343Sngiestatic bool 440272343Sngietest_ldh_ind_overflow3(size_t split) 441272343Sngie{ 442272343Sngie static struct bpf_insn insns[] = { 443272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX), 444272343Sngie BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), 445272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 446272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 447272343Sngie }; 448272343Sngie 449272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 450272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 451272343Sngie 452272343Sngie if (!prog_validate(insns, insn_count)) 453272343Sngie return false; 454272343Sngie 455272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 456272343Sngie} 457272343Sngie 458272343Sngiestatic bool 459272343Sngietest_ldw_ind_overflow1(size_t split) 460272343Sngie{ 461272343Sngie static struct bpf_insn insns[] = { 462272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2), 463272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 464272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 465272343Sngie }; 466272343Sngie 467272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 468272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 469272343Sngie 470272343Sngie if (!prog_validate(insns, insn_count)) 471272343Sngie return false; 472272343Sngie 473272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 474272343Sngie} 475272343Sngie 476272343Sngiestatic bool 477272343Sngietest_ldw_ind_overflow2(size_t split) 478272343Sngie{ 479272343Sngie static struct bpf_insn insns[] = { 480272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), 481272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1), 482272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), 483272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 484272343Sngie }; 485272343Sngie 486272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 487272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 488272343Sngie 489272343Sngie if (!prog_validate(insns, insn_count)) 490272343Sngie return false; 491272343Sngie 492272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 493272343Sngie} 494272343Sngie 495272343Sngiestatic bool 496272343Sngietest_ldw_ind_overflow3(size_t split) 497272343Sngie{ 498272343Sngie static struct bpf_insn insns[] = { 499272343Sngie BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX), 500272343Sngie BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1), 501272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 502272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 503272343Sngie }; 504272343Sngie 505272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 506272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 507272343Sngie 508272343Sngie if (!prog_validate(insns, insn_count)) 509272343Sngie return false; 510272343Sngie 511272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 512272343Sngie} 513272343Sngie 514272343Sngiestatic bool 515272343Sngietest_msh_overflow(size_t split) 516272343Sngie{ 517272343Sngie static struct bpf_insn insns[] = { 518272343Sngie BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 5), 519272343Sngie BPF_STMT(BPF_MISC+BPF_TXA, 0), 520272343Sngie BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1), 521272343Sngie BPF_STMT(BPF_RET+BPF_A, 0), 522272343Sngie }; 523272343Sngie 524272343Sngie static unsigned char P[] = { 1, 2, 3, 4, 5 }; 525272343Sngie const size_t insn_count = sizeof(insns) / sizeof(insns[0]); 526272343Sngie 527272343Sngie if (!prog_validate(insns, insn_count)) 528272343Sngie return false; 529272343Sngie 530272343Sngie return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0; 531272343Sngie} 532272343Sngie 533272343SngieATF_TC(bpfjit_mbuf_ldb_abs); 534272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_abs, tc) 535272343Sngie{ 536272343Sngie 537272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_ABS " 538272343Sngie "loads bytes from mbuf correctly"); 539272343Sngie} 540272343Sngie 541272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_abs, tc) 542272343Sngie{ 543272343Sngie 544272343Sngie RZ(rump_init()); 545272343Sngie 546272343Sngie ATF_CHECK(test_ldb_abs(0)); 547272343Sngie ATF_CHECK(test_ldb_abs(1)); 548272343Sngie ATF_CHECK(test_ldb_abs(2)); 549272343Sngie ATF_CHECK(test_ldb_abs(3)); 550272343Sngie ATF_CHECK(test_ldb_abs(4)); 551272343Sngie ATF_CHECK(test_ldb_abs(5)); 552272343Sngie} 553272343Sngie 554272343SngieATF_TC(bpfjit_mbuf_ldh_abs); 555272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_abs, tc) 556272343Sngie{ 557272343Sngie 558272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_ABS " 559272343Sngie "loads halfwords from mbuf correctly"); 560272343Sngie} 561272343Sngie 562272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_abs, tc) 563272343Sngie{ 564272343Sngie 565272343Sngie RZ(rump_init()); 566272343Sngie 567272343Sngie ATF_CHECK(test_ldh_abs(0)); 568272343Sngie ATF_CHECK(test_ldh_abs(1)); 569272343Sngie ATF_CHECK(test_ldh_abs(2)); 570272343Sngie ATF_CHECK(test_ldh_abs(3)); 571272343Sngie ATF_CHECK(test_ldh_abs(4)); 572272343Sngie ATF_CHECK(test_ldh_abs(5)); 573272343Sngie} 574272343Sngie 575272343SngieATF_TC(bpfjit_mbuf_ldw_abs); 576272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_abs, tc) 577272343Sngie{ 578272343Sngie 579272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_ABS " 580272343Sngie "loads words from mbuf correctly"); 581272343Sngie} 582272343Sngie 583272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_abs, tc) 584272343Sngie{ 585272343Sngie 586272343Sngie RZ(rump_init()); 587272343Sngie 588272343Sngie ATF_CHECK(test_ldw_abs(0)); 589272343Sngie ATF_CHECK(test_ldw_abs(1)); 590272343Sngie ATF_CHECK(test_ldw_abs(2)); 591272343Sngie ATF_CHECK(test_ldw_abs(3)); 592272343Sngie ATF_CHECK(test_ldw_abs(4)); 593272343Sngie ATF_CHECK(test_ldw_abs(5)); 594272343Sngie} 595272343Sngie 596272343SngieATF_TC(bpfjit_mbuf_ldb_ind); 597272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_ind, tc) 598272343Sngie{ 599272343Sngie 600272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND " 601272343Sngie "loads bytes from mbuf correctly"); 602272343Sngie} 603272343Sngie 604272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_ind, tc) 605272343Sngie{ 606272343Sngie 607272343Sngie RZ(rump_init()); 608272343Sngie 609272343Sngie ATF_CHECK(test_ldb_ind(0)); 610272343Sngie ATF_CHECK(test_ldb_ind(1)); 611272343Sngie ATF_CHECK(test_ldb_ind(2)); 612272343Sngie ATF_CHECK(test_ldb_ind(3)); 613272343Sngie ATF_CHECK(test_ldb_ind(4)); 614272343Sngie ATF_CHECK(test_ldb_ind(5)); 615272343Sngie} 616272343Sngie 617272343SngieATF_TC(bpfjit_mbuf_ldh_ind); 618272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_ind, tc) 619272343Sngie{ 620272343Sngie 621272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND " 622272343Sngie "loads halfwords from mbuf correctly"); 623272343Sngie} 624272343Sngie 625272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_ind, tc) 626272343Sngie{ 627272343Sngie 628272343Sngie RZ(rump_init()); 629272343Sngie 630272343Sngie ATF_CHECK(test_ldh_ind(0)); 631272343Sngie ATF_CHECK(test_ldh_ind(1)); 632272343Sngie ATF_CHECK(test_ldh_ind(2)); 633272343Sngie ATF_CHECK(test_ldh_ind(3)); 634272343Sngie ATF_CHECK(test_ldh_ind(4)); 635272343Sngie ATF_CHECK(test_ldh_ind(5)); 636272343Sngie} 637272343Sngie 638272343SngieATF_TC(bpfjit_mbuf_ldw_ind); 639272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_ind, tc) 640272343Sngie{ 641272343Sngie 642272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND " 643272343Sngie "loads words from mbuf correctly"); 644272343Sngie} 645272343Sngie 646272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_ind, tc) 647272343Sngie{ 648272343Sngie 649272343Sngie RZ(rump_init()); 650272343Sngie 651272343Sngie ATF_CHECK(test_ldw_ind(0)); 652272343Sngie ATF_CHECK(test_ldw_ind(1)); 653272343Sngie ATF_CHECK(test_ldw_ind(2)); 654272343Sngie ATF_CHECK(test_ldw_ind(3)); 655272343Sngie ATF_CHECK(test_ldw_ind(4)); 656272343Sngie ATF_CHECK(test_ldw_ind(5)); 657272343Sngie} 658272343Sngie 659272343SngieATF_TC(bpfjit_mbuf_msh); 660272343SngieATF_TC_HEAD(bpfjit_mbuf_msh, tc) 661272343Sngie{ 662272343Sngie 663272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LDX+BPF_B+BPF_MSH " 664272343Sngie "loads bytes from mbuf correctly"); 665272343Sngie} 666272343Sngie 667272343SngieATF_TC_BODY(bpfjit_mbuf_msh, tc) 668272343Sngie{ 669272343Sngie 670272343Sngie RZ(rump_init()); 671272343Sngie 672272343Sngie ATF_CHECK(test_msh(0)); 673272343Sngie ATF_CHECK(test_msh(1)); 674272343Sngie ATF_CHECK(test_msh(2)); 675272343Sngie ATF_CHECK(test_msh(3)); 676272343Sngie ATF_CHECK(test_msh(4)); 677272343Sngie ATF_CHECK(test_msh(5)); 678272343Sngie} 679272343Sngie 680272343SngieATF_TC(bpfjit_mbuf_ldb_abs_overflow); 681272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_abs_overflow, tc) 682272343Sngie{ 683272343Sngie 684272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_ABS " 685272343Sngie "with out-of-bounds index aborts a filter program"); 686272343Sngie} 687272343Sngie 688272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_abs_overflow, tc) 689272343Sngie{ 690272343Sngie 691272343Sngie RZ(rump_init()); 692272343Sngie 693272343Sngie ATF_CHECK(test_ldb_abs_overflow(0)); 694272343Sngie ATF_CHECK(test_ldb_abs_overflow(1)); 695272343Sngie ATF_CHECK(test_ldb_abs_overflow(2)); 696272343Sngie ATF_CHECK(test_ldb_abs_overflow(3)); 697272343Sngie ATF_CHECK(test_ldb_abs_overflow(4)); 698272343Sngie ATF_CHECK(test_ldb_abs_overflow(5)); 699272343Sngie} 700272343Sngie 701272343SngieATF_TC(bpfjit_mbuf_ldh_abs_overflow); 702272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_abs_overflow, tc) 703272343Sngie{ 704272343Sngie 705272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_ABS " 706272343Sngie "with out-of-bounds index aborts a filter program"); 707272343Sngie} 708272343Sngie 709272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_abs_overflow, tc) 710272343Sngie{ 711272343Sngie 712272343Sngie RZ(rump_init()); 713272343Sngie 714272343Sngie ATF_CHECK(test_ldh_abs_overflow(0)); 715272343Sngie ATF_CHECK(test_ldh_abs_overflow(1)); 716272343Sngie ATF_CHECK(test_ldh_abs_overflow(2)); 717272343Sngie ATF_CHECK(test_ldh_abs_overflow(3)); 718272343Sngie ATF_CHECK(test_ldh_abs_overflow(4)); 719272343Sngie ATF_CHECK(test_ldh_abs_overflow(5)); 720272343Sngie} 721272343Sngie 722272343SngieATF_TC(bpfjit_mbuf_ldw_abs_overflow); 723272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_abs_overflow, tc) 724272343Sngie{ 725272343Sngie 726272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_ABS " 727272343Sngie "with out-of-bounds index aborts a filter program"); 728272343Sngie} 729272343Sngie 730272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_abs_overflow, tc) 731272343Sngie{ 732272343Sngie 733272343Sngie RZ(rump_init()); 734272343Sngie 735272343Sngie ATF_CHECK(test_ldw_abs_overflow(0)); 736272343Sngie ATF_CHECK(test_ldw_abs_overflow(1)); 737272343Sngie ATF_CHECK(test_ldw_abs_overflow(2)); 738272343Sngie ATF_CHECK(test_ldw_abs_overflow(3)); 739272343Sngie ATF_CHECK(test_ldw_abs_overflow(4)); 740272343Sngie ATF_CHECK(test_ldw_abs_overflow(5)); 741272343Sngie} 742272343Sngie 743272343SngieATF_TC(bpfjit_mbuf_ldb_ind_overflow1); 744272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow1, tc) 745272343Sngie{ 746272343Sngie 747272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND " 748272343Sngie "with out-of-bounds index aborts a filter program"); 749272343Sngie} 750272343Sngie 751272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow1, tc) 752272343Sngie{ 753272343Sngie 754272343Sngie RZ(rump_init()); 755272343Sngie 756272343Sngie ATF_CHECK(test_ldb_ind_overflow1(0)); 757272343Sngie ATF_CHECK(test_ldb_ind_overflow1(1)); 758272343Sngie ATF_CHECK(test_ldb_ind_overflow1(2)); 759272343Sngie ATF_CHECK(test_ldb_ind_overflow1(3)); 760272343Sngie ATF_CHECK(test_ldb_ind_overflow1(4)); 761272343Sngie ATF_CHECK(test_ldb_ind_overflow1(5)); 762272343Sngie} 763272343Sngie 764272343SngieATF_TC(bpfjit_mbuf_ldb_ind_overflow2); 765272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow2, tc) 766272343Sngie{ 767272343Sngie 768272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND " 769272343Sngie "with out-of-bounds index aborts a filter program"); 770272343Sngie} 771272343Sngie 772272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow2, tc) 773272343Sngie{ 774272343Sngie 775272343Sngie RZ(rump_init()); 776272343Sngie 777272343Sngie ATF_CHECK(test_ldb_ind_overflow2(0)); 778272343Sngie ATF_CHECK(test_ldb_ind_overflow2(1)); 779272343Sngie ATF_CHECK(test_ldb_ind_overflow2(2)); 780272343Sngie ATF_CHECK(test_ldb_ind_overflow2(3)); 781272343Sngie ATF_CHECK(test_ldb_ind_overflow2(4)); 782272343Sngie ATF_CHECK(test_ldb_ind_overflow2(5)); 783272343Sngie} 784272343Sngie 785272343SngieATF_TC(bpfjit_mbuf_ldb_ind_overflow3); 786272343SngieATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow3, tc) 787272343Sngie{ 788272343Sngie 789272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND " 790272343Sngie "with out-of-bounds index aborts a filter program"); 791272343Sngie} 792272343Sngie 793272343SngieATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow3, tc) 794272343Sngie{ 795272343Sngie 796272343Sngie RZ(rump_init()); 797272343Sngie 798272343Sngie ATF_CHECK(test_ldb_ind_overflow3(0)); 799272343Sngie ATF_CHECK(test_ldb_ind_overflow3(1)); 800272343Sngie ATF_CHECK(test_ldb_ind_overflow3(2)); 801272343Sngie ATF_CHECK(test_ldb_ind_overflow3(3)); 802272343Sngie ATF_CHECK(test_ldb_ind_overflow3(4)); 803272343Sngie ATF_CHECK(test_ldb_ind_overflow3(5)); 804272343Sngie} 805272343Sngie 806272343SngieATF_TC(bpfjit_mbuf_ldh_ind_overflow1); 807272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow1, tc) 808272343Sngie{ 809272343Sngie 810272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND " 811272343Sngie "with out-of-bounds index aborts a filter program"); 812272343Sngie} 813272343Sngie 814272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow1, tc) 815272343Sngie{ 816272343Sngie 817272343Sngie RZ(rump_init()); 818272343Sngie 819272343Sngie ATF_CHECK(test_ldh_ind_overflow1(0)); 820272343Sngie ATF_CHECK(test_ldh_ind_overflow1(1)); 821272343Sngie ATF_CHECK(test_ldh_ind_overflow1(2)); 822272343Sngie ATF_CHECK(test_ldh_ind_overflow1(3)); 823272343Sngie ATF_CHECK(test_ldh_ind_overflow1(4)); 824272343Sngie ATF_CHECK(test_ldh_ind_overflow1(5)); 825272343Sngie} 826272343Sngie 827272343SngieATF_TC(bpfjit_mbuf_ldh_ind_overflow2); 828272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow2, tc) 829272343Sngie{ 830272343Sngie 831272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND " 832272343Sngie "with out-of-bounds index aborts a filter program"); 833272343Sngie} 834272343Sngie 835272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow2, tc) 836272343Sngie{ 837272343Sngie 838272343Sngie RZ(rump_init()); 839272343Sngie 840272343Sngie ATF_CHECK(test_ldh_ind_overflow2(0)); 841272343Sngie ATF_CHECK(test_ldh_ind_overflow2(1)); 842272343Sngie ATF_CHECK(test_ldh_ind_overflow2(2)); 843272343Sngie ATF_CHECK(test_ldh_ind_overflow2(3)); 844272343Sngie ATF_CHECK(test_ldh_ind_overflow2(4)); 845272343Sngie ATF_CHECK(test_ldh_ind_overflow2(5)); 846272343Sngie} 847272343Sngie 848272343SngieATF_TC(bpfjit_mbuf_ldh_ind_overflow3); 849272343SngieATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow3, tc) 850272343Sngie{ 851272343Sngie 852272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND " 853272343Sngie "with out-of-bounds index aborts a filter program"); 854272343Sngie} 855272343Sngie 856272343SngieATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow3, tc) 857272343Sngie{ 858272343Sngie 859272343Sngie RZ(rump_init()); 860272343Sngie 861272343Sngie ATF_CHECK(test_ldh_ind_overflow3(0)); 862272343Sngie ATF_CHECK(test_ldh_ind_overflow3(1)); 863272343Sngie ATF_CHECK(test_ldh_ind_overflow3(2)); 864272343Sngie ATF_CHECK(test_ldh_ind_overflow3(3)); 865272343Sngie ATF_CHECK(test_ldh_ind_overflow3(4)); 866272343Sngie ATF_CHECK(test_ldh_ind_overflow3(5)); 867272343Sngie} 868272343Sngie 869272343SngieATF_TC(bpfjit_mbuf_ldw_ind_overflow1); 870272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow1, tc) 871272343Sngie{ 872272343Sngie 873272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND " 874272343Sngie "with out-of-bounds index aborts a filter program"); 875272343Sngie} 876272343Sngie 877272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow1, tc) 878272343Sngie{ 879272343Sngie 880272343Sngie RZ(rump_init()); 881272343Sngie 882272343Sngie ATF_CHECK(test_ldw_ind_overflow1(0)); 883272343Sngie ATF_CHECK(test_ldw_ind_overflow1(1)); 884272343Sngie ATF_CHECK(test_ldw_ind_overflow1(2)); 885272343Sngie ATF_CHECK(test_ldw_ind_overflow1(3)); 886272343Sngie ATF_CHECK(test_ldw_ind_overflow1(4)); 887272343Sngie ATF_CHECK(test_ldw_ind_overflow1(5)); 888272343Sngie} 889272343Sngie 890272343SngieATF_TC(bpfjit_mbuf_ldw_ind_overflow2); 891272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow2, tc) 892272343Sngie{ 893272343Sngie 894272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND " 895272343Sngie "with out-of-bounds index aborts a filter program"); 896272343Sngie} 897272343Sngie 898272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow2, tc) 899272343Sngie{ 900272343Sngie 901272343Sngie RZ(rump_init()); 902272343Sngie 903272343Sngie ATF_CHECK(test_ldw_ind_overflow2(0)); 904272343Sngie ATF_CHECK(test_ldw_ind_overflow2(1)); 905272343Sngie ATF_CHECK(test_ldw_ind_overflow2(2)); 906272343Sngie ATF_CHECK(test_ldw_ind_overflow2(3)); 907272343Sngie ATF_CHECK(test_ldw_ind_overflow2(4)); 908272343Sngie ATF_CHECK(test_ldw_ind_overflow2(5)); 909272343Sngie} 910272343Sngie 911272343SngieATF_TC(bpfjit_mbuf_ldw_ind_overflow3); 912272343SngieATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow3, tc) 913272343Sngie{ 914272343Sngie 915272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND " 916272343Sngie "with out-of-bounds index aborts a filter program"); 917272343Sngie} 918272343Sngie 919272343SngieATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow3, tc) 920272343Sngie{ 921272343Sngie 922272343Sngie RZ(rump_init()); 923272343Sngie 924272343Sngie ATF_CHECK(test_ldw_ind_overflow3(0)); 925272343Sngie ATF_CHECK(test_ldw_ind_overflow3(1)); 926272343Sngie ATF_CHECK(test_ldw_ind_overflow3(2)); 927272343Sngie ATF_CHECK(test_ldw_ind_overflow3(3)); 928272343Sngie ATF_CHECK(test_ldw_ind_overflow3(4)); 929272343Sngie ATF_CHECK(test_ldw_ind_overflow3(5)); 930272343Sngie} 931272343Sngie 932272343SngieATF_TC(bpfjit_mbuf_msh_overflow); 933272343SngieATF_TC_HEAD(bpfjit_mbuf_msh_overflow, tc) 934272343Sngie{ 935272343Sngie 936272343Sngie atf_tc_set_md_var(tc, "descr", "Check that BPF_LDX+BPF_B+BPF_MSH " 937272343Sngie "with out-of-bounds index aborts a filter program"); 938272343Sngie} 939272343Sngie 940272343SngieATF_TC_BODY(bpfjit_mbuf_msh_overflow, tc) 941272343Sngie{ 942272343Sngie 943272343Sngie RZ(rump_init()); 944272343Sngie 945272343Sngie ATF_CHECK(test_msh_overflow(0)); 946272343Sngie ATF_CHECK(test_msh_overflow(1)); 947272343Sngie ATF_CHECK(test_msh_overflow(2)); 948272343Sngie ATF_CHECK(test_msh_overflow(3)); 949272343Sngie ATF_CHECK(test_msh_overflow(4)); 950272343Sngie ATF_CHECK(test_msh_overflow(5)); 951272343Sngie} 952272343Sngie 953272343SngieATF_TP_ADD_TCS(tp) 954272343Sngie{ 955272343Sngie 956272343Sngie /* 957272343Sngie * For every new test please also add a similar test 958272343Sngie * to ../../net/bpf/t_mbuf.c 959272343Sngie */ 960272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_abs); 961272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_abs); 962272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_abs); 963272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind); 964272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind); 965272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind); 966272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_msh); 967272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_abs_overflow); 968272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_abs_overflow); 969272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_abs_overflow); 970272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow1); 971272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow2); 972272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow3); 973272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow1); 974272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow2); 975272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow3); 976272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow1); 977272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow2); 978272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow3); 979272343Sngie ATF_TP_ADD_TC(tp, bpfjit_mbuf_msh_overflow); 980272343Sngie 981272343Sngie return atf_no_error(); 982272343Sngie} 983