?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / tests / net / bpfjit / t_mbuf.c
blob489ef802d9abe802f75e08010c88736b6fc0184d
1 /* $NetBSD: t_mbuf.c,v 1.1 2014/07/08 21:45:55 alnsn Exp $ */
2
3 /*-
4 * Copyright (c) 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_mbuf.c,v 1.1 2014/07/08 21:45:55 alnsn Exp $");
31
32 #include <sys/param.h>
33 #include <sys/mbuf.h>
34
35 #include <net/bpf.h>
36 #include <net/bpfjit.h>
37
38 #include <stdint.h>
39 #include <string.h>
40
41 #include <rump/rump.h>
42 #include <rump/rump_syscalls.h>
43
44 #include "../../net/bpf/h_bpf.h"
45
46 /* XXX: atf-c.h has collisions with mbuf */
47 #undef m_type
48 #undef m_data
49 #include <atf-c.h>
50
51 #include "../../h_macros.h"
52
53 static bool
54 test_ldb_abs(size_t split)
55 {
56 /* Return a product of all packet bytes. */
57 static struct bpf_insn insns[] = {
58 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
59
60 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 0), /* A <- P[0] */
61 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
62 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
63
64 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 1), /* A <- P[1] */
65 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
66 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
67
68 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 2), /* A <- P[2] */
69 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
70 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
71
72 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 3), /* A <- P[3] */
73 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
74 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
75
76 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 4), /* A <- P[4] */
77 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
78 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
79 };
80
81 static unsigned char P[] = { 1, 2, 3, 4, 5 };
82 const unsigned int res = 120;
83 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
84
85 if (!prog_validate(insns, insn_count))
86 return false;
87
88 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
89 }
90
91 static bool
92 test_ldh_abs(size_t split)
93 {
94 static struct bpf_insn insns[] = {
95 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 0), /* A <- P[0:2] */
96 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
97 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
98
99 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 1), /* A <- P[1:2] */
100 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
101 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
102
103 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 2), /* A <- P[2:2] */
104 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
105 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
106
107 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 3), /* A <- P[3:2] */
108 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
109 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
110 };
111
112 static unsigned char P[] = { 1, 2, 3, 4, 5 };
113 const unsigned int res = 0x0a0e; /* 10 14 */
114 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
115
116 if (!prog_validate(insns, insn_count))
117 return false;
118
119 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
120 }
121
122 static bool
123 test_ldw_abs(size_t split)
124 {
125 static struct bpf_insn insns[] = {
126 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 0), /* A <- P[0:4] */
127 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
128 BPF_STMT(BPF_MISC+BPF_TAX, 0), /* X <- A */
129
130 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 1), /* A <- P[1:4] */
131 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
132 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
133 };
134
135 static unsigned char P[] = { 1, 2, 3, 4, 5 };
136 const unsigned int res = 0x03050709;
137 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
138
139 if (!prog_validate(insns, insn_count))
140 return false;
141
142 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
143 }
144
145 static bool
146 test_ldb_ind(size_t split)
147 {
148 /* Return a sum of all packet bytes. */
149 static struct bpf_insn insns[] = {
150 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 0), /* A <- P[0+X] */
151 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
152
153 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */
154 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
155 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
156 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
157
158 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
159 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1), /* A <- P[1+X] */
160 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
161 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
162 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
163
164 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
165 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 2), /* A <- P[2+X] */
166 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
167 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
168 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
169
170 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
171 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 3), /* A <- P[3+X] */
172 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
173 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
174 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
175 };
176
177 static unsigned char P[] = { 1, 2, 3, 4, 5 };
178 const unsigned int res = 15;
179 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
180
181 if (!prog_validate(insns, insn_count))
182 return false;
183
184 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
185 }
186
187 static bool
188 test_ldw_ind(size_t split)
189 {
190 static struct bpf_insn insns[] = {
191 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */
192 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
193
194 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
195 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 0), /* A <- P[X+0:4] */
196 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
197 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
198 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
199
200 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 0), /* X <- 0 */
201 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1), /* A <- P[X+1:4] */
202 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
203 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
204 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
205 };
206
207 static unsigned char P[] = { 1, 2, 3, 4, 5 };
208 const unsigned int res = 0x05080b0e;
209 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
210
211 if (!prog_validate(insns, insn_count))
212 return false;
213
214 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
215 }
216
217 static bool
218 test_ldh_ind(size_t split)
219 {
220 static struct bpf_insn insns[] = {
221 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 0), /* A <- P[X+0:2] */
222 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
223
224 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */
225 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
226 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
227 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
228
229 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
230 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1), /* A <- P[X+1:2] */
231 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
232 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
233 BPF_STMT(BPF_ST, 0), /* M[0] <- A */
234
235 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1), /* X <- 1 */
236 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2), /* A <- P[X+2:2] */
237 BPF_STMT(BPF_LDX+BPF_W+BPF_MEM, 0), /* X <- M[0] */
238 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */
239 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
240 };
241
242 static unsigned char P[] = { 1, 2, 3, 4, 5 };
243 const unsigned int res = 0x0a0e; /* 10 14 */
244 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
245
246 if (!prog_validate(insns, insn_count))
247 return false;
248
249 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
250 }
251
252 static bool
253 test_msh(size_t split)
254 {
255 /* Return a product of all packet bytes. */
256 static struct bpf_insn insns[] = {
257 BPF_STMT(BPF_LD+BPF_IMM, 1), /* A <- 1 */
258
259 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 0), /* X <- 4*(P[0]&0xf) */
260 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
261 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
262
263 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 1), /* X <- 4*(P[1]&0xf) */
264 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
265 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
266
267 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 2), /* X <- 4*(P[2]&0xf) */
268 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
269 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
270
271 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 3), /* X <- 4*(P[3]&0xf) */
272 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
273 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
274
275 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 4), /* X <- 4*(P[4]&0xf) */
276 BPF_STMT(BPF_ALU+BPF_MUL+BPF_X, 0), /* A <- A * X */
277 BPF_STMT(BPF_ALU+BPF_DIV+BPF_K, 4), /* A <- A / 4 */
278
279 BPF_STMT(BPF_RET+BPF_A, 0), /* ret A */
280 };
281
282 static unsigned char P[] = { 1, 2, 3, 4, 5 };
283 const unsigned int res = 120;
284 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
285
286 if (!prog_validate(insns, insn_count))
287 return false;
288
289 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == res;
290 }
291
292 static bool
293 test_ldb_abs_overflow(size_t split)
294 {
295 static struct bpf_insn insns[] = {
296 BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 5),
297 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
298 BPF_STMT(BPF_RET+BPF_A, 0),
299 };
300
301 static unsigned char P[] = { 1, 2, 3, 4, 5 };
302 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
303
304 if (!prog_validate(insns, insn_count))
305 return false;
306
307 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
308 }
309
310 static bool
311 test_ldh_abs_overflow(size_t split)
312 {
313 static struct bpf_insn insns[] = {
314 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4),
315 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
316 BPF_STMT(BPF_RET+BPF_A, 0),
317 };
318
319 static unsigned char P[] = { 1, 2, 3, 4, 5 };
320 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
321
322 if (!prog_validate(insns, insn_count))
323 return false;
324
325 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
326 }
327
328 static bool
329 test_ldw_abs_overflow(size_t split)
330 {
331 static struct bpf_insn insns[] = {
332 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 2),
333 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
334 BPF_STMT(BPF_RET+BPF_A, 0),
335 };
336
337 static unsigned char P[] = { 1, 2, 3, 4, 5 };
338 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
339
340 if (!prog_validate(insns, insn_count))
341 return false;
342
343 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
344 }
345
346 static bool
347 test_ldb_ind_overflow1(size_t split)
348 {
349 static struct bpf_insn insns[] = {
350 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 5),
351 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
352 BPF_STMT(BPF_RET+BPF_A, 0),
353 };
354
355 static unsigned char P[] = { 1, 2, 3, 4, 5 };
356 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
357
358 if (!prog_validate(insns, insn_count))
359 return false;
360
361 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
362 }
363
364 static bool
365 test_ldb_ind_overflow2(size_t split)
366 {
367 static struct bpf_insn insns[] = {
368 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 4),
369 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1),
370 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
371 BPF_STMT(BPF_RET+BPF_A, 0),
372 };
373
374 static unsigned char P[] = { 1, 2, 3, 4, 5 };
375 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
376
377 if (!prog_validate(insns, insn_count))
378 return false;
379
380 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
381 }
382
383 static bool
384 test_ldb_ind_overflow3(size_t split)
385 {
386 static struct bpf_insn insns[] = {
387 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX),
388 BPF_STMT(BPF_LD+BPF_B+BPF_IND, 1),
389 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
390 BPF_STMT(BPF_RET+BPF_A, 0),
391 };
392
393 static unsigned char P[] = { 1, 2, 3, 4, 5 };
394 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
395
396 if (!prog_validate(insns, insn_count))
397 return false;
398
399 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
400 }
401
402 static bool
403 test_ldh_ind_overflow1(size_t split)
404 {
405 static struct bpf_insn insns[] = {
406 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 4),
407 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
408 BPF_STMT(BPF_RET+BPF_A, 0),
409 };
410
411 static unsigned char P[] = { 1, 2, 3, 4, 5 };
412 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
413
414 if (!prog_validate(insns, insn_count))
415 return false;
416
417 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
418 }
419
420 static bool
421 test_ldh_ind_overflow2(size_t split)
422 {
423 static struct bpf_insn insns[] = {
424 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 3),
425 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1),
426 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
427 BPF_STMT(BPF_RET+BPF_A, 0),
428 };
429
430 static unsigned char P[] = { 1, 2, 3, 4, 5 };
431 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
432
433 if (!prog_validate(insns, insn_count))
434 return false;
435
436 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
437 }
438
439 static bool
440 test_ldh_ind_overflow3(size_t split)
441 {
442 static struct bpf_insn insns[] = {
443 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX),
444 BPF_STMT(BPF_LD+BPF_H+BPF_IND, 1),
445 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
446 BPF_STMT(BPF_RET+BPF_A, 0),
447 };
448
449 static unsigned char P[] = { 1, 2, 3, 4, 5 };
450 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
451
452 if (!prog_validate(insns, insn_count))
453 return false;
454
455 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
456 }
457
458 static bool
459 test_ldw_ind_overflow1(size_t split)
460 {
461 static struct bpf_insn insns[] = {
462 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 2),
463 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
464 BPF_STMT(BPF_RET+BPF_A, 0),
465 };
466
467 static unsigned char P[] = { 1, 2, 3, 4, 5 };
468 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
469
470 if (!prog_validate(insns, insn_count))
471 return false;
472
473 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
474 }
475
476 static bool
477 test_ldw_ind_overflow2(size_t split)
478 {
479 static struct bpf_insn insns[] = {
480 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 1),
481 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1),
482 BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),
483 BPF_STMT(BPF_RET+BPF_A, 0),
484 };
485
486 static unsigned char P[] = { 1, 2, 3, 4, 5 };
487 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
488
489 if (!prog_validate(insns, insn_count))
490 return false;
491
492 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
493 }
494
495 static bool
496 test_ldw_ind_overflow3(size_t split)
497 {
498 static struct bpf_insn insns[] = {
499 BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, UINT32_MAX),
500 BPF_STMT(BPF_LD+BPF_W+BPF_IND, 1),
501 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
502 BPF_STMT(BPF_RET+BPF_A, 0),
503 };
504
505 static unsigned char P[] = { 1, 2, 3, 4, 5 };
506 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
507
508 if (!prog_validate(insns, insn_count))
509 return false;
510
511 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
512 }
513
514 static bool
515 test_msh_overflow(size_t split)
516 {
517 static struct bpf_insn insns[] = {
518 BPF_STMT(BPF_LDX+BPF_B+BPF_MSH, 5),
519 BPF_STMT(BPF_MISC+BPF_TXA, 0),
520 BPF_STMT(BPF_ALU+BPF_ADD+BPF_K, 1),
521 BPF_STMT(BPF_RET+BPF_A, 0),
522 };
523
524 static unsigned char P[] = { 1, 2, 3, 4, 5 };
525 const size_t insn_count = sizeof(insns) / sizeof(insns[0]);
526
527 if (!prog_validate(insns, insn_count))
528 return false;
529
530 return exec_prog_mchain2(insns, insn_count, P, sizeof(P), split) == 0;
531 }
532
533 ATF_TC(bpfjit_mbuf_ldb_abs);
534 ATF_TC_HEAD(bpfjit_mbuf_ldb_abs, tc)
535 {
536
537 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_ABS "
538 "loads bytes from mbuf correctly");
539 }
540
541 ATF_TC_BODY(bpfjit_mbuf_ldb_abs, tc)
542 {
543
544 RZ(rump_init());
545
546 ATF_CHECK(test_ldb_abs(0));
547 ATF_CHECK(test_ldb_abs(1));
548 ATF_CHECK(test_ldb_abs(2));
549 ATF_CHECK(test_ldb_abs(3));
550 ATF_CHECK(test_ldb_abs(4));
551 ATF_CHECK(test_ldb_abs(5));
552 }
553
554 ATF_TC(bpfjit_mbuf_ldh_abs);
555 ATF_TC_HEAD(bpfjit_mbuf_ldh_abs, tc)
556 {
557
558 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_ABS "
559 "loads halfwords from mbuf correctly");
560 }
561
562 ATF_TC_BODY(bpfjit_mbuf_ldh_abs, tc)
563 {
564
565 RZ(rump_init());
566
567 ATF_CHECK(test_ldh_abs(0));
568 ATF_CHECK(test_ldh_abs(1));
569 ATF_CHECK(test_ldh_abs(2));
570 ATF_CHECK(test_ldh_abs(3));
571 ATF_CHECK(test_ldh_abs(4));
572 ATF_CHECK(test_ldh_abs(5));
573 }
574
575 ATF_TC(bpfjit_mbuf_ldw_abs);
576 ATF_TC_HEAD(bpfjit_mbuf_ldw_abs, tc)
577 {
578
579 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_ABS "
580 "loads words from mbuf correctly");
581 }
582
583 ATF_TC_BODY(bpfjit_mbuf_ldw_abs, tc)
584 {
585
586 RZ(rump_init());
587
588 ATF_CHECK(test_ldw_abs(0));
589 ATF_CHECK(test_ldw_abs(1));
590 ATF_CHECK(test_ldw_abs(2));
591 ATF_CHECK(test_ldw_abs(3));
592 ATF_CHECK(test_ldw_abs(4));
593 ATF_CHECK(test_ldw_abs(5));
594 }
595
596 ATF_TC(bpfjit_mbuf_ldb_ind);
597 ATF_TC_HEAD(bpfjit_mbuf_ldb_ind, tc)
598 {
599
600 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND "
601 "loads bytes from mbuf correctly");
602 }
603
604 ATF_TC_BODY(bpfjit_mbuf_ldb_ind, tc)
605 {
606
607 RZ(rump_init());
608
609 ATF_CHECK(test_ldb_ind(0));
610 ATF_CHECK(test_ldb_ind(1));
611 ATF_CHECK(test_ldb_ind(2));
612 ATF_CHECK(test_ldb_ind(3));
613 ATF_CHECK(test_ldb_ind(4));
614 ATF_CHECK(test_ldb_ind(5));
615 }
616
617 ATF_TC(bpfjit_mbuf_ldh_ind);
618 ATF_TC_HEAD(bpfjit_mbuf_ldh_ind, tc)
619 {
620
621 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND "
622 "loads halfwords from mbuf correctly");
623 }
624
625 ATF_TC_BODY(bpfjit_mbuf_ldh_ind, tc)
626 {
627
628 RZ(rump_init());
629
630 ATF_CHECK(test_ldh_ind(0));
631 ATF_CHECK(test_ldh_ind(1));
632 ATF_CHECK(test_ldh_ind(2));
633 ATF_CHECK(test_ldh_ind(3));
634 ATF_CHECK(test_ldh_ind(4));
635 ATF_CHECK(test_ldh_ind(5));
636 }
637
638 ATF_TC(bpfjit_mbuf_ldw_ind);
639 ATF_TC_HEAD(bpfjit_mbuf_ldw_ind, tc)
640 {
641
642 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND "
643 "loads words from mbuf correctly");
644 }
645
646 ATF_TC_BODY(bpfjit_mbuf_ldw_ind, tc)
647 {
648
649 RZ(rump_init());
650
651 ATF_CHECK(test_ldw_ind(0));
652 ATF_CHECK(test_ldw_ind(1));
653 ATF_CHECK(test_ldw_ind(2));
654 ATF_CHECK(test_ldw_ind(3));
655 ATF_CHECK(test_ldw_ind(4));
656 ATF_CHECK(test_ldw_ind(5));
657 }
658
659 ATF_TC(bpfjit_mbuf_msh);
660 ATF_TC_HEAD(bpfjit_mbuf_msh, tc)
661 {
662
663 atf_tc_set_md_var(tc, "descr", "Check that BPF_LDX+BPF_B+BPF_MSH "
664 "loads bytes from mbuf correctly");
665 }
666
667 ATF_TC_BODY(bpfjit_mbuf_msh, tc)
668 {
669
670 RZ(rump_init());
671
672 ATF_CHECK(test_msh(0));
673 ATF_CHECK(test_msh(1));
674 ATF_CHECK(test_msh(2));
675 ATF_CHECK(test_msh(3));
676 ATF_CHECK(test_msh(4));
677 ATF_CHECK(test_msh(5));
678 }
679
680 ATF_TC(bpfjit_mbuf_ldb_abs_overflow);
681 ATF_TC_HEAD(bpfjit_mbuf_ldb_abs_overflow, tc)
682 {
683
684 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_ABS "
685 "with out-of-bounds index aborts a filter program");
686 }
687
688 ATF_TC_BODY(bpfjit_mbuf_ldb_abs_overflow, tc)
689 {
690
691 RZ(rump_init());
692
693 ATF_CHECK(test_ldb_abs_overflow(0));
694 ATF_CHECK(test_ldb_abs_overflow(1));
695 ATF_CHECK(test_ldb_abs_overflow(2));
696 ATF_CHECK(test_ldb_abs_overflow(3));
697 ATF_CHECK(test_ldb_abs_overflow(4));
698 ATF_CHECK(test_ldb_abs_overflow(5));
699 }
700
701 ATF_TC(bpfjit_mbuf_ldh_abs_overflow);
702 ATF_TC_HEAD(bpfjit_mbuf_ldh_abs_overflow, tc)
703 {
704
705 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_ABS "
706 "with out-of-bounds index aborts a filter program");
707 }
708
709 ATF_TC_BODY(bpfjit_mbuf_ldh_abs_overflow, tc)
710 {
711
712 RZ(rump_init());
713
714 ATF_CHECK(test_ldh_abs_overflow(0));
715 ATF_CHECK(test_ldh_abs_overflow(1));
716 ATF_CHECK(test_ldh_abs_overflow(2));
717 ATF_CHECK(test_ldh_abs_overflow(3));
718 ATF_CHECK(test_ldh_abs_overflow(4));
719 ATF_CHECK(test_ldh_abs_overflow(5));
720 }
721
722 ATF_TC(bpfjit_mbuf_ldw_abs_overflow);
723 ATF_TC_HEAD(bpfjit_mbuf_ldw_abs_overflow, tc)
724 {
725
726 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_ABS "
727 "with out-of-bounds index aborts a filter program");
728 }
729
730 ATF_TC_BODY(bpfjit_mbuf_ldw_abs_overflow, tc)
731 {
732
733 RZ(rump_init());
734
735 ATF_CHECK(test_ldw_abs_overflow(0));
736 ATF_CHECK(test_ldw_abs_overflow(1));
737 ATF_CHECK(test_ldw_abs_overflow(2));
738 ATF_CHECK(test_ldw_abs_overflow(3));
739 ATF_CHECK(test_ldw_abs_overflow(4));
740 ATF_CHECK(test_ldw_abs_overflow(5));
741 }
742
743 ATF_TC(bpfjit_mbuf_ldb_ind_overflow1);
744 ATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow1, tc)
745 {
746
747 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND "
748 "with out-of-bounds index aborts a filter program");
749 }
750
751 ATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow1, tc)
752 {
753
754 RZ(rump_init());
755
756 ATF_CHECK(test_ldb_ind_overflow1(0));
757 ATF_CHECK(test_ldb_ind_overflow1(1));
758 ATF_CHECK(test_ldb_ind_overflow1(2));
759 ATF_CHECK(test_ldb_ind_overflow1(3));
760 ATF_CHECK(test_ldb_ind_overflow1(4));
761 ATF_CHECK(test_ldb_ind_overflow1(5));
762 }
763
764 ATF_TC(bpfjit_mbuf_ldb_ind_overflow2);
765 ATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow2, tc)
766 {
767
768 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND "
769 "with out-of-bounds index aborts a filter program");
770 }
771
772 ATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow2, tc)
773 {
774
775 RZ(rump_init());
776
777 ATF_CHECK(test_ldb_ind_overflow2(0));
778 ATF_CHECK(test_ldb_ind_overflow2(1));
779 ATF_CHECK(test_ldb_ind_overflow2(2));
780 ATF_CHECK(test_ldb_ind_overflow2(3));
781 ATF_CHECK(test_ldb_ind_overflow2(4));
782 ATF_CHECK(test_ldb_ind_overflow2(5));
783 }
784
785 ATF_TC(bpfjit_mbuf_ldb_ind_overflow3);
786 ATF_TC_HEAD(bpfjit_mbuf_ldb_ind_overflow3, tc)
787 {
788
789 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_B+BPF_IND "
790 "with out-of-bounds index aborts a filter program");
791 }
792
793 ATF_TC_BODY(bpfjit_mbuf_ldb_ind_overflow3, tc)
794 {
795
796 RZ(rump_init());
797
798 ATF_CHECK(test_ldb_ind_overflow3(0));
799 ATF_CHECK(test_ldb_ind_overflow3(1));
800 ATF_CHECK(test_ldb_ind_overflow3(2));
801 ATF_CHECK(test_ldb_ind_overflow3(3));
802 ATF_CHECK(test_ldb_ind_overflow3(4));
803 ATF_CHECK(test_ldb_ind_overflow3(5));
804 }
805
806 ATF_TC(bpfjit_mbuf_ldh_ind_overflow1);
807 ATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow1, tc)
808 {
809
810 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND "
811 "with out-of-bounds index aborts a filter program");
812 }
813
814 ATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow1, tc)
815 {
816
817 RZ(rump_init());
818
819 ATF_CHECK(test_ldh_ind_overflow1(0));
820 ATF_CHECK(test_ldh_ind_overflow1(1));
821 ATF_CHECK(test_ldh_ind_overflow1(2));
822 ATF_CHECK(test_ldh_ind_overflow1(3));
823 ATF_CHECK(test_ldh_ind_overflow1(4));
824 ATF_CHECK(test_ldh_ind_overflow1(5));
825 }
826
827 ATF_TC(bpfjit_mbuf_ldh_ind_overflow2);
828 ATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow2, tc)
829 {
830
831 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND "
832 "with out-of-bounds index aborts a filter program");
833 }
834
835 ATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow2, tc)
836 {
837
838 RZ(rump_init());
839
840 ATF_CHECK(test_ldh_ind_overflow2(0));
841 ATF_CHECK(test_ldh_ind_overflow2(1));
842 ATF_CHECK(test_ldh_ind_overflow2(2));
843 ATF_CHECK(test_ldh_ind_overflow2(3));
844 ATF_CHECK(test_ldh_ind_overflow2(4));
845 ATF_CHECK(test_ldh_ind_overflow2(5));
846 }
847
848 ATF_TC(bpfjit_mbuf_ldh_ind_overflow3);
849 ATF_TC_HEAD(bpfjit_mbuf_ldh_ind_overflow3, tc)
850 {
851
852 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_H+BPF_IND "
853 "with out-of-bounds index aborts a filter program");
854 }
855
856 ATF_TC_BODY(bpfjit_mbuf_ldh_ind_overflow3, tc)
857 {
858
859 RZ(rump_init());
860
861 ATF_CHECK(test_ldh_ind_overflow3(0));
862 ATF_CHECK(test_ldh_ind_overflow3(1));
863 ATF_CHECK(test_ldh_ind_overflow3(2));
864 ATF_CHECK(test_ldh_ind_overflow3(3));
865 ATF_CHECK(test_ldh_ind_overflow3(4));
866 ATF_CHECK(test_ldh_ind_overflow3(5));
867 }
868
869 ATF_TC(bpfjit_mbuf_ldw_ind_overflow1);
870 ATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow1, tc)
871 {
872
873 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND "
874 "with out-of-bounds index aborts a filter program");
875 }
876
877 ATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow1, tc)
878 {
879
880 RZ(rump_init());
881
882 ATF_CHECK(test_ldw_ind_overflow1(0));
883 ATF_CHECK(test_ldw_ind_overflow1(1));
884 ATF_CHECK(test_ldw_ind_overflow1(2));
885 ATF_CHECK(test_ldw_ind_overflow1(3));
886 ATF_CHECK(test_ldw_ind_overflow1(4));
887 ATF_CHECK(test_ldw_ind_overflow1(5));
888 }
889
890 ATF_TC(bpfjit_mbuf_ldw_ind_overflow2);
891 ATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow2, tc)
892 {
893
894 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND "
895 "with out-of-bounds index aborts a filter program");
896 }
897
898 ATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow2, tc)
899 {
900
901 RZ(rump_init());
902
903 ATF_CHECK(test_ldw_ind_overflow2(0));
904 ATF_CHECK(test_ldw_ind_overflow2(1));
905 ATF_CHECK(test_ldw_ind_overflow2(2));
906 ATF_CHECK(test_ldw_ind_overflow2(3));
907 ATF_CHECK(test_ldw_ind_overflow2(4));
908 ATF_CHECK(test_ldw_ind_overflow2(5));
909 }
910
911 ATF_TC(bpfjit_mbuf_ldw_ind_overflow3);
912 ATF_TC_HEAD(bpfjit_mbuf_ldw_ind_overflow3, tc)
913 {
914
915 atf_tc_set_md_var(tc, "descr", "Check that BPF_LD+BPF_W+BPF_IND "
916 "with out-of-bounds index aborts a filter program");
917 }
918
919 ATF_TC_BODY(bpfjit_mbuf_ldw_ind_overflow3, tc)
920 {
921
922 RZ(rump_init());
923
924 ATF_CHECK(test_ldw_ind_overflow3(0));
925 ATF_CHECK(test_ldw_ind_overflow3(1));
926 ATF_CHECK(test_ldw_ind_overflow3(2));
927 ATF_CHECK(test_ldw_ind_overflow3(3));
928 ATF_CHECK(test_ldw_ind_overflow3(4));
929 ATF_CHECK(test_ldw_ind_overflow3(5));
930 }
931
932 ATF_TC(bpfjit_mbuf_msh_overflow);
933 ATF_TC_HEAD(bpfjit_mbuf_msh_overflow, tc)
934 {
935
936 atf_tc_set_md_var(tc, "descr", "Check that BPF_LDX+BPF_B+BPF_MSH "
937 "with out-of-bounds index aborts a filter program");
938 }
939
940 ATF_TC_BODY(bpfjit_mbuf_msh_overflow, tc)
941 {
942
943 RZ(rump_init());
944
945 ATF_CHECK(test_msh_overflow(0));
946 ATF_CHECK(test_msh_overflow(1));
947 ATF_CHECK(test_msh_overflow(2));
948 ATF_CHECK(test_msh_overflow(3));
949 ATF_CHECK(test_msh_overflow(4));
950 ATF_CHECK(test_msh_overflow(5));
951 }
952
953 ATF_TP_ADD_TCS(tp)
954 {
955
956 /*
957 * For every new test please also add a similar test
958 * to ../../net/bpf/t_mbuf.c
959 */
960 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_abs);
961 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_abs);
962 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_abs);
963 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind);
964 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind);
965 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind);
966 ATF_TP_ADD_TC(tp, bpfjit_mbuf_msh);
967 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_abs_overflow);
968 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_abs_overflow);
969 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_abs_overflow);
970 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow1);
971 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow2);
972 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldb_ind_overflow3);
973 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow1);
974 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow2);
975 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldh_ind_overflow3);
976 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow1);
977 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow2);
978 ATF_TP_ADD_TC(tp, bpfjit_mbuf_ldw_ind_overflow3);
979 ATF_TP_ADD_TC(tp, bpfjit_mbuf_msh_overflow);
980
981 return atf_no_error();
982 }
MINIX 3 (repo.or.cz mirror)