rawdev: add private data size to info query
[dpdk.git] / app / test / test_bpf.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Intel Corporation
3  */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <stdint.h>
8 #include <inttypes.h>
9
10 #include <rte_memory.h>
11 #include <rte_debug.h>
12 #include <rte_hexdump.h>
13 #include <rte_random.h>
14 #include <rte_byteorder.h>
15 #include <rte_errno.h>
16 #include <rte_bpf.h>
17 #include <rte_ether.h>
18 #include <rte_ip.h>
19
20 #include "test.h"
21
22 /*
23  * Basic functional tests for librte_bpf.
24  * The main procedure - load eBPF program, execute it and
25  * compare restuls with expected values.
26  */
27
28 struct dummy_offset {
29         uint64_t u64;
30         uint32_t u32;
31         uint16_t u16;
32         uint8_t  u8;
33 };
34
35 struct dummy_vect8 {
36         struct dummy_offset in[8];
37         struct dummy_offset out[8];
38 };
39
40 struct dummy_net {
41         struct rte_ether_hdr eth_hdr;
42         struct rte_vlan_hdr vlan_hdr;
43         struct rte_ipv4_hdr ip_hdr;
44 };
45
46 #define DUMMY_MBUF_NUM  2
47
48 /* first mbuf in the packet, should always be at offset 0 */
49 struct dummy_mbuf {
50         struct rte_mbuf mb[DUMMY_MBUF_NUM];
51         uint8_t buf[DUMMY_MBUF_NUM][RTE_MBUF_DEFAULT_BUF_SIZE];
52 };
53
54 #define TEST_FILL_1     0xDEADBEEF
55
56 #define TEST_MUL_1      21
57 #define TEST_MUL_2      -100
58
59 #define TEST_SHIFT_1    15
60 #define TEST_SHIFT_2    33
61
62 #define TEST_JCC_1      0
63 #define TEST_JCC_2      -123
64 #define TEST_JCC_3      5678
65 #define TEST_JCC_4      TEST_FILL_1
66
67 #define TEST_IMM_1      UINT64_MAX
68 #define TEST_IMM_2      ((uint64_t)INT64_MIN)
69 #define TEST_IMM_3      ((uint64_t)INT64_MAX + INT32_MAX)
70 #define TEST_IMM_4      ((uint64_t)UINT32_MAX)
71 #define TEST_IMM_5      ((uint64_t)UINT32_MAX + 1)
72
73 #define TEST_MEMFROB    0x2a2a2a2a
74
75 #define STRING_GEEK     0x6B656567
76 #define STRING_WEEK     0x6B656577
77
78 #define TEST_NETMASK 0xffffff00
79 #define TEST_SUBNET  0xaca80200
80
81 uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
82 uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
83
84 uint32_t ip_src_addr = (172U << 24) | (168U << 16) | (2 << 8) | 1;
85 uint32_t ip_dst_addr = (172U << 24) | (168U << 16) | (2 << 8) | 2;
86
87 struct bpf_test {
88         const char *name;
89         size_t arg_sz;
90         struct rte_bpf_prm prm;
91         void (*prepare)(void *);
92         int (*check_result)(uint64_t, const void *);
93         uint32_t allow_fail;
94 };
95
96 /*
97  * Compare return value and result data with expected ones.
98  * Report a failure if they don't match.
99  */
100 static int
101 cmp_res(const char *func, uint64_t exp_rc, uint64_t ret_rc,
102         const void *exp_res, const void *ret_res, size_t res_sz)
103 {
104         int32_t ret;
105
106         ret = 0;
107         if (exp_rc != ret_rc) {
108                 printf("%s@%d: invalid return value, expected: 0x%" PRIx64
109                         ",result: 0x%" PRIx64 "\n",
110                         func, __LINE__, exp_rc, ret_rc);
111                 ret |= -1;
112         }
113
114         if (memcmp(exp_res, ret_res, res_sz) != 0) {
115                 printf("%s: invalid value\n", func);
116                 rte_memdump(stdout, "expected", exp_res, res_sz);
117                 rte_memdump(stdout, "result", ret_res, res_sz);
118                 ret |= -1;
119         }
120
121         return ret;
122 }
123
124 /* store immediate test-cases */
125 static const struct ebpf_insn test_store1_prog[] = {
126         {
127                 .code = (BPF_ST | BPF_MEM | BPF_B),
128                 .dst_reg = EBPF_REG_1,
129                 .off = offsetof(struct dummy_offset, u8),
130                 .imm = TEST_FILL_1,
131         },
132         {
133                 .code = (BPF_ST | BPF_MEM | BPF_H),
134                 .dst_reg = EBPF_REG_1,
135                 .off = offsetof(struct dummy_offset, u16),
136                 .imm = TEST_FILL_1,
137         },
138         {
139                 .code = (BPF_ST | BPF_MEM | BPF_W),
140                 .dst_reg = EBPF_REG_1,
141                 .off = offsetof(struct dummy_offset, u32),
142                 .imm = TEST_FILL_1,
143         },
144         {
145                 .code = (BPF_ST | BPF_MEM | EBPF_DW),
146                 .dst_reg = EBPF_REG_1,
147                 .off = offsetof(struct dummy_offset, u64),
148                 .imm = TEST_FILL_1,
149         },
150         /* return 1 */
151         {
152                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
153                 .dst_reg = EBPF_REG_0,
154                 .imm = 1,
155         },
156         {
157                 .code = (BPF_JMP | EBPF_EXIT),
158         },
159 };
160
161 static void
162 test_store1_prepare(void *arg)
163 {
164         struct dummy_offset *df;
165
166         df = arg;
167         memset(df, 0, sizeof(*df));
168 }
169
170 static int
171 test_store1_check(uint64_t rc, const void *arg)
172 {
173         const struct dummy_offset *dft;
174         struct dummy_offset dfe;
175
176         dft = arg;
177
178         memset(&dfe, 0, sizeof(dfe));
179         dfe.u64 = (int32_t)TEST_FILL_1;
180         dfe.u32 = dfe.u64;
181         dfe.u16 = dfe.u64;
182         dfe.u8 = dfe.u64;
183
184         return cmp_res(__func__, 1, rc, &dfe, dft, sizeof(dfe));
185 }
186
187 /* store register test-cases */
188 static const struct ebpf_insn test_store2_prog[] = {
189
190         {
191                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
192                 .dst_reg = EBPF_REG_2,
193                 .imm = TEST_FILL_1,
194         },
195         {
196                 .code = (BPF_STX | BPF_MEM | BPF_B),
197                 .dst_reg = EBPF_REG_1,
198                 .src_reg = EBPF_REG_2,
199                 .off = offsetof(struct dummy_offset, u8),
200         },
201         {
202                 .code = (BPF_STX | BPF_MEM | BPF_H),
203                 .dst_reg = EBPF_REG_1,
204                 .src_reg = EBPF_REG_2,
205                 .off = offsetof(struct dummy_offset, u16),
206         },
207         {
208                 .code = (BPF_STX | BPF_MEM | BPF_W),
209                 .dst_reg = EBPF_REG_1,
210                 .src_reg = EBPF_REG_2,
211                 .off = offsetof(struct dummy_offset, u32),
212         },
213         {
214                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
215                 .dst_reg = EBPF_REG_1,
216                 .src_reg = EBPF_REG_2,
217                 .off = offsetof(struct dummy_offset, u64),
218         },
219         /* return 1 */
220         {
221                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
222                 .dst_reg = EBPF_REG_0,
223                 .imm = 1,
224         },
225         {
226                 .code = (BPF_JMP | EBPF_EXIT),
227         },
228 };
229
230 /* load test-cases */
231 static const struct ebpf_insn test_load1_prog[] = {
232
233         {
234                 .code = (BPF_LDX | BPF_MEM | BPF_B),
235                 .dst_reg = EBPF_REG_2,
236                 .src_reg = EBPF_REG_1,
237                 .off = offsetof(struct dummy_offset, u8),
238         },
239         {
240                 .code = (BPF_LDX | BPF_MEM | BPF_H),
241                 .dst_reg = EBPF_REG_3,
242                 .src_reg = EBPF_REG_1,
243                 .off = offsetof(struct dummy_offset, u16),
244         },
245         {
246                 .code = (BPF_LDX | BPF_MEM | BPF_W),
247                 .dst_reg = EBPF_REG_4,
248                 .src_reg = EBPF_REG_1,
249                 .off = offsetof(struct dummy_offset, u32),
250         },
251         {
252                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
253                 .dst_reg = EBPF_REG_0,
254                 .src_reg = EBPF_REG_1,
255                 .off = offsetof(struct dummy_offset, u64),
256         },
257         /* return sum */
258         {
259                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
260                 .dst_reg = EBPF_REG_0,
261                 .src_reg = EBPF_REG_4,
262         },
263         {
264                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
265                 .dst_reg = EBPF_REG_0,
266                 .src_reg = EBPF_REG_3,
267         },
268         {
269                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
270                 .dst_reg = EBPF_REG_0,
271                 .src_reg = EBPF_REG_2,
272         },
273         {
274                 .code = (BPF_JMP | EBPF_EXIT),
275         },
276 };
277
278 static void
279 test_load1_prepare(void *arg)
280 {
281         struct dummy_offset *df;
282
283         df = arg;
284
285         memset(df, 0, sizeof(*df));
286         df->u64 = (int32_t)TEST_FILL_1;
287         df->u32 = df->u64;
288         df->u16 = df->u64;
289         df->u8 = df->u64;
290 }
291
292 static int
293 test_load1_check(uint64_t rc, const void *arg)
294 {
295         uint64_t v;
296         const struct dummy_offset *dft;
297
298         dft = arg;
299         v = dft->u64;
300         v += dft->u32;
301         v += dft->u16;
302         v += dft->u8;
303
304         return cmp_res(__func__, v, rc, dft, dft, sizeof(*dft));
305 }
306
307 /* load immediate test-cases */
308 static const struct ebpf_insn test_ldimm1_prog[] = {
309
310         {
311                 .code = (BPF_LD | BPF_IMM | EBPF_DW),
312                 .dst_reg = EBPF_REG_0,
313                 .imm = (uint32_t)TEST_IMM_1,
314         },
315         {
316                 .imm = TEST_IMM_1 >> 32,
317         },
318         {
319                 .code = (BPF_LD | BPF_IMM | EBPF_DW),
320                 .dst_reg = EBPF_REG_3,
321                 .imm = (uint32_t)TEST_IMM_2,
322         },
323         {
324                 .imm = TEST_IMM_2 >> 32,
325         },
326         {
327                 .code = (BPF_LD | BPF_IMM | EBPF_DW),
328                 .dst_reg = EBPF_REG_5,
329                 .imm = (uint32_t)TEST_IMM_3,
330         },
331         {
332                 .imm = TEST_IMM_3 >> 32,
333         },
334         {
335                 .code = (BPF_LD | BPF_IMM | EBPF_DW),
336                 .dst_reg = EBPF_REG_7,
337                 .imm = (uint32_t)TEST_IMM_4,
338         },
339         {
340                 .imm = TEST_IMM_4 >> 32,
341         },
342         {
343                 .code = (BPF_LD | BPF_IMM | EBPF_DW),
344                 .dst_reg = EBPF_REG_9,
345                 .imm = (uint32_t)TEST_IMM_5,
346         },
347         {
348                 .imm = TEST_IMM_5 >> 32,
349         },
350         /* return sum */
351         {
352                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
353                 .dst_reg = EBPF_REG_0,
354                 .src_reg = EBPF_REG_3,
355         },
356         {
357                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
358                 .dst_reg = EBPF_REG_0,
359                 .src_reg = EBPF_REG_5,
360         },
361         {
362                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
363                 .dst_reg = EBPF_REG_0,
364                 .src_reg = EBPF_REG_7,
365         },
366         {
367                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
368                 .dst_reg = EBPF_REG_0,
369                 .src_reg = EBPF_REG_9,
370         },
371         {
372                 .code = (BPF_JMP | EBPF_EXIT),
373         },
374 };
375
376 static int
377 test_ldimm1_check(uint64_t rc, const void *arg)
378 {
379         uint64_t v1, v2;
380
381         v1 = TEST_IMM_1;
382         v2 = TEST_IMM_2;
383         v1 += v2;
384         v2 = TEST_IMM_3;
385         v1 += v2;
386         v2 = TEST_IMM_4;
387         v1 += v2;
388         v2 = TEST_IMM_5;
389         v1 += v2;
390
391         return cmp_res(__func__, v1, rc, arg, arg, 0);
392 }
393
394
395 /* alu mul test-cases */
396 static const struct ebpf_insn test_mul1_prog[] = {
397
398         {
399                 .code = (BPF_LDX | BPF_MEM | BPF_W),
400                 .dst_reg = EBPF_REG_2,
401                 .src_reg = EBPF_REG_1,
402                 .off = offsetof(struct dummy_vect8, in[0].u32),
403         },
404         {
405                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
406                 .dst_reg = EBPF_REG_3,
407                 .src_reg = EBPF_REG_1,
408                 .off = offsetof(struct dummy_vect8, in[1].u64),
409         },
410         {
411                 .code = (BPF_LDX | BPF_MEM | BPF_W),
412                 .dst_reg = EBPF_REG_4,
413                 .src_reg = EBPF_REG_1,
414                 .off = offsetof(struct dummy_vect8, in[2].u32),
415         },
416         {
417                 .code = (BPF_ALU | BPF_MUL | BPF_K),
418                 .dst_reg = EBPF_REG_2,
419                 .imm = TEST_MUL_1,
420         },
421         {
422                 .code = (EBPF_ALU64 | BPF_MUL | BPF_K),
423                 .dst_reg = EBPF_REG_3,
424                 .imm = TEST_MUL_2,
425         },
426         {
427                 .code = (BPF_ALU | BPF_MUL | BPF_X),
428                 .dst_reg = EBPF_REG_4,
429                 .src_reg = EBPF_REG_2,
430         },
431         {
432                 .code = (EBPF_ALU64 | BPF_MUL | BPF_X),
433                 .dst_reg = EBPF_REG_4,
434                 .src_reg = EBPF_REG_3,
435         },
436         {
437                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
438                 .dst_reg = EBPF_REG_1,
439                 .src_reg = EBPF_REG_2,
440                 .off = offsetof(struct dummy_vect8, out[0].u64),
441         },
442         {
443                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
444                 .dst_reg = EBPF_REG_1,
445                 .src_reg = EBPF_REG_3,
446                 .off = offsetof(struct dummy_vect8, out[1].u64),
447         },
448         {
449                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
450                 .dst_reg = EBPF_REG_1,
451                 .src_reg = EBPF_REG_4,
452                 .off = offsetof(struct dummy_vect8, out[2].u64),
453         },
454         /* return 1 */
455         {
456                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
457                 .dst_reg = EBPF_REG_0,
458                 .imm = 1,
459         },
460         {
461                 .code = (BPF_JMP | EBPF_EXIT),
462         },
463 };
464
465 static void
466 test_mul1_prepare(void *arg)
467 {
468         struct dummy_vect8 *dv;
469         uint64_t v;
470
471         dv = arg;
472
473         v = rte_rand();
474
475         memset(dv, 0, sizeof(*dv));
476         dv->in[0].u32 = v;
477         dv->in[1].u64 = v << 12 | v >> 6;
478         dv->in[2].u32 = -v;
479 }
480
481 static int
482 test_mul1_check(uint64_t rc, const void *arg)
483 {
484         uint64_t r2, r3, r4;
485         const struct dummy_vect8 *dvt;
486         struct dummy_vect8 dve;
487
488         dvt = arg;
489         memset(&dve, 0, sizeof(dve));
490
491         r2 = dvt->in[0].u32;
492         r3 = dvt->in[1].u64;
493         r4 = dvt->in[2].u32;
494
495         r2 = (uint32_t)r2 * TEST_MUL_1;
496         r3 *= TEST_MUL_2;
497         r4 = (uint32_t)(r4 * r2);
498         r4 *= r3;
499
500         dve.out[0].u64 = r2;
501         dve.out[1].u64 = r3;
502         dve.out[2].u64 = r4;
503
504         return cmp_res(__func__, 1, rc, dve.out, dvt->out, sizeof(dve.out));
505 }
506
507 /* alu shift test-cases */
508 static const struct ebpf_insn test_shift1_prog[] = {
509
510         {
511                 .code = (BPF_LDX | BPF_MEM | BPF_W),
512                 .dst_reg = EBPF_REG_2,
513                 .src_reg = EBPF_REG_1,
514                 .off = offsetof(struct dummy_vect8, in[0].u32),
515         },
516         {
517                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
518                 .dst_reg = EBPF_REG_3,
519                 .src_reg = EBPF_REG_1,
520                 .off = offsetof(struct dummy_vect8, in[1].u64),
521         },
522         {
523                 .code = (BPF_LDX | BPF_MEM | BPF_W),
524                 .dst_reg = EBPF_REG_4,
525                 .src_reg = EBPF_REG_1,
526                 .off = offsetof(struct dummy_vect8, in[2].u32),
527         },
528         {
529                 .code = (BPF_ALU | BPF_LSH | BPF_K),
530                 .dst_reg = EBPF_REG_2,
531                 .imm = TEST_SHIFT_1,
532         },
533         {
534                 .code = (EBPF_ALU64 | EBPF_ARSH | BPF_K),
535                 .dst_reg = EBPF_REG_3,
536                 .imm = TEST_SHIFT_2,
537         },
538         {
539                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
540                 .dst_reg = EBPF_REG_1,
541                 .src_reg = EBPF_REG_2,
542                 .off = offsetof(struct dummy_vect8, out[0].u64),
543         },
544         {
545                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
546                 .dst_reg = EBPF_REG_1,
547                 .src_reg = EBPF_REG_3,
548                 .off = offsetof(struct dummy_vect8, out[1].u64),
549         },
550         {
551                 .code = (BPF_ALU | BPF_RSH | BPF_X),
552                 .dst_reg = EBPF_REG_2,
553                 .src_reg = EBPF_REG_4,
554         },
555         {
556                 .code = (EBPF_ALU64 | BPF_LSH | BPF_X),
557                 .dst_reg = EBPF_REG_3,
558                 .src_reg = EBPF_REG_4,
559         },
560         {
561                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
562                 .dst_reg = EBPF_REG_1,
563                 .src_reg = EBPF_REG_2,
564                 .off = offsetof(struct dummy_vect8, out[2].u64),
565         },
566         {
567                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
568                 .dst_reg = EBPF_REG_1,
569                 .src_reg = EBPF_REG_3,
570                 .off = offsetof(struct dummy_vect8, out[3].u64),
571         },
572         {
573                 .code = (BPF_LDX | BPF_MEM | BPF_W),
574                 .dst_reg = EBPF_REG_2,
575                 .src_reg = EBPF_REG_1,
576                 .off = offsetof(struct dummy_vect8, in[0].u32),
577         },
578         {
579                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
580                 .dst_reg = EBPF_REG_3,
581                 .src_reg = EBPF_REG_1,
582                 .off = offsetof(struct dummy_vect8, in[1].u64),
583         },
584         {
585                 .code = (BPF_LDX | BPF_MEM | BPF_W),
586                 .dst_reg = EBPF_REG_4,
587                 .src_reg = EBPF_REG_1,
588                 .off = offsetof(struct dummy_vect8, in[2].u32),
589         },
590         {
591                 .code = (BPF_ALU | BPF_AND | BPF_K),
592                 .dst_reg = EBPF_REG_2,
593                 .imm = sizeof(uint64_t) * CHAR_BIT - 1,
594         },
595         {
596                 .code = (EBPF_ALU64 | EBPF_ARSH | BPF_X),
597                 .dst_reg = EBPF_REG_3,
598                 .src_reg = EBPF_REG_2,
599         },
600         {
601                 .code = (BPF_ALU | BPF_AND | BPF_K),
602                 .dst_reg = EBPF_REG_2,
603                 .imm = sizeof(uint32_t) * CHAR_BIT - 1,
604         },
605         {
606                 .code = (BPF_ALU | BPF_LSH | BPF_X),
607                 .dst_reg = EBPF_REG_4,
608                 .src_reg = EBPF_REG_2,
609         },
610         {
611                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
612                 .dst_reg = EBPF_REG_1,
613                 .src_reg = EBPF_REG_4,
614                 .off = offsetof(struct dummy_vect8, out[4].u64),
615         },
616         {
617                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
618                 .dst_reg = EBPF_REG_1,
619                 .src_reg = EBPF_REG_3,
620                 .off = offsetof(struct dummy_vect8, out[5].u64),
621         },
622         /* return 1 */
623         {
624                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
625                 .dst_reg = EBPF_REG_0,
626                 .imm = 1,
627         },
628         {
629                 .code = (BPF_JMP | EBPF_EXIT),
630         },
631 };
632
633 static void
634 test_shift1_prepare(void *arg)
635 {
636         struct dummy_vect8 *dv;
637         uint64_t v;
638
639         dv = arg;
640
641         v = rte_rand();
642
643         memset(dv, 0, sizeof(*dv));
644         dv->in[0].u32 = v;
645         dv->in[1].u64 = v << 12 | v >> 6;
646         dv->in[2].u32 = (-v ^ 5);
647 }
648
649 static int
650 test_shift1_check(uint64_t rc, const void *arg)
651 {
652         uint64_t r2, r3, r4;
653         const struct dummy_vect8 *dvt;
654         struct dummy_vect8 dve;
655
656         dvt = arg;
657         memset(&dve, 0, sizeof(dve));
658
659         r2 = dvt->in[0].u32;
660         r3 = dvt->in[1].u64;
661         r4 = dvt->in[2].u32;
662
663         r2 = (uint32_t)r2 << TEST_SHIFT_1;
664         r3 = (int64_t)r3 >> TEST_SHIFT_2;
665
666         dve.out[0].u64 = r2;
667         dve.out[1].u64 = r3;
668
669         r2 = (uint32_t)r2 >> r4;
670         r3 <<= r4;
671
672         dve.out[2].u64 = r2;
673         dve.out[3].u64 = r3;
674
675         r2 = dvt->in[0].u32;
676         r3 = dvt->in[1].u64;
677         r4 = dvt->in[2].u32;
678
679         r2 &= sizeof(uint64_t) * CHAR_BIT - 1;
680         r3 = (int64_t)r3 >> r2;
681         r2 &= sizeof(uint32_t) * CHAR_BIT - 1;
682         r4 = (uint32_t)r4 << r2;
683
684         dve.out[4].u64 = r4;
685         dve.out[5].u64 = r3;
686
687         return cmp_res(__func__, 1, rc, dve.out, dvt->out, sizeof(dve.out));
688 }
689
690 /* jmp test-cases */
691 static const struct ebpf_insn test_jump1_prog[] = {
692
693         [0] = {
694                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
695                 .dst_reg = EBPF_REG_0,
696                 .imm = 0,
697         },
698         [1] = {
699                 .code = (BPF_LDX | BPF_MEM | BPF_W),
700                 .dst_reg = EBPF_REG_2,
701                 .src_reg = EBPF_REG_1,
702                 .off = offsetof(struct dummy_vect8, in[0].u32),
703         },
704         [2] = {
705                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
706                 .dst_reg = EBPF_REG_3,
707                 .src_reg = EBPF_REG_1,
708                 .off = offsetof(struct dummy_vect8, in[0].u64),
709         },
710         [3] = {
711                 .code = (BPF_LDX | BPF_MEM | BPF_W),
712                 .dst_reg = EBPF_REG_4,
713                 .src_reg = EBPF_REG_1,
714                 .off = offsetof(struct dummy_vect8, in[1].u32),
715         },
716         [4] = {
717                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
718                 .dst_reg = EBPF_REG_5,
719                 .src_reg = EBPF_REG_1,
720                 .off = offsetof(struct dummy_vect8, in[1].u64),
721         },
722         [5] = {
723                 .code = (BPF_JMP | BPF_JEQ | BPF_K),
724                 .dst_reg = EBPF_REG_2,
725                 .imm = TEST_JCC_1,
726                 .off = 8,
727         },
728         [6] = {
729                 .code = (BPF_JMP | EBPF_JSLE | BPF_K),
730                 .dst_reg = EBPF_REG_3,
731                 .imm = TEST_JCC_2,
732                 .off = 9,
733         },
734         [7] = {
735                 .code = (BPF_JMP | BPF_JGT | BPF_K),
736                 .dst_reg = EBPF_REG_4,
737                 .imm = TEST_JCC_3,
738                 .off = 10,
739         },
740         [8] = {
741                 .code = (BPF_JMP | BPF_JSET | BPF_K),
742                 .dst_reg = EBPF_REG_5,
743                 .imm = TEST_JCC_4,
744                 .off = 11,
745         },
746         [9] = {
747                 .code = (BPF_JMP | EBPF_JNE | BPF_X),
748                 .dst_reg = EBPF_REG_2,
749                 .src_reg = EBPF_REG_3,
750                 .off = 12,
751         },
752         [10] = {
753                 .code = (BPF_JMP | EBPF_JSGT | BPF_X),
754                 .dst_reg = EBPF_REG_2,
755                 .src_reg = EBPF_REG_4,
756                 .off = 13,
757         },
758         [11] = {
759                 .code = (BPF_JMP | EBPF_JLE | BPF_X),
760                 .dst_reg = EBPF_REG_2,
761                 .src_reg = EBPF_REG_5,
762                 .off = 14,
763         },
764         [12] = {
765                 .code = (BPF_JMP | BPF_JSET | BPF_X),
766                 .dst_reg = EBPF_REG_3,
767                 .src_reg = EBPF_REG_5,
768                 .off = 15,
769         },
770         [13] = {
771                 .code = (BPF_JMP | EBPF_EXIT),
772         },
773         [14] = {
774                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
775                 .dst_reg = EBPF_REG_0,
776                 .imm = 0x1,
777         },
778         [15] = {
779                 .code = (BPF_JMP | BPF_JA),
780                 .off = -10,
781         },
782         [16] = {
783                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
784                 .dst_reg = EBPF_REG_0,
785                 .imm = 0x2,
786         },
787         [17] = {
788                 .code = (BPF_JMP | BPF_JA),
789                 .off = -11,
790         },
791         [18] = {
792                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
793                 .dst_reg = EBPF_REG_0,
794                 .imm = 0x4,
795         },
796         [19] = {
797                 .code = (BPF_JMP | BPF_JA),
798                 .off = -12,
799         },
800         [20] = {
801                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
802                 .dst_reg = EBPF_REG_0,
803                 .imm = 0x8,
804         },
805         [21] = {
806                 .code = (BPF_JMP | BPF_JA),
807                 .off = -13,
808         },
809         [22] = {
810                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
811                 .dst_reg = EBPF_REG_0,
812                 .imm = 0x10,
813         },
814         [23] = {
815                 .code = (BPF_JMP | BPF_JA),
816                 .off = -14,
817         },
818         [24] = {
819                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
820                 .dst_reg = EBPF_REG_0,
821                 .imm = 0x20,
822         },
823         [25] = {
824                 .code = (BPF_JMP | BPF_JA),
825                 .off = -15,
826         },
827         [26] = {
828                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
829                 .dst_reg = EBPF_REG_0,
830                 .imm = 0x40,
831         },
832         [27] = {
833                 .code = (BPF_JMP | BPF_JA),
834                 .off = -16,
835         },
836         [28] = {
837                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
838                 .dst_reg = EBPF_REG_0,
839                 .imm = 0x80,
840         },
841         [29] = {
842                 .code = (BPF_JMP | BPF_JA),
843                 .off = -17,
844         },
845 };
846
847 static void
848 test_jump1_prepare(void *arg)
849 {
850         struct dummy_vect8 *dv;
851         uint64_t v1, v2;
852
853         dv = arg;
854
855         v1 = rte_rand();
856         v2 = rte_rand();
857
858         memset(dv, 0, sizeof(*dv));
859         dv->in[0].u64 = v1;
860         dv->in[1].u64 = v2;
861         dv->in[0].u32 = (v1 << 12) + (v2 >> 6);
862         dv->in[1].u32 = (v2 << 12) - (v1 >> 6);
863 }
864
865 static int
866 test_jump1_check(uint64_t rc, const void *arg)
867 {
868         uint64_t r2, r3, r4, r5, rv;
869         const struct dummy_vect8 *dvt;
870
871         dvt = arg;
872
873         rv = 0;
874         r2 = dvt->in[0].u32;
875         r3 = dvt->in[0].u64;
876         r4 = dvt->in[1].u32;
877         r5 = dvt->in[1].u64;
878
879         if (r2 == TEST_JCC_1)
880                 rv |= 0x1;
881         if ((int64_t)r3 <= TEST_JCC_2)
882                 rv |= 0x2;
883         if (r4 > TEST_JCC_3)
884                 rv |= 0x4;
885         if (r5 & TEST_JCC_4)
886                 rv |= 0x8;
887         if (r2 != r3)
888                 rv |= 0x10;
889         if ((int64_t)r2 > (int64_t)r4)
890                 rv |= 0x20;
891         if (r2 <= r5)
892                 rv |= 0x40;
893         if (r3 & r5)
894                 rv |= 0x80;
895
896         return cmp_res(__func__, rv, rc, &rv, &rc, sizeof(rv));
897 }
898
899 /* Jump test case - check ip4_dest in particular subnet */
900 static const struct ebpf_insn test_jump2_prog[] = {
901
902         [0] = {
903                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
904                 .dst_reg = EBPF_REG_2,
905                 .imm = 0xe,
906         },
907         [1] = {
908                 .code = (BPF_LDX | BPF_MEM | BPF_H),
909                 .dst_reg = EBPF_REG_3,
910                 .src_reg = EBPF_REG_1,
911                 .off = 12,
912         },
913         [2] = {
914                 .code = (BPF_JMP | EBPF_JNE | BPF_K),
915                 .dst_reg = EBPF_REG_3,
916                 .off = 2,
917                 .imm = 0x81,
918         },
919         [3] = {
920                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
921                 .dst_reg = EBPF_REG_2,
922                 .imm = 0x12,
923         },
924         [4] = {
925                 .code = (BPF_LDX | BPF_MEM | BPF_H),
926                 .dst_reg = EBPF_REG_3,
927                 .src_reg = EBPF_REG_1,
928                 .off = 16,
929         },
930         [5] = {
931                 .code = (EBPF_ALU64 | BPF_AND | BPF_K),
932                 .dst_reg = EBPF_REG_3,
933                 .imm = 0xffff,
934         },
935         [6] = {
936                 .code = (BPF_JMP | EBPF_JNE | BPF_K),
937                 .dst_reg = EBPF_REG_3,
938                 .off = 9,
939                 .imm = 0x8,
940         },
941         [7] = {
942                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
943                 .dst_reg = EBPF_REG_1,
944                 .src_reg = EBPF_REG_2,
945         },
946         [8] = {
947                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
948                 .dst_reg = EBPF_REG_0,
949                 .imm = 0,
950         },
951         [9] = {
952                 .code = (BPF_LDX | BPF_MEM | BPF_W),
953                 .dst_reg = EBPF_REG_1,
954                 .src_reg = EBPF_REG_1,
955                 .off = 16,
956         },
957         [10] = {
958                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
959                 .dst_reg = EBPF_REG_3,
960                 .imm = TEST_NETMASK,
961         },
962         [11] = {
963                 .code = (BPF_ALU | EBPF_END | EBPF_TO_BE),
964                 .dst_reg = EBPF_REG_3,
965                 .imm = sizeof(uint32_t) * CHAR_BIT,
966         },
967         [12] = {
968                 .code = (BPF_ALU | BPF_AND | BPF_X),
969                 .dst_reg = EBPF_REG_1,
970                 .src_reg = EBPF_REG_3,
971         },
972         [13] = {
973                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
974                 .dst_reg = EBPF_REG_3,
975                 .imm = TEST_SUBNET,
976         },
977         [14] = {
978                 .code = (BPF_ALU | EBPF_END | EBPF_TO_BE),
979                 .dst_reg = EBPF_REG_3,
980                 .imm = sizeof(uint32_t) * CHAR_BIT,
981         },
982         [15] = {
983                 .code = (BPF_JMP | BPF_JEQ | BPF_X),
984                 .dst_reg = EBPF_REG_1,
985                 .src_reg = EBPF_REG_3,
986                 .off = 1,
987         },
988         [16] = {
989                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
990                 .dst_reg = EBPF_REG_0,
991                 .imm = -1,
992         },
993         [17] = {
994                 .code = (BPF_JMP | EBPF_EXIT),
995         },
996 };
997
998 /* Preparing a vlan packet */
999 static void
1000 test_jump2_prepare(void *arg)
1001 {
1002         struct dummy_net *dn;
1003
1004         dn = arg;
1005         memset(dn, 0, sizeof(*dn));
1006
1007         /*
1008          * Initialize ether header.
1009          */
1010         rte_ether_addr_copy((struct rte_ether_addr *)dst_mac,
1011                             &dn->eth_hdr.d_addr);
1012         rte_ether_addr_copy((struct rte_ether_addr *)src_mac,
1013                             &dn->eth_hdr.s_addr);
1014         dn->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
1015
1016         /*
1017          * Initialize vlan header.
1018          */
1019         dn->vlan_hdr.eth_proto =  rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
1020         dn->vlan_hdr.vlan_tci = 32;
1021
1022         /*
1023          * Initialize IP header.
1024          */
1025         dn->ip_hdr.version_ihl   = 0x45;    /*IP_VERSION | IP_HDRLEN*/
1026         dn->ip_hdr.time_to_live   = 64;   /* IP_DEFTTL */
1027         dn->ip_hdr.next_proto_id = IPPROTO_TCP;
1028         dn->ip_hdr.packet_id = rte_cpu_to_be_16(0x463c);
1029         dn->ip_hdr.total_length   = rte_cpu_to_be_16(60);
1030         dn->ip_hdr.src_addr = rte_cpu_to_be_32(ip_src_addr);
1031         dn->ip_hdr.dst_addr = rte_cpu_to_be_32(ip_dst_addr);
1032 }
1033
1034 static int
1035 test_jump2_check(uint64_t rc, const void *arg)
1036 {
1037         const struct rte_ether_hdr *eth_hdr = arg;
1038         const struct rte_ipv4_hdr *ipv4_hdr;
1039         const void *next = eth_hdr;
1040         uint16_t eth_type;
1041         uint64_t v = -1;
1042
1043         if (eth_hdr->ether_type == htons(0x8100)) {
1044                 const struct rte_vlan_hdr *vlan_hdr =
1045                         (const void *)(eth_hdr + 1);
1046                 eth_type = vlan_hdr->eth_proto;
1047                 next = vlan_hdr + 1;
1048         } else {
1049                 eth_type = eth_hdr->ether_type;
1050                 next = eth_hdr + 1;
1051         }
1052
1053         if (eth_type == htons(0x0800)) {
1054                 ipv4_hdr = next;
1055                 if ((ipv4_hdr->dst_addr & rte_cpu_to_be_32(TEST_NETMASK)) ==
1056                     rte_cpu_to_be_32(TEST_SUBNET)) {
1057                         v = 0;
1058                 }
1059         }
1060
1061         return cmp_res(__func__, v, rc, arg, arg, sizeof(arg));
1062 }
1063
1064 /* alu (add, sub, and, or, xor, neg)  test-cases */
1065 static const struct ebpf_insn test_alu1_prog[] = {
1066
1067         {
1068                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1069                 .dst_reg = EBPF_REG_2,
1070                 .src_reg = EBPF_REG_1,
1071                 .off = offsetof(struct dummy_vect8, in[0].u32),
1072         },
1073         {
1074                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1075                 .dst_reg = EBPF_REG_3,
1076                 .src_reg = EBPF_REG_1,
1077                 .off = offsetof(struct dummy_vect8, in[0].u64),
1078         },
1079         {
1080                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1081                 .dst_reg = EBPF_REG_4,
1082                 .src_reg = EBPF_REG_1,
1083                 .off = offsetof(struct dummy_vect8, in[1].u32),
1084         },
1085         {
1086                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1087                 .dst_reg = EBPF_REG_5,
1088                 .src_reg = EBPF_REG_1,
1089                 .off = offsetof(struct dummy_vect8, in[1].u64),
1090         },
1091         {
1092                 .code = (BPF_ALU | BPF_AND | BPF_K),
1093                 .dst_reg = EBPF_REG_2,
1094                 .imm = TEST_FILL_1,
1095         },
1096         {
1097                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
1098                 .dst_reg = EBPF_REG_3,
1099                 .imm = TEST_FILL_1,
1100         },
1101         {
1102                 .code = (BPF_ALU | BPF_XOR | BPF_K),
1103                 .dst_reg = EBPF_REG_4,
1104                 .imm = TEST_FILL_1,
1105         },
1106         {
1107                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
1108                 .dst_reg = EBPF_REG_5,
1109                 .imm = TEST_FILL_1,
1110         },
1111         {
1112                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1113                 .dst_reg = EBPF_REG_1,
1114                 .src_reg = EBPF_REG_2,
1115                 .off = offsetof(struct dummy_vect8, out[0].u64),
1116         },
1117         {
1118                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1119                 .dst_reg = EBPF_REG_1,
1120                 .src_reg = EBPF_REG_3,
1121                 .off = offsetof(struct dummy_vect8, out[1].u64),
1122         },
1123         {
1124                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1125                 .dst_reg = EBPF_REG_1,
1126                 .src_reg = EBPF_REG_4,
1127                 .off = offsetof(struct dummy_vect8, out[2].u64),
1128         },
1129         {
1130                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1131                 .dst_reg = EBPF_REG_1,
1132                 .src_reg = EBPF_REG_5,
1133                 .off = offsetof(struct dummy_vect8, out[3].u64),
1134         },
1135         {
1136                 .code = (BPF_ALU | BPF_OR | BPF_X),
1137                 .dst_reg = EBPF_REG_2,
1138                 .src_reg = EBPF_REG_3,
1139         },
1140         {
1141                 .code = (EBPF_ALU64 | BPF_XOR | BPF_X),
1142                 .dst_reg = EBPF_REG_3,
1143                 .src_reg = EBPF_REG_4,
1144         },
1145         {
1146                 .code = (BPF_ALU | BPF_SUB | BPF_X),
1147                 .dst_reg = EBPF_REG_4,
1148                 .src_reg = EBPF_REG_5,
1149         },
1150         {
1151                 .code = (EBPF_ALU64 | BPF_AND | BPF_X),
1152                 .dst_reg = EBPF_REG_5,
1153                 .src_reg = EBPF_REG_2,
1154         },
1155         {
1156                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1157                 .dst_reg = EBPF_REG_1,
1158                 .src_reg = EBPF_REG_2,
1159                 .off = offsetof(struct dummy_vect8, out[4].u64),
1160         },
1161         {
1162                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1163                 .dst_reg = EBPF_REG_1,
1164                 .src_reg = EBPF_REG_3,
1165                 .off = offsetof(struct dummy_vect8, out[5].u64),
1166         },
1167         {
1168                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1169                 .dst_reg = EBPF_REG_1,
1170                 .src_reg = EBPF_REG_4,
1171                 .off = offsetof(struct dummy_vect8, out[6].u64),
1172         },
1173         {
1174                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1175                 .dst_reg = EBPF_REG_1,
1176                 .src_reg = EBPF_REG_5,
1177                 .off = offsetof(struct dummy_vect8, out[7].u64),
1178         },
1179         /* return (-r2 + (-r3)) */
1180         {
1181                 .code = (BPF_ALU | BPF_NEG),
1182                 .dst_reg = EBPF_REG_2,
1183         },
1184         {
1185                 .code = (EBPF_ALU64 | BPF_NEG),
1186                 .dst_reg = EBPF_REG_3,
1187         },
1188         {
1189                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1190                 .dst_reg = EBPF_REG_2,
1191                 .src_reg = EBPF_REG_3,
1192         },
1193         {
1194                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
1195                 .dst_reg = EBPF_REG_0,
1196                 .src_reg = EBPF_REG_2,
1197         },
1198         {
1199                 .code = (BPF_JMP | EBPF_EXIT),
1200         },
1201 };
1202
1203 static int
1204 test_alu1_check(uint64_t rc, const void *arg)
1205 {
1206         uint64_t r2, r3, r4, r5, rv;
1207         const struct dummy_vect8 *dvt;
1208         struct dummy_vect8 dve;
1209
1210         dvt = arg;
1211         memset(&dve, 0, sizeof(dve));
1212
1213         r2 = dvt->in[0].u32;
1214         r3 = dvt->in[0].u64;
1215         r4 = dvt->in[1].u32;
1216         r5 = dvt->in[1].u64;
1217
1218         r2 = (uint32_t)r2 & TEST_FILL_1;
1219         r3 |= (int32_t) TEST_FILL_1;
1220         r4 = (uint32_t)r4 ^ TEST_FILL_1;
1221         r5 += (int32_t)TEST_FILL_1;
1222
1223         dve.out[0].u64 = r2;
1224         dve.out[1].u64 = r3;
1225         dve.out[2].u64 = r4;
1226         dve.out[3].u64 = r5;
1227
1228         r2 = (uint32_t)r2 | (uint32_t)r3;
1229         r3 ^= r4;
1230         r4 = (uint32_t)r4 - (uint32_t)r5;
1231         r5 &= r2;
1232
1233         dve.out[4].u64 = r2;
1234         dve.out[5].u64 = r3;
1235         dve.out[6].u64 = r4;
1236         dve.out[7].u64 = r5;
1237
1238         r2 = -(int32_t)r2;
1239         rv = (uint32_t)r2;
1240         r3 = -r3;
1241         rv += r3;
1242
1243         return cmp_res(__func__, rv, rc, dve.out, dvt->out, sizeof(dve.out));
1244 }
1245
1246 /* endianness conversions (BE->LE/LE->BE)  test-cases */
1247 static const struct ebpf_insn test_bele1_prog[] = {
1248
1249         {
1250                 .code = (BPF_LDX | BPF_MEM | BPF_H),
1251                 .dst_reg = EBPF_REG_2,
1252                 .src_reg = EBPF_REG_1,
1253                 .off = offsetof(struct dummy_vect8, in[0].u16),
1254         },
1255         {
1256                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1257                 .dst_reg = EBPF_REG_3,
1258                 .src_reg = EBPF_REG_1,
1259                 .off = offsetof(struct dummy_vect8, in[0].u32),
1260         },
1261         {
1262                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1263                 .dst_reg = EBPF_REG_4,
1264                 .src_reg = EBPF_REG_1,
1265                 .off = offsetof(struct dummy_vect8, in[0].u64),
1266         },
1267         {
1268                 .code = (BPF_ALU | EBPF_END | EBPF_TO_BE),
1269                 .dst_reg = EBPF_REG_2,
1270                 .imm = sizeof(uint16_t) * CHAR_BIT,
1271         },
1272         {
1273                 .code = (BPF_ALU | EBPF_END | EBPF_TO_BE),
1274                 .dst_reg = EBPF_REG_3,
1275                 .imm = sizeof(uint32_t) * CHAR_BIT,
1276         },
1277         {
1278                 .code = (BPF_ALU | EBPF_END | EBPF_TO_BE),
1279                 .dst_reg = EBPF_REG_4,
1280                 .imm = sizeof(uint64_t) * CHAR_BIT,
1281         },
1282         {
1283                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1284                 .dst_reg = EBPF_REG_1,
1285                 .src_reg = EBPF_REG_2,
1286                 .off = offsetof(struct dummy_vect8, out[0].u64),
1287         },
1288         {
1289                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1290                 .dst_reg = EBPF_REG_1,
1291                 .src_reg = EBPF_REG_3,
1292                 .off = offsetof(struct dummy_vect8, out[1].u64),
1293         },
1294         {
1295                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1296                 .dst_reg = EBPF_REG_1,
1297                 .src_reg = EBPF_REG_4,
1298                 .off = offsetof(struct dummy_vect8, out[2].u64),
1299         },
1300         {
1301                 .code = (BPF_LDX | BPF_MEM | BPF_H),
1302                 .dst_reg = EBPF_REG_2,
1303                 .src_reg = EBPF_REG_1,
1304                 .off = offsetof(struct dummy_vect8, in[0].u16),
1305         },
1306         {
1307                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1308                 .dst_reg = EBPF_REG_3,
1309                 .src_reg = EBPF_REG_1,
1310                 .off = offsetof(struct dummy_vect8, in[0].u32),
1311         },
1312         {
1313                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1314                 .dst_reg = EBPF_REG_4,
1315                 .src_reg = EBPF_REG_1,
1316                 .off = offsetof(struct dummy_vect8, in[0].u64),
1317         },
1318         {
1319                 .code = (BPF_ALU | EBPF_END | EBPF_TO_LE),
1320                 .dst_reg = EBPF_REG_2,
1321                 .imm = sizeof(uint16_t) * CHAR_BIT,
1322         },
1323         {
1324                 .code = (BPF_ALU | EBPF_END | EBPF_TO_LE),
1325                 .dst_reg = EBPF_REG_3,
1326                 .imm = sizeof(uint32_t) * CHAR_BIT,
1327         },
1328         {
1329                 .code = (BPF_ALU | EBPF_END | EBPF_TO_LE),
1330                 .dst_reg = EBPF_REG_4,
1331                 .imm = sizeof(uint64_t) * CHAR_BIT,
1332         },
1333         {
1334                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1335                 .dst_reg = EBPF_REG_1,
1336                 .src_reg = EBPF_REG_2,
1337                 .off = offsetof(struct dummy_vect8, out[3].u64),
1338         },
1339         {
1340                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1341                 .dst_reg = EBPF_REG_1,
1342                 .src_reg = EBPF_REG_3,
1343                 .off = offsetof(struct dummy_vect8, out[4].u64),
1344         },
1345         {
1346                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1347                 .dst_reg = EBPF_REG_1,
1348                 .src_reg = EBPF_REG_4,
1349                 .off = offsetof(struct dummy_vect8, out[5].u64),
1350         },
1351         /* return 1 */
1352         {
1353                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
1354                 .dst_reg = EBPF_REG_0,
1355                 .imm = 1,
1356         },
1357         {
1358                 .code = (BPF_JMP | EBPF_EXIT),
1359         },
1360 };
1361
1362 static void
1363 test_bele1_prepare(void *arg)
1364 {
1365         struct dummy_vect8 *dv;
1366
1367         dv = arg;
1368
1369         memset(dv, 0, sizeof(*dv));
1370         dv->in[0].u64 = rte_rand();
1371         dv->in[0].u32 = dv->in[0].u64;
1372         dv->in[0].u16 = dv->in[0].u64;
1373 }
1374
1375 static int
1376 test_bele1_check(uint64_t rc, const void *arg)
1377 {
1378         uint64_t r2, r3, r4;
1379         const struct dummy_vect8 *dvt;
1380         struct dummy_vect8 dve;
1381
1382         dvt = arg;
1383         memset(&dve, 0, sizeof(dve));
1384
1385         r2 = dvt->in[0].u16;
1386         r3 = dvt->in[0].u32;
1387         r4 = dvt->in[0].u64;
1388
1389         r2 =  rte_cpu_to_be_16(r2);
1390         r3 =  rte_cpu_to_be_32(r3);
1391         r4 =  rte_cpu_to_be_64(r4);
1392
1393         dve.out[0].u64 = r2;
1394         dve.out[1].u64 = r3;
1395         dve.out[2].u64 = r4;
1396
1397         r2 = dvt->in[0].u16;
1398         r3 = dvt->in[0].u32;
1399         r4 = dvt->in[0].u64;
1400
1401         r2 =  rte_cpu_to_le_16(r2);
1402         r3 =  rte_cpu_to_le_32(r3);
1403         r4 =  rte_cpu_to_le_64(r4);
1404
1405         dve.out[3].u64 = r2;
1406         dve.out[4].u64 = r3;
1407         dve.out[5].u64 = r4;
1408
1409         return cmp_res(__func__, 1, rc, dve.out, dvt->out, sizeof(dve.out));
1410 }
1411
1412 /* atomic add test-cases */
1413 static const struct ebpf_insn test_xadd1_prog[] = {
1414
1415         {
1416                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1417                 .dst_reg = EBPF_REG_2,
1418                 .imm = 1,
1419         },
1420         {
1421                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1422                 .dst_reg = EBPF_REG_1,
1423                 .src_reg = EBPF_REG_2,
1424                 .off = offsetof(struct dummy_offset, u32),
1425         },
1426         {
1427                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1428                 .dst_reg = EBPF_REG_1,
1429                 .src_reg = EBPF_REG_2,
1430                 .off = offsetof(struct dummy_offset, u64),
1431         },
1432         {
1433                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1434                 .dst_reg = EBPF_REG_3,
1435                 .imm = -1,
1436         },
1437         {
1438                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1439                 .dst_reg = EBPF_REG_1,
1440                 .src_reg = EBPF_REG_3,
1441                 .off = offsetof(struct dummy_offset, u32),
1442         },
1443         {
1444                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1445                 .dst_reg = EBPF_REG_1,
1446                 .src_reg = EBPF_REG_3,
1447                 .off = offsetof(struct dummy_offset, u64),
1448         },
1449         {
1450                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1451                 .dst_reg = EBPF_REG_4,
1452                 .imm = TEST_FILL_1,
1453         },
1454         {
1455                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1456                 .dst_reg = EBPF_REG_1,
1457                 .src_reg = EBPF_REG_4,
1458                 .off = offsetof(struct dummy_offset, u32),
1459         },
1460         {
1461                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1462                 .dst_reg = EBPF_REG_1,
1463                 .src_reg = EBPF_REG_4,
1464                 .off = offsetof(struct dummy_offset, u64),
1465         },
1466         {
1467                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1468                 .dst_reg = EBPF_REG_5,
1469                 .imm = TEST_MUL_1,
1470         },
1471         {
1472                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1473                 .dst_reg = EBPF_REG_1,
1474                 .src_reg = EBPF_REG_5,
1475                 .off = offsetof(struct dummy_offset, u32),
1476         },
1477         {
1478                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1479                 .dst_reg = EBPF_REG_1,
1480                 .src_reg = EBPF_REG_5,
1481                 .off = offsetof(struct dummy_offset, u64),
1482         },
1483         {
1484                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1485                 .dst_reg = EBPF_REG_6,
1486                 .imm = TEST_MUL_2,
1487         },
1488         {
1489                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1490                 .dst_reg = EBPF_REG_1,
1491                 .src_reg = EBPF_REG_6,
1492                 .off = offsetof(struct dummy_offset, u32),
1493         },
1494         {
1495                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1496                 .dst_reg = EBPF_REG_1,
1497                 .src_reg = EBPF_REG_6,
1498                 .off = offsetof(struct dummy_offset, u64),
1499         },
1500         {
1501                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1502                 .dst_reg = EBPF_REG_7,
1503                 .imm = TEST_JCC_2,
1504         },
1505         {
1506                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1507                 .dst_reg = EBPF_REG_1,
1508                 .src_reg = EBPF_REG_7,
1509                 .off = offsetof(struct dummy_offset, u32),
1510         },
1511         {
1512                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1513                 .dst_reg = EBPF_REG_1,
1514                 .src_reg = EBPF_REG_7,
1515                 .off = offsetof(struct dummy_offset, u64),
1516         },
1517         {
1518                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
1519                 .dst_reg = EBPF_REG_8,
1520                 .imm = TEST_JCC_3,
1521         },
1522         {
1523                 .code = (BPF_STX | EBPF_XADD | BPF_W),
1524                 .dst_reg = EBPF_REG_1,
1525                 .src_reg = EBPF_REG_8,
1526                 .off = offsetof(struct dummy_offset, u32),
1527         },
1528         {
1529                 .code = (BPF_STX | EBPF_XADD | EBPF_DW),
1530                 .dst_reg = EBPF_REG_1,
1531                 .src_reg = EBPF_REG_8,
1532                 .off = offsetof(struct dummy_offset, u64),
1533         },
1534         /* return 1 */
1535         {
1536                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
1537                 .dst_reg = EBPF_REG_0,
1538                 .imm = 1,
1539         },
1540         {
1541                 .code = (BPF_JMP | EBPF_EXIT),
1542         },
1543 };
1544
1545 static int
1546 test_xadd1_check(uint64_t rc, const void *arg)
1547 {
1548         uint64_t rv;
1549         const struct dummy_offset *dft;
1550         struct dummy_offset dfe;
1551
1552         dft = arg;
1553         memset(&dfe, 0, sizeof(dfe));
1554
1555         rv = 1;
1556         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1557         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1558
1559         rv = -1;
1560         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1561         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1562
1563         rv = (int32_t)TEST_FILL_1;
1564         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1565         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1566
1567         rv = TEST_MUL_1;
1568         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1569         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1570
1571         rv = TEST_MUL_2;
1572         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1573         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1574
1575         rv = TEST_JCC_2;
1576         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1577         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1578
1579         rv = TEST_JCC_3;
1580         rte_atomic32_add((rte_atomic32_t *)&dfe.u32, rv);
1581         rte_atomic64_add((rte_atomic64_t *)&dfe.u64, rv);
1582
1583         return cmp_res(__func__, 1, rc, &dfe, dft, sizeof(dfe));
1584 }
1585
1586 /* alu div test-cases */
1587 static const struct ebpf_insn test_div1_prog[] = {
1588
1589         {
1590                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1591                 .dst_reg = EBPF_REG_2,
1592                 .src_reg = EBPF_REG_1,
1593                 .off = offsetof(struct dummy_vect8, in[0].u32),
1594         },
1595         {
1596                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1597                 .dst_reg = EBPF_REG_3,
1598                 .src_reg = EBPF_REG_1,
1599                 .off = offsetof(struct dummy_vect8, in[1].u64),
1600         },
1601         {
1602                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1603                 .dst_reg = EBPF_REG_4,
1604                 .src_reg = EBPF_REG_1,
1605                 .off = offsetof(struct dummy_vect8, in[2].u32),
1606         },
1607         {
1608                 .code = (BPF_ALU | BPF_DIV | BPF_K),
1609                 .dst_reg = EBPF_REG_2,
1610                 .imm = TEST_MUL_1,
1611         },
1612         {
1613                 .code = (EBPF_ALU64 | BPF_MOD | BPF_K),
1614                 .dst_reg = EBPF_REG_3,
1615                 .imm = TEST_MUL_2,
1616         },
1617         {
1618                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
1619                 .dst_reg = EBPF_REG_2,
1620                 .imm = 1,
1621         },
1622         {
1623                 .code = (EBPF_ALU64 | BPF_OR | BPF_K),
1624                 .dst_reg = EBPF_REG_3,
1625                 .imm = 1,
1626         },
1627         {
1628                 .code = (BPF_ALU | BPF_MOD | BPF_X),
1629                 .dst_reg = EBPF_REG_4,
1630                 .src_reg = EBPF_REG_2,
1631         },
1632         {
1633                 .code = (EBPF_ALU64 | BPF_DIV | BPF_X),
1634                 .dst_reg = EBPF_REG_4,
1635                 .src_reg = EBPF_REG_3,
1636         },
1637         {
1638                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1639                 .dst_reg = EBPF_REG_1,
1640                 .src_reg = EBPF_REG_2,
1641                 .off = offsetof(struct dummy_vect8, out[0].u64),
1642         },
1643         {
1644                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1645                 .dst_reg = EBPF_REG_1,
1646                 .src_reg = EBPF_REG_3,
1647                 .off = offsetof(struct dummy_vect8, out[1].u64),
1648         },
1649         {
1650                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1651                 .dst_reg = EBPF_REG_1,
1652                 .src_reg = EBPF_REG_4,
1653                 .off = offsetof(struct dummy_vect8, out[2].u64),
1654         },
1655         /* check that we can handle division by zero gracefully. */
1656         {
1657                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1658                 .dst_reg = EBPF_REG_2,
1659                 .src_reg = EBPF_REG_1,
1660                 .off = offsetof(struct dummy_vect8, in[3].u32),
1661         },
1662         {
1663                 .code = (BPF_ALU | BPF_DIV | BPF_X),
1664                 .dst_reg = EBPF_REG_4,
1665                 .src_reg = EBPF_REG_2,
1666         },
1667         /* return 1 */
1668         {
1669                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
1670                 .dst_reg = EBPF_REG_0,
1671                 .imm = 1,
1672         },
1673         {
1674                 .code = (BPF_JMP | EBPF_EXIT),
1675         },
1676 };
1677
1678 static int
1679 test_div1_check(uint64_t rc, const void *arg)
1680 {
1681         uint64_t r2, r3, r4;
1682         const struct dummy_vect8 *dvt;
1683         struct dummy_vect8 dve;
1684
1685         dvt = arg;
1686         memset(&dve, 0, sizeof(dve));
1687
1688         r2 = dvt->in[0].u32;
1689         r3 = dvt->in[1].u64;
1690         r4 = dvt->in[2].u32;
1691
1692         r2 = (uint32_t)r2 / TEST_MUL_1;
1693         r3 %= TEST_MUL_2;
1694         r2 |= 1;
1695         r3 |= 1;
1696         r4 = (uint32_t)(r4 % r2);
1697         r4 /= r3;
1698
1699         dve.out[0].u64 = r2;
1700         dve.out[1].u64 = r3;
1701         dve.out[2].u64 = r4;
1702
1703         /*
1704          * in the test prog we attempted to divide by zero.
1705          * so return value should return 0.
1706          */
1707         return cmp_res(__func__, 0, rc, dve.out, dvt->out, sizeof(dve.out));
1708 }
1709
1710 /* call test-cases */
1711 static const struct ebpf_insn test_call1_prog[] = {
1712
1713         {
1714                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1715                 .dst_reg = EBPF_REG_2,
1716                 .src_reg = EBPF_REG_1,
1717                 .off = offsetof(struct dummy_offset, u32),
1718         },
1719         {
1720                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1721                 .dst_reg = EBPF_REG_3,
1722                 .src_reg = EBPF_REG_1,
1723                 .off = offsetof(struct dummy_offset, u64),
1724         },
1725         {
1726                 .code = (BPF_STX | BPF_MEM | BPF_W),
1727                 .dst_reg = EBPF_REG_10,
1728                 .src_reg = EBPF_REG_2,
1729                 .off = -4,
1730         },
1731         {
1732                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
1733                 .dst_reg = EBPF_REG_10,
1734                 .src_reg = EBPF_REG_3,
1735                 .off = -16,
1736         },
1737         {
1738                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
1739                 .dst_reg = EBPF_REG_2,
1740                 .src_reg = EBPF_REG_10,
1741         },
1742         {
1743                 .code = (EBPF_ALU64 | BPF_SUB | BPF_K),
1744                 .dst_reg = EBPF_REG_2,
1745                 .imm = 4,
1746         },
1747         {
1748                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
1749                 .dst_reg = EBPF_REG_3,
1750                 .src_reg = EBPF_REG_10,
1751         },
1752         {
1753                 .code = (EBPF_ALU64 | BPF_SUB | BPF_K),
1754                 .dst_reg = EBPF_REG_3,
1755                 .imm = 16,
1756         },
1757         {
1758                 .code = (BPF_JMP | EBPF_CALL),
1759                 .imm = 0,
1760         },
1761         {
1762                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1763                 .dst_reg = EBPF_REG_2,
1764                 .src_reg = EBPF_REG_10,
1765                 .off = -4,
1766         },
1767         {
1768                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1769                 .dst_reg = EBPF_REG_0,
1770                 .src_reg = EBPF_REG_10,
1771                 .off = -16
1772         },
1773         {
1774                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1775                 .dst_reg = EBPF_REG_0,
1776                 .src_reg = EBPF_REG_2,
1777         },
1778         {
1779                 .code = (BPF_JMP | EBPF_EXIT),
1780         },
1781 };
1782
1783 static void
1784 dummy_func1(const void *p, uint32_t *v32, uint64_t *v64)
1785 {
1786         const struct dummy_offset *dv;
1787
1788         dv = p;
1789
1790         v32[0] += dv->u16;
1791         v64[0] += dv->u8;
1792 }
1793
1794 static int
1795 test_call1_check(uint64_t rc, const void *arg)
1796 {
1797         uint32_t v32;
1798         uint64_t v64;
1799         const struct dummy_offset *dv;
1800
1801         dv = arg;
1802
1803         v32 = dv->u32;
1804         v64 = dv->u64;
1805         dummy_func1(arg, &v32, &v64);
1806         v64 += v32;
1807
1808         return cmp_res(__func__, v64, rc, dv, dv, sizeof(*dv));
1809 }
1810
1811 static const struct rte_bpf_xsym test_call1_xsym[] = {
1812         {
1813                 .name = RTE_STR(dummy_func1),
1814                 .type = RTE_BPF_XTYPE_FUNC,
1815                 .func = {
1816                         .val = (void *)dummy_func1,
1817                         .nb_args = 3,
1818                         .args = {
1819                                 [0] = {
1820                                         .type = RTE_BPF_ARG_PTR,
1821                                         .size = sizeof(struct dummy_offset),
1822                                 },
1823                                 [1] = {
1824                                         .type = RTE_BPF_ARG_PTR,
1825                                         .size = sizeof(uint32_t),
1826                                 },
1827                                 [2] = {
1828                                         .type = RTE_BPF_ARG_PTR,
1829                                         .size = sizeof(uint64_t),
1830                                 },
1831                         },
1832                 },
1833         },
1834 };
1835
1836 static const struct ebpf_insn test_call2_prog[] = {
1837
1838         {
1839                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
1840                 .dst_reg = EBPF_REG_1,
1841                 .src_reg = EBPF_REG_10,
1842         },
1843         {
1844                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
1845                 .dst_reg = EBPF_REG_1,
1846                 .imm = -(int32_t)sizeof(struct dummy_offset),
1847         },
1848         {
1849                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
1850                 .dst_reg = EBPF_REG_2,
1851                 .src_reg = EBPF_REG_10,
1852         },
1853         {
1854                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
1855                 .dst_reg = EBPF_REG_2,
1856                 .imm = -2 * (int32_t)sizeof(struct dummy_offset),
1857         },
1858         {
1859                 .code = (BPF_JMP | EBPF_CALL),
1860                 .imm = 0,
1861         },
1862         {
1863                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1864                 .dst_reg = EBPF_REG_1,
1865                 .src_reg = EBPF_REG_10,
1866                 .off = -(int32_t)(sizeof(struct dummy_offset) -
1867                         offsetof(struct dummy_offset, u64)),
1868         },
1869         {
1870                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1871                 .dst_reg = EBPF_REG_0,
1872                 .src_reg = EBPF_REG_10,
1873                 .off = -(int32_t)(sizeof(struct dummy_offset) -
1874                         offsetof(struct dummy_offset, u32)),
1875         },
1876         {
1877                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1878                 .dst_reg = EBPF_REG_0,
1879                 .src_reg = EBPF_REG_1,
1880         },
1881         {
1882                 .code = (BPF_LDX | BPF_MEM | BPF_H),
1883                 .dst_reg = EBPF_REG_1,
1884                 .src_reg = EBPF_REG_10,
1885                 .off = -(int32_t)(2 * sizeof(struct dummy_offset) -
1886                         offsetof(struct dummy_offset, u16)),
1887         },
1888         {
1889                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1890                 .dst_reg = EBPF_REG_0,
1891                 .src_reg = EBPF_REG_1,
1892         },
1893         {
1894                 .code = (BPF_LDX | BPF_MEM | BPF_B),
1895                 .dst_reg = EBPF_REG_1,
1896                 .src_reg = EBPF_REG_10,
1897                 .off = -(int32_t)(2 * sizeof(struct dummy_offset) -
1898                         offsetof(struct dummy_offset, u8)),
1899         },
1900         {
1901                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1902                 .dst_reg = EBPF_REG_0,
1903                 .src_reg = EBPF_REG_1,
1904         },
1905         {
1906                 .code = (BPF_JMP | EBPF_EXIT),
1907         },
1908
1909 };
1910
1911 static void
1912 dummy_func2(struct dummy_offset *a, struct dummy_offset *b)
1913 {
1914         uint64_t v;
1915
1916         v = 0;
1917         a->u64 = v++;
1918         a->u32 = v++;
1919         a->u16 = v++;
1920         a->u8 = v++;
1921         b->u64 = v++;
1922         b->u32 = v++;
1923         b->u16 = v++;
1924         b->u8 = v++;
1925 }
1926
1927 static int
1928 test_call2_check(uint64_t rc, const void *arg)
1929 {
1930         uint64_t v;
1931         struct dummy_offset a, b;
1932
1933         RTE_SET_USED(arg);
1934
1935         dummy_func2(&a, &b);
1936         v = a.u64 + a.u32 + b.u16 + b.u8;
1937
1938         return cmp_res(__func__, v, rc, arg, arg, 0);
1939 }
1940
1941 static const struct rte_bpf_xsym test_call2_xsym[] = {
1942         {
1943                 .name = RTE_STR(dummy_func2),
1944                 .type = RTE_BPF_XTYPE_FUNC,
1945                 .func = {
1946                         .val = (void *)dummy_func2,
1947                         .nb_args = 2,
1948                         .args = {
1949                                 [0] = {
1950                                         .type = RTE_BPF_ARG_PTR,
1951                                         .size = sizeof(struct dummy_offset),
1952                                 },
1953                                 [1] = {
1954                                         .type = RTE_BPF_ARG_PTR,
1955                                         .size = sizeof(struct dummy_offset),
1956                                 },
1957                         },
1958                 },
1959         },
1960 };
1961
1962 static const struct ebpf_insn test_call3_prog[] = {
1963
1964         {
1965                 .code = (BPF_JMP | EBPF_CALL),
1966                 .imm = 0,
1967         },
1968         {
1969                 .code = (BPF_LDX | BPF_MEM | BPF_B),
1970                 .dst_reg = EBPF_REG_2,
1971                 .src_reg = EBPF_REG_0,
1972                 .off = offsetof(struct dummy_offset, u8),
1973         },
1974         {
1975                 .code = (BPF_LDX | BPF_MEM | BPF_H),
1976                 .dst_reg = EBPF_REG_3,
1977                 .src_reg = EBPF_REG_0,
1978                 .off = offsetof(struct dummy_offset, u16),
1979         },
1980         {
1981                 .code = (BPF_LDX | BPF_MEM | BPF_W),
1982                 .dst_reg = EBPF_REG_4,
1983                 .src_reg = EBPF_REG_0,
1984                 .off = offsetof(struct dummy_offset, u32),
1985         },
1986         {
1987                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
1988                 .dst_reg = EBPF_REG_0,
1989                 .src_reg = EBPF_REG_0,
1990                 .off = offsetof(struct dummy_offset, u64),
1991         },
1992         /* return sum */
1993         {
1994                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
1995                 .dst_reg = EBPF_REG_0,
1996                 .src_reg = EBPF_REG_4,
1997         },
1998         {
1999                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2000                 .dst_reg = EBPF_REG_0,
2001                 .src_reg = EBPF_REG_3,
2002         },
2003         {
2004                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2005                 .dst_reg = EBPF_REG_0,
2006                 .src_reg = EBPF_REG_2,
2007         },
2008         {
2009                 .code = (BPF_JMP | EBPF_EXIT),
2010         },
2011 };
2012
2013 static const struct dummy_offset *
2014 dummy_func3(const struct dummy_vect8 *p)
2015 {
2016         return &p->in[RTE_DIM(p->in) - 1];
2017 }
2018
2019 static void
2020 test_call3_prepare(void *arg)
2021 {
2022         struct dummy_vect8 *pv;
2023         struct dummy_offset *df;
2024
2025         pv = arg;
2026         df = (struct dummy_offset *)(uintptr_t)dummy_func3(pv);
2027
2028         memset(pv, 0, sizeof(*pv));
2029         df->u64 = (int32_t)TEST_FILL_1;
2030         df->u32 = df->u64;
2031         df->u16 = df->u64;
2032         df->u8 = df->u64;
2033 }
2034
2035 static int
2036 test_call3_check(uint64_t rc, const void *arg)
2037 {
2038         uint64_t v;
2039         const struct dummy_vect8 *pv;
2040         const struct dummy_offset *dft;
2041
2042         pv = arg;
2043         dft = dummy_func3(pv);
2044
2045         v = dft->u64;
2046         v += dft->u32;
2047         v += dft->u16;
2048         v += dft->u8;
2049
2050         return cmp_res(__func__, v, rc, pv, pv, sizeof(*pv));
2051 }
2052
2053 static const struct rte_bpf_xsym test_call3_xsym[] = {
2054         {
2055                 .name = RTE_STR(dummy_func3),
2056                 .type = RTE_BPF_XTYPE_FUNC,
2057                 .func = {
2058                         .val = (void *)dummy_func3,
2059                         .nb_args = 1,
2060                         .args = {
2061                                 [0] = {
2062                                         .type = RTE_BPF_ARG_PTR,
2063                                         .size = sizeof(struct dummy_vect8),
2064                                 },
2065                         },
2066                         .ret = {
2067                                 .type = RTE_BPF_ARG_PTR,
2068                                 .size = sizeof(struct dummy_offset),
2069                         },
2070                 },
2071         },
2072 };
2073
2074 /* Test for stack corruption in multiple function calls */
2075 static const struct ebpf_insn test_call4_prog[] = {
2076         {
2077                 .code = (BPF_ST | BPF_MEM | BPF_B),
2078                 .dst_reg = EBPF_REG_10,
2079                 .off = -4,
2080                 .imm = 1,
2081         },
2082         {
2083                 .code = (BPF_ST | BPF_MEM | BPF_B),
2084                 .dst_reg = EBPF_REG_10,
2085                 .off = -3,
2086                 .imm = 2,
2087         },
2088         {
2089                 .code = (BPF_ST | BPF_MEM | BPF_B),
2090                 .dst_reg = EBPF_REG_10,
2091                 .off = -2,
2092                 .imm = 3,
2093         },
2094         {
2095                 .code = (BPF_ST | BPF_MEM | BPF_B),
2096                 .dst_reg = EBPF_REG_10,
2097                 .off = -1,
2098                 .imm = 4,
2099         },
2100         {
2101                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2102                 .dst_reg = EBPF_REG_1,
2103                 .src_reg = EBPF_REG_10,
2104         },
2105         {
2106                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
2107                 .dst_reg = EBPF_REG_2,
2108                 .imm = 4,
2109         },
2110         {
2111                 .code = (EBPF_ALU64 | BPF_SUB | BPF_X),
2112                 .dst_reg = EBPF_REG_1,
2113                 .src_reg = EBPF_REG_2,
2114         },
2115         {
2116                 .code = (BPF_JMP | EBPF_CALL),
2117                 .imm = 0,
2118         },
2119         {
2120                 .code = (BPF_LDX | BPF_MEM | BPF_B),
2121                 .dst_reg = EBPF_REG_1,
2122                 .src_reg = EBPF_REG_10,
2123                 .off = -4,
2124         },
2125         {
2126                 .code = (BPF_LDX | BPF_MEM | BPF_B),
2127                 .dst_reg = EBPF_REG_2,
2128                 .src_reg = EBPF_REG_10,
2129                 .off = -3,
2130         },
2131         {
2132                 .code = (BPF_LDX | BPF_MEM | BPF_B),
2133                 .dst_reg = EBPF_REG_3,
2134                 .src_reg = EBPF_REG_10,
2135                 .off = -2,
2136         },
2137         {
2138                 .code = (BPF_LDX | BPF_MEM | BPF_B),
2139                 .dst_reg = EBPF_REG_4,
2140                 .src_reg = EBPF_REG_10,
2141                 .off = -1,
2142         },
2143         {
2144                 .code = (BPF_JMP | EBPF_CALL),
2145                 .imm = 1,
2146         },
2147         {
2148                 .code = (EBPF_ALU64 | BPF_XOR | BPF_K),
2149                 .dst_reg = EBPF_REG_0,
2150                 .imm = TEST_MEMFROB,
2151         },
2152         {
2153                 .code = (BPF_JMP | EBPF_EXIT),
2154         },
2155 };
2156
2157 /* Gathering the bytes together */
2158 static uint32_t
2159 dummy_func4_1(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
2160 {
2161         return (a << 24) | (b << 16) | (c << 8) | (d << 0);
2162 }
2163
2164 /* Implementation of memfrob */
2165 static uint32_t
2166 dummy_func4_0(uint32_t *s, uint8_t n)
2167 {
2168         char *p = (char *) s;
2169         while (n-- > 0)
2170                 *p++ ^= 42;
2171         return *s;
2172 }
2173
2174
2175 static int
2176 test_call4_check(uint64_t rc, const void *arg)
2177 {
2178         uint8_t a[4] = {1, 2, 3, 4};
2179         uint32_t s, v = 0;
2180
2181         RTE_SET_USED(arg);
2182
2183         s = dummy_func4_0((uint32_t *)a, 4);
2184
2185         s = dummy_func4_1(a[0], a[1], a[2], a[3]);
2186
2187         v = s ^ TEST_MEMFROB;
2188
2189         return cmp_res(__func__, v, rc, &v, &rc, sizeof(v));
2190 }
2191
2192 static const struct rte_bpf_xsym test_call4_xsym[] = {
2193         [0] = {
2194                 .name = RTE_STR(dummy_func4_0),
2195                 .type = RTE_BPF_XTYPE_FUNC,
2196                 .func = {
2197                         .val = (void *)dummy_func4_0,
2198                         .nb_args = 2,
2199                         .args = {
2200                                 [0] = {
2201                                         .type = RTE_BPF_ARG_PTR,
2202                                         .size = 4 * sizeof(uint8_t),
2203                                 },
2204                                 [1] = {
2205                                         .type = RTE_BPF_ARG_RAW,
2206                                         .size = sizeof(uint8_t),
2207                                 },
2208                         },
2209                         .ret = {
2210                                 .type = RTE_BPF_ARG_RAW,
2211                                 .size = sizeof(uint32_t),
2212                         },
2213                 },
2214         },
2215         [1] = {
2216                 .name = RTE_STR(dummy_func4_1),
2217                 .type = RTE_BPF_XTYPE_FUNC,
2218                 .func = {
2219                         .val = (void *)dummy_func4_1,
2220                         .nb_args = 4,
2221                         .args = {
2222                                 [0] = {
2223                                         .type = RTE_BPF_ARG_RAW,
2224                                         .size = sizeof(uint8_t),
2225                                 },
2226                                 [1] = {
2227                                         .type = RTE_BPF_ARG_RAW,
2228                                         .size = sizeof(uint8_t),
2229                                 },
2230                                 [2] = {
2231                                         .type = RTE_BPF_ARG_RAW,
2232                                         .size = sizeof(uint8_t),
2233                                 },
2234                                 [3] = {
2235                                         .type = RTE_BPF_ARG_RAW,
2236                                         .size = sizeof(uint8_t),
2237                                 },
2238                         },
2239                         .ret = {
2240                                 .type = RTE_BPF_ARG_RAW,
2241                                 .size = sizeof(uint32_t),
2242                         },
2243                 },
2244         },
2245 };
2246
2247 /* string compare test case */
2248 static const struct ebpf_insn test_call5_prog[] = {
2249
2250         [0] = {
2251                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
2252                 .dst_reg = EBPF_REG_1,
2253                 .imm = STRING_GEEK,
2254         },
2255         [1] = {
2256                 .code = (BPF_STX | BPF_MEM | BPF_W),
2257                 .dst_reg = EBPF_REG_10,
2258                 .src_reg = EBPF_REG_1,
2259                 .off = -8,
2260         },
2261         [2] = {
2262                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
2263                 .dst_reg = EBPF_REG_6,
2264                 .imm = 0,
2265         },
2266         [3] = {
2267                 .code = (BPF_STX | BPF_MEM | BPF_B),
2268                 .dst_reg = EBPF_REG_10,
2269                 .src_reg = EBPF_REG_6,
2270                 .off = -4,
2271         },
2272         [4] = {
2273                 .code = (BPF_STX | BPF_MEM | BPF_W),
2274                 .dst_reg = EBPF_REG_10,
2275                 .src_reg = EBPF_REG_6,
2276                 .off = -12,
2277         },
2278         [5] = {
2279                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
2280                 .dst_reg = EBPF_REG_1,
2281                 .imm = STRING_WEEK,
2282         },
2283         [6] = {
2284                 .code = (BPF_STX | BPF_MEM | BPF_W),
2285                 .dst_reg = EBPF_REG_10,
2286                 .src_reg = EBPF_REG_1,
2287                 .off = -16,
2288         },
2289         [7] = {
2290                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2291                 .dst_reg = EBPF_REG_1,
2292                 .src_reg = EBPF_REG_10,
2293         },
2294         [8] = {
2295                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
2296                 .dst_reg = EBPF_REG_1,
2297                 .imm = -8,
2298         },
2299         [9] = {
2300                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2301                 .dst_reg = EBPF_REG_2,
2302                 .src_reg = EBPF_REG_1,
2303         },
2304         [10] = {
2305                 .code = (BPF_JMP | EBPF_CALL),
2306                 .imm = 0,
2307         },
2308         [11] = {
2309                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2310                 .dst_reg = EBPF_REG_1,
2311                 .src_reg = EBPF_REG_0,
2312         },
2313         [12] = {
2314                 .code = (BPF_ALU | EBPF_MOV | BPF_K),
2315                 .dst_reg = EBPF_REG_0,
2316                 .imm = -1,
2317         },
2318         [13] = {
2319                 .code = (EBPF_ALU64 | BPF_LSH | BPF_K),
2320                 .dst_reg = EBPF_REG_1,
2321                 .imm = 0x20,
2322         },
2323         [14] = {
2324                 .code = (EBPF_ALU64 | BPF_RSH | BPF_K),
2325                 .dst_reg = EBPF_REG_1,
2326                 .imm = 0x20,
2327         },
2328         [15] = {
2329                 .code = (BPF_JMP | EBPF_JNE | BPF_K),
2330                 .dst_reg = EBPF_REG_1,
2331                 .off = 11,
2332                 .imm = 0,
2333         },
2334         [16] = {
2335                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2336                 .dst_reg = EBPF_REG_1,
2337                 .src_reg = EBPF_REG_10,
2338         },
2339         [17] = {
2340                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
2341                 .dst_reg = EBPF_REG_1,
2342                 .imm = -8,
2343         },
2344         [18] = {
2345                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2346                 .dst_reg = EBPF_REG_2,
2347                 .src_reg = EBPF_REG_10,
2348         },
2349         [19] = {
2350                 .code = (EBPF_ALU64 | BPF_ADD | BPF_K),
2351                 .dst_reg = EBPF_REG_2,
2352                 .imm = -16,
2353         },
2354         [20] = {
2355                 .code = (BPF_JMP | EBPF_CALL),
2356                 .imm = 0,
2357         },
2358         [21] = {
2359                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2360                 .dst_reg = EBPF_REG_1,
2361                 .src_reg = EBPF_REG_0,
2362         },
2363         [22] = {
2364                 .code = (EBPF_ALU64 | BPF_LSH | BPF_K),
2365                 .dst_reg = EBPF_REG_1,
2366                 .imm = 0x20,
2367         },
2368         [23] = {
2369                 .code = (EBPF_ALU64 | BPF_RSH | BPF_K),
2370                 .dst_reg = EBPF_REG_1,
2371                 .imm = 0x20,
2372         },
2373         [24] = {
2374                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2375                 .dst_reg = EBPF_REG_0,
2376                 .src_reg = EBPF_REG_1,
2377         },
2378         [25] = {
2379                 .code = (BPF_JMP | BPF_JEQ | BPF_X),
2380                 .dst_reg = EBPF_REG_1,
2381                 .src_reg = EBPF_REG_6,
2382                 .off = 1,
2383         },
2384         [26] = {
2385                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_K),
2386                 .dst_reg = EBPF_REG_0,
2387                 .imm = 0,
2388         },
2389         [27] = {
2390                 .code = (BPF_JMP | EBPF_EXIT),
2391         },
2392 };
2393
2394 /* String comparision impelementation, return 0 if equal else difference */
2395 static uint32_t
2396 dummy_func5(const char *s1, const char *s2)
2397 {
2398         while (*s1 && (*s1 == *s2)) {
2399                 s1++;
2400                 s2++;
2401         }
2402         return *(const unsigned char *)s1 - *(const unsigned char *)s2;
2403 }
2404
2405 static int
2406 test_call5_check(uint64_t rc, const void *arg)
2407 {
2408         char a[] = "geek";
2409         char b[] = "week";
2410         uint32_t v;
2411
2412         RTE_SET_USED(arg);
2413
2414         v = dummy_func5(a, a);
2415         if (v != 0) {
2416                 v = -1;
2417                 goto fail;
2418         }
2419
2420         v = dummy_func5(a, b);
2421         if (v == 0)
2422                 goto fail;
2423
2424         v = 0;
2425
2426 fail:
2427         return cmp_res(__func__, v, rc, &v, &rc, sizeof(v));
2428 }
2429
2430 static const struct rte_bpf_xsym test_call5_xsym[] = {
2431         [0] = {
2432                 .name = RTE_STR(dummy_func5),
2433                 .type = RTE_BPF_XTYPE_FUNC,
2434                 .func = {
2435                         .val = (void *)dummy_func5,
2436                         .nb_args = 2,
2437                         .args = {
2438                                 [0] = {
2439                                         .type = RTE_BPF_ARG_PTR,
2440                                         .size = sizeof(char),
2441                                 },
2442                                 [1] = {
2443                                         .type = RTE_BPF_ARG_PTR,
2444                                         .size = sizeof(char),
2445                                 },
2446                         },
2447                         .ret = {
2448                                 .type = RTE_BPF_ARG_RAW,
2449                                 .size = sizeof(uint32_t),
2450                         },
2451                 },
2452         },
2453 };
2454
2455 /* load mbuf (BPF_ABS/BPF_IND) test-cases */
2456 static const struct ebpf_insn test_ld_mbuf1_prog[] = {
2457
2458         /* BPF_ABS/BPF_IND implicitly expect mbuf ptr in R6 */
2459         {
2460                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2461                 .dst_reg = EBPF_REG_6,
2462                 .src_reg = EBPF_REG_1,
2463         },
2464         /* load IPv4 version and IHL */
2465         {
2466                 .code = (BPF_LD | BPF_ABS | BPF_B),
2467                 .imm = offsetof(struct rte_ipv4_hdr, version_ihl),
2468         },
2469         /* check IP version */
2470         {
2471                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2472                 .dst_reg = EBPF_REG_2,
2473                 .src_reg = EBPF_REG_0,
2474         },
2475         {
2476                 .code = (BPF_ALU | BPF_AND | BPF_K),
2477                 .dst_reg = EBPF_REG_2,
2478                 .imm = 0xf0,
2479         },
2480         {
2481                 .code = (BPF_JMP | BPF_JEQ | BPF_K),
2482                 .dst_reg = EBPF_REG_2,
2483                 .imm = IPVERSION << 4,
2484                 .off = 2,
2485         },
2486         /* invalid IP version, return 0 */
2487         {
2488                 .code = (EBPF_ALU64 | BPF_XOR | BPF_X),
2489                 .dst_reg = EBPF_REG_0,
2490                 .src_reg = EBPF_REG_0,
2491         },
2492         {
2493                 .code = (BPF_JMP | EBPF_EXIT),
2494         },
2495         /* load 3-rd byte of IP data */
2496         {
2497                 .code = (BPF_ALU | BPF_AND | BPF_K),
2498                 .dst_reg = EBPF_REG_0,
2499                 .imm = RTE_IPV4_HDR_IHL_MASK,
2500         },
2501         {
2502                 .code = (BPF_ALU | BPF_LSH | BPF_K),
2503                 .dst_reg = EBPF_REG_0,
2504                 .imm = 2,
2505         },
2506         {
2507                 .code = (BPF_LD | BPF_IND | BPF_B),
2508                 .src_reg = EBPF_REG_0,
2509                 .imm = 3,
2510         },
2511         {
2512                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2513                 .dst_reg = EBPF_REG_7,
2514                 .src_reg = EBPF_REG_0,
2515         },
2516         /* load IPv4 src addr */
2517         {
2518                 .code = (BPF_LD | BPF_ABS | BPF_W),
2519                 .imm = offsetof(struct rte_ipv4_hdr, src_addr),
2520         },
2521         {
2522                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2523                 .dst_reg = EBPF_REG_7,
2524                 .src_reg = EBPF_REG_0,
2525         },
2526         /* load IPv4 total length */
2527         {
2528                 .code = (BPF_LD | BPF_ABS | BPF_H),
2529                 .imm = offsetof(struct rte_ipv4_hdr, total_length),
2530         },
2531         {
2532                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2533                 .dst_reg = EBPF_REG_8,
2534                 .src_reg = EBPF_REG_0,
2535         },
2536         /* load last 4 bytes of IP data */
2537         {
2538                 .code = (BPF_LD | BPF_IND | BPF_W),
2539                 .src_reg = EBPF_REG_8,
2540                 .imm = -(int32_t)sizeof(uint32_t),
2541         },
2542         {
2543                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2544                 .dst_reg = EBPF_REG_7,
2545                 .src_reg = EBPF_REG_0,
2546         },
2547         /* load 2 bytes from the middle of IP data */
2548         {
2549                 .code = (EBPF_ALU64 | BPF_RSH | BPF_K),
2550                 .dst_reg = EBPF_REG_8,
2551                 .imm = 1,
2552         },
2553         {
2554                 .code = (BPF_LD | BPF_IND | BPF_H),
2555                 .src_reg = EBPF_REG_8,
2556         },
2557         {
2558                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2559                 .dst_reg = EBPF_REG_0,
2560                 .src_reg = EBPF_REG_7,
2561         },
2562         {
2563                 .code = (BPF_JMP | EBPF_EXIT),
2564         },
2565 };
2566
2567 static void
2568 dummy_mbuf_prep(struct rte_mbuf *mb, uint8_t buf[], uint32_t buf_len,
2569         uint32_t data_len)
2570 {
2571         uint32_t i;
2572         uint8_t *db;
2573
2574         mb->buf_addr = buf;
2575         mb->buf_iova = (uintptr_t)buf;
2576         mb->buf_len = buf_len;
2577         rte_mbuf_refcnt_set(mb, 1);
2578
2579         /* set pool pointer to dummy value, test doesn't use it */
2580         mb->pool = (void *)buf;
2581
2582         rte_pktmbuf_reset(mb);
2583         db = (uint8_t *)rte_pktmbuf_append(mb, data_len);
2584
2585         for (i = 0; i != data_len; i++)
2586                 db[i] = i;
2587 }
2588
2589 static void
2590 test_ld_mbuf1_prepare(void *arg)
2591 {
2592         struct dummy_mbuf *dm;
2593         struct rte_ipv4_hdr *ph;
2594
2595         const uint32_t plen = 400;
2596         const struct rte_ipv4_hdr iph = {
2597                 .version_ihl = RTE_IPV4_VHL_DEF,
2598                 .total_length = rte_cpu_to_be_16(plen),
2599                 .time_to_live = IPDEFTTL,
2600                 .next_proto_id = IPPROTO_RAW,
2601                 .src_addr = rte_cpu_to_be_32(RTE_IPV4_LOOPBACK),
2602                 .dst_addr = rte_cpu_to_be_32(RTE_IPV4_BROADCAST),
2603         };
2604
2605         dm = arg;
2606         memset(dm, 0, sizeof(*dm));
2607
2608         dummy_mbuf_prep(&dm->mb[0], dm->buf[0], sizeof(dm->buf[0]),
2609                 plen / 2 + 1);
2610         dummy_mbuf_prep(&dm->mb[1], dm->buf[1], sizeof(dm->buf[0]),
2611                 plen / 2 - 1);
2612
2613         rte_pktmbuf_chain(&dm->mb[0], &dm->mb[1]);
2614
2615         ph = rte_pktmbuf_mtod(dm->mb, typeof(ph));
2616         memcpy(ph, &iph, sizeof(iph));
2617 }
2618
2619 static uint64_t
2620 test_ld_mbuf1(const struct rte_mbuf *pkt)
2621 {
2622         uint64_t n, v;
2623         const uint8_t *p8;
2624         const uint16_t *p16;
2625         const uint32_t *p32;
2626         struct dummy_offset dof;
2627
2628         /* load IPv4 version and IHL */
2629         p8 = rte_pktmbuf_read(pkt,
2630                 offsetof(struct rte_ipv4_hdr, version_ihl), sizeof(*p8),
2631                 &dof);
2632         if (p8 == NULL)
2633                 return 0;
2634
2635         /* check IP version */
2636         if ((p8[0] & 0xf0) != IPVERSION << 4)
2637                 return 0;
2638
2639         n = (p8[0] & RTE_IPV4_HDR_IHL_MASK) * RTE_IPV4_IHL_MULTIPLIER;
2640
2641         /* load 3-rd byte of IP data */
2642         p8 = rte_pktmbuf_read(pkt, n + 3, sizeof(*p8), &dof);
2643         if (p8 == NULL)
2644                 return 0;
2645
2646         v = p8[0];
2647
2648         /* load IPv4 src addr */
2649         p32 = rte_pktmbuf_read(pkt,
2650                 offsetof(struct rte_ipv4_hdr, src_addr), sizeof(*p32),
2651                 &dof);
2652         if (p32 == NULL)
2653                 return 0;
2654
2655         v += rte_be_to_cpu_32(p32[0]);
2656
2657         /* load IPv4 total length */
2658         p16 = rte_pktmbuf_read(pkt,
2659                 offsetof(struct rte_ipv4_hdr, total_length), sizeof(*p16),
2660                 &dof);
2661         if (p16 == NULL)
2662                 return 0;
2663
2664         n = rte_be_to_cpu_16(p16[0]);
2665
2666         /* load last 4 bytes of IP data */
2667         p32 = rte_pktmbuf_read(pkt, n - sizeof(*p32), sizeof(*p32), &dof);
2668         if (p32 == NULL)
2669                 return 0;
2670
2671         v += rte_be_to_cpu_32(p32[0]);
2672
2673         /* load 2 bytes from the middle of IP data */
2674         p16 = rte_pktmbuf_read(pkt, n / 2, sizeof(*p16), &dof);
2675         if (p16 == NULL)
2676                 return 0;
2677
2678         v += rte_be_to_cpu_16(p16[0]);
2679         return v;
2680 }
2681
2682 static int
2683 test_ld_mbuf1_check(uint64_t rc, const void *arg)
2684 {
2685         const struct dummy_mbuf *dm;
2686         uint64_t v;
2687
2688         dm = arg;
2689         v = test_ld_mbuf1(dm->mb);
2690         return cmp_res(__func__, v, rc, arg, arg, 0);
2691 }
2692
2693 /*
2694  * same as ld_mbuf1, but then trancate the mbuf by 1B,
2695  * so load of last 4B fail.
2696  */
2697 static void
2698 test_ld_mbuf2_prepare(void *arg)
2699 {
2700         struct dummy_mbuf *dm;
2701
2702         test_ld_mbuf1_prepare(arg);
2703         dm = arg;
2704         rte_pktmbuf_trim(dm->mb, 1);
2705 }
2706
2707 static int
2708 test_ld_mbuf2_check(uint64_t rc, const void *arg)
2709 {
2710         return cmp_res(__func__, 0, rc, arg, arg, 0);
2711 }
2712
2713 /* same as test_ld_mbuf1, but now store intermediate results on the stack */
2714 static const struct ebpf_insn test_ld_mbuf3_prog[] = {
2715
2716         /* BPF_ABS/BPF_IND implicitly expect mbuf ptr in R6 */
2717         {
2718                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2719                 .dst_reg = EBPF_REG_6,
2720                 .src_reg = EBPF_REG_1,
2721         },
2722         /* load IPv4 version and IHL */
2723         {
2724                 .code = (BPF_LD | BPF_ABS | BPF_B),
2725                 .imm = offsetof(struct rte_ipv4_hdr, version_ihl),
2726         },
2727         /* check IP version */
2728         {
2729                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2730                 .dst_reg = EBPF_REG_2,
2731                 .src_reg = EBPF_REG_0,
2732         },
2733         {
2734                 .code = (BPF_ALU | BPF_AND | BPF_K),
2735                 .dst_reg = EBPF_REG_2,
2736                 .imm = 0xf0,
2737         },
2738         {
2739                 .code = (BPF_JMP | BPF_JEQ | BPF_K),
2740                 .dst_reg = EBPF_REG_2,
2741                 .imm = IPVERSION << 4,
2742                 .off = 2,
2743         },
2744         /* invalid IP version, return 0 */
2745         {
2746                 .code = (EBPF_ALU64 | BPF_XOR | BPF_X),
2747                 .dst_reg = EBPF_REG_0,
2748                 .src_reg = EBPF_REG_0,
2749         },
2750         {
2751                 .code = (BPF_JMP | EBPF_EXIT),
2752         },
2753         /* load 3-rd byte of IP data */
2754         {
2755                 .code = (BPF_ALU | BPF_AND | BPF_K),
2756                 .dst_reg = EBPF_REG_0,
2757                 .imm = RTE_IPV4_HDR_IHL_MASK,
2758         },
2759         {
2760                 .code = (BPF_ALU | BPF_LSH | BPF_K),
2761                 .dst_reg = EBPF_REG_0,
2762                 .imm = 2,
2763         },
2764         {
2765                 .code = (BPF_LD | BPF_IND | BPF_B),
2766                 .src_reg = EBPF_REG_0,
2767                 .imm = 3,
2768         },
2769         {
2770                 .code = (BPF_STX | BPF_MEM | BPF_B),
2771                 .dst_reg = EBPF_REG_10,
2772                 .src_reg = EBPF_REG_0,
2773                 .off = (int16_t)(offsetof(struct dummy_offset, u8) -
2774                         sizeof(struct dummy_offset)),
2775         },
2776         /* load IPv4 src addr */
2777         {
2778                 .code = (BPF_LD | BPF_ABS | BPF_W),
2779                 .imm = offsetof(struct rte_ipv4_hdr, src_addr),
2780         },
2781         {
2782                 .code = (BPF_STX | BPF_MEM | BPF_W),
2783                 .dst_reg = EBPF_REG_10,
2784                 .src_reg = EBPF_REG_0,
2785                 .off = (int16_t)(offsetof(struct dummy_offset, u32) -
2786                         sizeof(struct dummy_offset)),
2787         },
2788         /* load IPv4 total length */
2789         {
2790                 .code = (BPF_LD | BPF_ABS | BPF_H),
2791                 .imm = offsetof(struct rte_ipv4_hdr, total_length),
2792         },
2793         {
2794                 .code = (EBPF_ALU64 | EBPF_MOV | BPF_X),
2795                 .dst_reg = EBPF_REG_8,
2796                 .src_reg = EBPF_REG_0,
2797         },
2798         /* load last 4 bytes of IP data */
2799         {
2800                 .code = (BPF_LD | BPF_IND | BPF_W),
2801                 .src_reg = EBPF_REG_8,
2802                 .imm = -(int32_t)sizeof(uint32_t),
2803         },
2804         {
2805                 .code = (BPF_STX | BPF_MEM | EBPF_DW),
2806                 .dst_reg = EBPF_REG_10,
2807                 .src_reg = EBPF_REG_0,
2808                 .off = (int16_t)(offsetof(struct dummy_offset, u64) -
2809                         sizeof(struct dummy_offset)),
2810         },
2811         /* load 2 bytes from the middle of IP data */
2812         {
2813                 .code = (EBPF_ALU64 | BPF_RSH | BPF_K),
2814                 .dst_reg = EBPF_REG_8,
2815                 .imm = 1,
2816         },
2817         {
2818                 .code = (BPF_LD | BPF_IND | BPF_H),
2819                 .src_reg = EBPF_REG_8,
2820         },
2821         {
2822                 .code = (BPF_LDX | BPF_MEM | EBPF_DW),
2823                 .dst_reg = EBPF_REG_1,
2824                 .src_reg = EBPF_REG_10,
2825                 .off = (int16_t)(offsetof(struct dummy_offset, u64) -
2826                         sizeof(struct dummy_offset)),
2827         },
2828         {
2829                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2830                 .dst_reg = EBPF_REG_0,
2831                 .src_reg = EBPF_REG_1,
2832         },
2833         {
2834                 .code = (BPF_LDX | BPF_MEM | BPF_W),
2835                 .dst_reg = EBPF_REG_1,
2836                 .src_reg = EBPF_REG_10,
2837                 .off = (int16_t)(offsetof(struct dummy_offset, u32) -
2838                         sizeof(struct dummy_offset)),
2839         },
2840         {
2841                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2842                 .dst_reg = EBPF_REG_0,
2843                 .src_reg = EBPF_REG_1,
2844         },
2845         {
2846                 .code = (BPF_LDX | BPF_MEM | BPF_B),
2847                 .dst_reg = EBPF_REG_1,
2848                 .src_reg = EBPF_REG_10,
2849                 .off = (int16_t)(offsetof(struct dummy_offset, u8) -
2850                         sizeof(struct dummy_offset)),
2851         },
2852         {
2853                 .code = (EBPF_ALU64 | BPF_ADD | BPF_X),
2854                 .dst_reg = EBPF_REG_0,
2855                 .src_reg = EBPF_REG_1,
2856         },
2857         {
2858                 .code = (BPF_JMP | EBPF_EXIT),
2859         },
2860 };
2861
2862 /* all bpf test cases */
2863 static const struct bpf_test tests[] = {
2864         {
2865                 .name = "test_store1",
2866                 .arg_sz = sizeof(struct dummy_offset),
2867                 .prm = {
2868                         .ins = test_store1_prog,
2869                         .nb_ins = RTE_DIM(test_store1_prog),
2870                         .prog_arg = {
2871                                 .type = RTE_BPF_ARG_PTR,
2872                                 .size = sizeof(struct dummy_offset),
2873                         },
2874                 },
2875                 .prepare = test_store1_prepare,
2876                 .check_result = test_store1_check,
2877         },
2878         {
2879                 .name = "test_store2",
2880                 .arg_sz = sizeof(struct dummy_offset),
2881                 .prm = {
2882                         .ins = test_store2_prog,
2883                         .nb_ins = RTE_DIM(test_store2_prog),
2884                         .prog_arg = {
2885                                 .type = RTE_BPF_ARG_PTR,
2886                                 .size = sizeof(struct dummy_offset),
2887                         },
2888                 },
2889                 .prepare = test_store1_prepare,
2890                 .check_result = test_store1_check,
2891         },
2892         {
2893                 .name = "test_load1",
2894                 .arg_sz = sizeof(struct dummy_offset),
2895                 .prm = {
2896                         .ins = test_load1_prog,
2897                         .nb_ins = RTE_DIM(test_load1_prog),
2898                         .prog_arg = {
2899                                 .type = RTE_BPF_ARG_PTR,
2900                                 .size = sizeof(struct dummy_offset),
2901                         },
2902                 },
2903                 .prepare = test_load1_prepare,
2904                 .check_result = test_load1_check,
2905         },
2906         {
2907                 .name = "test_ldimm1",
2908                 .arg_sz = sizeof(struct dummy_offset),
2909                 .prm = {
2910                         .ins = test_ldimm1_prog,
2911                         .nb_ins = RTE_DIM(test_ldimm1_prog),
2912                         .prog_arg = {
2913                                 .type = RTE_BPF_ARG_PTR,
2914                                 .size = sizeof(struct dummy_offset),
2915                         },
2916                 },
2917                 .prepare = test_store1_prepare,
2918                 .check_result = test_ldimm1_check,
2919         },
2920         {
2921                 .name = "test_mul1",
2922                 .arg_sz = sizeof(struct dummy_vect8),
2923                 .prm = {
2924                         .ins = test_mul1_prog,
2925                         .nb_ins = RTE_DIM(test_mul1_prog),
2926                         .prog_arg = {
2927                                 .type = RTE_BPF_ARG_PTR,
2928                                 .size = sizeof(struct dummy_vect8),
2929                         },
2930                 },
2931                 .prepare = test_mul1_prepare,
2932                 .check_result = test_mul1_check,
2933         },
2934         {
2935                 .name = "test_shift1",
2936                 .arg_sz = sizeof(struct dummy_vect8),
2937                 .prm = {
2938                         .ins = test_shift1_prog,
2939                         .nb_ins = RTE_DIM(test_shift1_prog),
2940                         .prog_arg = {
2941                                 .type = RTE_BPF_ARG_PTR,
2942                                 .size = sizeof(struct dummy_vect8),
2943                         },
2944                 },
2945                 .prepare = test_shift1_prepare,
2946                 .check_result = test_shift1_check,
2947         },
2948         {
2949                 .name = "test_jump1",
2950                 .arg_sz = sizeof(struct dummy_vect8),
2951                 .prm = {
2952                         .ins = test_jump1_prog,
2953                         .nb_ins = RTE_DIM(test_jump1_prog),
2954                         .prog_arg = {
2955                                 .type = RTE_BPF_ARG_PTR,
2956                                 .size = sizeof(struct dummy_vect8),
2957                         },
2958                 },
2959                 .prepare = test_jump1_prepare,
2960                 .check_result = test_jump1_check,
2961         },
2962         {
2963                 .name = "test_jump2",
2964                 .arg_sz = sizeof(struct dummy_net),
2965                 .prm = {
2966                         .ins = test_jump2_prog,
2967                         .nb_ins = RTE_DIM(test_jump2_prog),
2968                         .prog_arg = {
2969                                 .type = RTE_BPF_ARG_PTR,
2970                                 .size = sizeof(struct dummy_net),
2971                         },
2972                 },
2973                 .prepare = test_jump2_prepare,
2974                 .check_result = test_jump2_check,
2975         },
2976         {
2977                 .name = "test_alu1",
2978                 .arg_sz = sizeof(struct dummy_vect8),
2979                 .prm = {
2980                         .ins = test_alu1_prog,
2981                         .nb_ins = RTE_DIM(test_alu1_prog),
2982                         .prog_arg = {
2983                                 .type = RTE_BPF_ARG_PTR,
2984                                 .size = sizeof(struct dummy_vect8),
2985                         },
2986                 },
2987                 .prepare = test_jump1_prepare,
2988                 .check_result = test_alu1_check,
2989         },
2990         {
2991                 .name = "test_bele1",
2992                 .arg_sz = sizeof(struct dummy_vect8),
2993                 .prm = {
2994                         .ins = test_bele1_prog,
2995                         .nb_ins = RTE_DIM(test_bele1_prog),
2996                         .prog_arg = {
2997                                 .type = RTE_BPF_ARG_PTR,
2998                                 .size = sizeof(struct dummy_vect8),
2999                         },
3000                 },
3001                 .prepare = test_bele1_prepare,
3002                 .check_result = test_bele1_check,
3003         },
3004         {
3005                 .name = "test_xadd1",
3006                 .arg_sz = sizeof(struct dummy_offset),
3007                 .prm = {
3008                         .ins = test_xadd1_prog,
3009                         .nb_ins = RTE_DIM(test_xadd1_prog),
3010                         .prog_arg = {
3011                                 .type = RTE_BPF_ARG_PTR,
3012                                 .size = sizeof(struct dummy_offset),
3013                         },
3014                 },
3015                 .prepare = test_store1_prepare,
3016                 .check_result = test_xadd1_check,
3017         },
3018         {
3019                 .name = "test_div1",
3020                 .arg_sz = sizeof(struct dummy_vect8),
3021                 .prm = {
3022                         .ins = test_div1_prog,
3023                         .nb_ins = RTE_DIM(test_div1_prog),
3024                         .prog_arg = {
3025                                 .type = RTE_BPF_ARG_PTR,
3026                                 .size = sizeof(struct dummy_vect8),
3027                         },
3028                 },
3029                 .prepare = test_mul1_prepare,
3030                 .check_result = test_div1_check,
3031         },
3032         {
3033                 .name = "test_call1",
3034                 .arg_sz = sizeof(struct dummy_offset),
3035                 .prm = {
3036                         .ins = test_call1_prog,
3037                         .nb_ins = RTE_DIM(test_call1_prog),
3038                         .prog_arg = {
3039                                 .type = RTE_BPF_ARG_PTR,
3040                                 .size = sizeof(struct dummy_offset),
3041                         },
3042                         .xsym = test_call1_xsym,
3043                         .nb_xsym = RTE_DIM(test_call1_xsym),
3044                 },
3045                 .prepare = test_load1_prepare,
3046                 .check_result = test_call1_check,
3047                 /* for now don't support function calls on 32 bit platform */
3048                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3049         },
3050         {
3051                 .name = "test_call2",
3052                 .arg_sz = sizeof(struct dummy_offset),
3053                 .prm = {
3054                         .ins = test_call2_prog,
3055                         .nb_ins = RTE_DIM(test_call2_prog),
3056                         .prog_arg = {
3057                                 .type = RTE_BPF_ARG_PTR,
3058                                 .size = sizeof(struct dummy_offset),
3059                         },
3060                         .xsym = test_call2_xsym,
3061                         .nb_xsym = RTE_DIM(test_call2_xsym),
3062                 },
3063                 .prepare = test_store1_prepare,
3064                 .check_result = test_call2_check,
3065                 /* for now don't support function calls on 32 bit platform */
3066                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3067         },
3068         {
3069                 .name = "test_call3",
3070                 .arg_sz = sizeof(struct dummy_vect8),
3071                 .prm = {
3072                         .ins = test_call3_prog,
3073                         .nb_ins = RTE_DIM(test_call3_prog),
3074                         .prog_arg = {
3075                                 .type = RTE_BPF_ARG_PTR,
3076                                 .size = sizeof(struct dummy_vect8),
3077                         },
3078                         .xsym = test_call3_xsym,
3079                         .nb_xsym = RTE_DIM(test_call3_xsym),
3080                 },
3081                 .prepare = test_call3_prepare,
3082                 .check_result = test_call3_check,
3083                 /* for now don't support function calls on 32 bit platform */
3084                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3085         },
3086         {
3087                 .name = "test_call4",
3088                 .arg_sz = sizeof(struct dummy_offset),
3089                 .prm = {
3090                         .ins = test_call4_prog,
3091                         .nb_ins = RTE_DIM(test_call4_prog),
3092                         .prog_arg = {
3093                                 .type = RTE_BPF_ARG_PTR,
3094                                 .size = 2 * sizeof(struct dummy_offset),
3095                         },
3096                         .xsym = test_call4_xsym,
3097                         .nb_xsym = RTE_DIM(test_call4_xsym),
3098                 },
3099                 .prepare = test_store1_prepare,
3100                 .check_result = test_call4_check,
3101                 /* for now don't support function calls on 32 bit platform */
3102                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3103         },
3104         {
3105                 .name = "test_call5",
3106                 .arg_sz = sizeof(struct dummy_offset),
3107                 .prm = {
3108                         .ins = test_call5_prog,
3109                         .nb_ins = RTE_DIM(test_call5_prog),
3110                         .prog_arg = {
3111                                 .type = RTE_BPF_ARG_PTR,
3112                                 .size = sizeof(struct dummy_offset),
3113                         },
3114                         .xsym = test_call5_xsym,
3115                         .nb_xsym = RTE_DIM(test_call5_xsym),
3116                 },
3117                 .prepare = test_store1_prepare,
3118                 .check_result = test_call5_check,
3119                 /* for now don't support function calls on 32 bit platform */
3120                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3121         },
3122         {
3123                 .name = "test_ld_mbuf1",
3124                 .arg_sz = sizeof(struct dummy_mbuf),
3125                 .prm = {
3126                         .ins = test_ld_mbuf1_prog,
3127                         .nb_ins = RTE_DIM(test_ld_mbuf1_prog),
3128                         .prog_arg = {
3129                                 .type = RTE_BPF_ARG_PTR_MBUF,
3130                                 .buf_size = sizeof(struct dummy_mbuf),
3131                         },
3132                 },
3133                 .prepare = test_ld_mbuf1_prepare,
3134                 .check_result = test_ld_mbuf1_check,
3135                 /* mbuf as input argument is not supported on 32 bit platform */
3136                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3137         },
3138         {
3139                 .name = "test_ld_mbuf2",
3140                 .arg_sz = sizeof(struct dummy_mbuf),
3141                 .prm = {
3142                         .ins = test_ld_mbuf1_prog,
3143                         .nb_ins = RTE_DIM(test_ld_mbuf1_prog),
3144                         .prog_arg = {
3145                                 .type = RTE_BPF_ARG_PTR_MBUF,
3146                                 .buf_size = sizeof(struct dummy_mbuf),
3147                         },
3148                 },
3149                 .prepare = test_ld_mbuf2_prepare,
3150                 .check_result = test_ld_mbuf2_check,
3151                 /* mbuf as input argument is not supported on 32 bit platform */
3152                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3153         },
3154         {
3155                 .name = "test_ld_mbuf3",
3156                 .arg_sz = sizeof(struct dummy_mbuf),
3157                 .prm = {
3158                         .ins = test_ld_mbuf3_prog,
3159                         .nb_ins = RTE_DIM(test_ld_mbuf3_prog),
3160                         .prog_arg = {
3161                                 .type = RTE_BPF_ARG_PTR_MBUF,
3162                                 .buf_size = sizeof(struct dummy_mbuf),
3163                         },
3164                 },
3165                 .prepare = test_ld_mbuf1_prepare,
3166                 .check_result = test_ld_mbuf1_check,
3167                 /* mbuf as input argument is not supported on 32 bit platform */
3168                 .allow_fail = (sizeof(uint64_t) != sizeof(uintptr_t)),
3169         },
3170 };
3171
3172 static int
3173 run_test(const struct bpf_test *tst)
3174 {
3175         int32_t ret, rv;
3176         int64_t rc;
3177         struct rte_bpf *bpf;
3178         struct rte_bpf_jit jit;
3179         uint8_t tbuf[tst->arg_sz];
3180
3181         printf("%s(%s) start\n", __func__, tst->name);
3182
3183         bpf = rte_bpf_load(&tst->prm);
3184         if (bpf == NULL) {
3185                 printf("%s@%d: failed to load bpf code, error=%d(%s);\n",
3186                         __func__, __LINE__, rte_errno, strerror(rte_errno));
3187                 return -1;
3188         }
3189
3190         tst->prepare(tbuf);
3191         rc = rte_bpf_exec(bpf, tbuf);
3192         ret = tst->check_result(rc, tbuf);
3193         if (ret != 0) {
3194                 printf("%s@%d: check_result(%s) failed, error: %d(%s);\n",
3195                         __func__, __LINE__, tst->name, ret, strerror(ret));
3196         }
3197
3198         /* repeat the same test with jit, when possible */
3199         rte_bpf_get_jit(bpf, &jit);
3200         if (jit.func != NULL) {
3201
3202                 tst->prepare(tbuf);
3203                 rc = jit.func(tbuf);
3204                 rv = tst->check_result(rc, tbuf);
3205                 ret |= rv;
3206                 if (rv != 0) {
3207                         printf("%s@%d: check_result(%s) failed, "
3208                                 "error: %d(%s);\n",
3209                                 __func__, __LINE__, tst->name,
3210                                 rv, strerror(ret));
3211                 }
3212         }
3213
3214         rte_bpf_destroy(bpf);
3215         return ret;
3216
3217 }
3218
3219 static int
3220 test_bpf(void)
3221 {
3222         int32_t rc, rv;
3223         uint32_t i;
3224
3225         rc = 0;
3226         for (i = 0; i != RTE_DIM(tests); i++) {
3227                 rv = run_test(tests + i);
3228                 if (tests[i].allow_fail == 0)
3229                         rc |= rv;
3230         }
3231
3232         return rc;
3233 }
3234
3235 REGISTER_TEST_COMMAND(bpf_autotest, test_bpf);