acl: fix division by float zero in test app
[dpdk.git] / app / test-acl / main.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <rte_acl.h>
35 #include <getopt.h>
36 #include <string.h>
37
38 #include <rte_cycles.h>
39 #include <rte_per_lcore.h>
40 #include <rte_lcore.h>
41 #include <rte_ip.h>
42
43 #define PRINT_USAGE_START       "%s [EAL options]\n"
44
45 #define RTE_LOGTYPE_TESTACL     RTE_LOGTYPE_USER1
46
47 #define APP_NAME        "TESTACL"
48
49 #define GET_CB_FIELD(in, fd, base, lim, dlm)    do {            \
50         unsigned long val;                                      \
51         char *end_fld;                                          \
52         errno = 0;                                              \
53         val = strtoul((in), &end_fld, (base));                  \
54         if (errno != 0 || end_fld[0] != (dlm) || val > (lim))   \
55                 return -EINVAL;                               \
56         (fd) = (typeof(fd))val;                                 \
57         (in) = end_fld + 1;                                     \
58 } while (0)
59
60 #define OPT_RULE_FILE           "rulesf"
61 #define OPT_TRACE_FILE          "tracef"
62 #define OPT_RULE_NUM            "rulenum"
63 #define OPT_TRACE_NUM           "tracenum"
64 #define OPT_TRACE_STEP          "tracestep"
65 #define OPT_SEARCH_ALG          "alg"
66 #define OPT_BLD_CATEGORIES      "bldcat"
67 #define OPT_RUN_CATEGORIES      "runcat"
68 #define OPT_MAX_SIZE            "maxsize"
69 #define OPT_ITER_NUM            "iter"
70 #define OPT_VERBOSE             "verbose"
71 #define OPT_IPV6                "ipv6"
72
73 #define TRACE_DEFAULT_NUM       0x10000
74 #define TRACE_STEP_MAX          0x1000
75 #define TRACE_STEP_DEF          0x100
76
77 #define RULE_NUM                0x10000
78
79 enum {
80         DUMP_NONE,
81         DUMP_SEARCH,
82         DUMP_PKT,
83         DUMP_MAX
84 };
85
86 struct acl_alg {
87         const char *name;
88         enum rte_acl_classify_alg alg;
89 };
90
91 static const struct acl_alg acl_alg[] = {
92         {
93                 .name = "scalar",
94                 .alg = RTE_ACL_CLASSIFY_SCALAR,
95         },
96         {
97                 .name = "sse",
98                 .alg = RTE_ACL_CLASSIFY_SSE,
99         },
100         {
101                 .name = "avx2",
102                 .alg = RTE_ACL_CLASSIFY_AVX2,
103         },
104         {
105                 .name = "neon",
106                 .alg = RTE_ACL_CLASSIFY_NEON,
107         },
108 };
109
110 static struct {
111         const char         *prgname;
112         const char         *rule_file;
113         const char         *trace_file;
114         size_t              max_size;
115         uint32_t            bld_categories;
116         uint32_t            run_categories;
117         uint32_t            nb_rules;
118         uint32_t            nb_traces;
119         uint32_t            trace_step;
120         uint32_t            trace_sz;
121         uint32_t            iter_num;
122         uint32_t            verbose;
123         uint32_t            ipv6;
124         struct acl_alg      alg;
125         uint32_t            used_traces;
126         void               *traces;
127         struct rte_acl_ctx *acx;
128 } config = {
129         .bld_categories = 3,
130         .run_categories = 1,
131         .nb_rules = RULE_NUM,
132         .nb_traces = TRACE_DEFAULT_NUM,
133         .trace_step = TRACE_STEP_DEF,
134         .iter_num = 1,
135         .verbose = DUMP_MAX,
136         .alg = {
137                 .name = "default",
138                 .alg = RTE_ACL_CLASSIFY_DEFAULT,
139         },
140         .ipv6 = 0
141 };
142
143 static struct rte_acl_param prm = {
144         .name = APP_NAME,
145         .socket_id = SOCKET_ID_ANY,
146 };
147
148 /*
149  * Rule and trace formats definitions.
150  */
151
152 struct ipv4_5tuple {
153         uint8_t  proto;
154         uint32_t ip_src;
155         uint32_t ip_dst;
156         uint16_t port_src;
157         uint16_t port_dst;
158 };
159
160 enum {
161         PROTO_FIELD_IPV4,
162         SRC_FIELD_IPV4,
163         DST_FIELD_IPV4,
164         SRCP_FIELD_IPV4,
165         DSTP_FIELD_IPV4,
166         NUM_FIELDS_IPV4
167 };
168
169 /*
170  * That effectively defines order of IPV4VLAN classifications:
171  *  - PROTO
172  *  - VLAN (TAG and DOMAIN)
173  *  - SRC IP ADDRESS
174  *  - DST IP ADDRESS
175  *  - PORTS (SRC and DST)
176  */
177 enum {
178         RTE_ACL_IPV4VLAN_PROTO,
179         RTE_ACL_IPV4VLAN_VLAN,
180         RTE_ACL_IPV4VLAN_SRC,
181         RTE_ACL_IPV4VLAN_DST,
182         RTE_ACL_IPV4VLAN_PORTS,
183         RTE_ACL_IPV4VLAN_NUM
184 };
185
186 struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
187         {
188                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
189                 .size = sizeof(uint8_t),
190                 .field_index = PROTO_FIELD_IPV4,
191                 .input_index = RTE_ACL_IPV4VLAN_PROTO,
192                 .offset = offsetof(struct ipv4_5tuple, proto),
193         },
194         {
195                 .type = RTE_ACL_FIELD_TYPE_MASK,
196                 .size = sizeof(uint32_t),
197                 .field_index = SRC_FIELD_IPV4,
198                 .input_index = RTE_ACL_IPV4VLAN_SRC,
199                 .offset = offsetof(struct ipv4_5tuple, ip_src),
200         },
201         {
202                 .type = RTE_ACL_FIELD_TYPE_MASK,
203                 .size = sizeof(uint32_t),
204                 .field_index = DST_FIELD_IPV4,
205                 .input_index = RTE_ACL_IPV4VLAN_DST,
206                 .offset = offsetof(struct ipv4_5tuple, ip_dst),
207         },
208         {
209                 .type = RTE_ACL_FIELD_TYPE_RANGE,
210                 .size = sizeof(uint16_t),
211                 .field_index = SRCP_FIELD_IPV4,
212                 .input_index = RTE_ACL_IPV4VLAN_PORTS,
213                 .offset = offsetof(struct ipv4_5tuple, port_src),
214         },
215         {
216                 .type = RTE_ACL_FIELD_TYPE_RANGE,
217                 .size = sizeof(uint16_t),
218                 .field_index = DSTP_FIELD_IPV4,
219                 .input_index = RTE_ACL_IPV4VLAN_PORTS,
220                 .offset = offsetof(struct ipv4_5tuple, port_dst),
221         },
222 };
223
224 #define IPV6_ADDR_LEN   16
225 #define IPV6_ADDR_U16   (IPV6_ADDR_LEN / sizeof(uint16_t))
226 #define IPV6_ADDR_U32   (IPV6_ADDR_LEN / sizeof(uint32_t))
227
228 struct ipv6_5tuple {
229         uint8_t  proto;
230         uint32_t ip_src[IPV6_ADDR_U32];
231         uint32_t ip_dst[IPV6_ADDR_U32];
232         uint16_t port_src;
233         uint16_t port_dst;
234 };
235
236 enum {
237         PROTO_FIELD_IPV6,
238         SRC1_FIELD_IPV6,
239         SRC2_FIELD_IPV6,
240         SRC3_FIELD_IPV6,
241         SRC4_FIELD_IPV6,
242         DST1_FIELD_IPV6,
243         DST2_FIELD_IPV6,
244         DST3_FIELD_IPV6,
245         DST4_FIELD_IPV6,
246         SRCP_FIELD_IPV6,
247         DSTP_FIELD_IPV6,
248         NUM_FIELDS_IPV6
249 };
250
251 struct rte_acl_field_def ipv6_defs[NUM_FIELDS_IPV6] = {
252         {
253                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
254                 .size = sizeof(uint8_t),
255                 .field_index = PROTO_FIELD_IPV6,
256                 .input_index = PROTO_FIELD_IPV6,
257                 .offset = offsetof(struct ipv6_5tuple, proto),
258         },
259         {
260                 .type = RTE_ACL_FIELD_TYPE_MASK,
261                 .size = sizeof(uint32_t),
262                 .field_index = SRC1_FIELD_IPV6,
263                 .input_index = SRC1_FIELD_IPV6,
264                 .offset = offsetof(struct ipv6_5tuple, ip_src[0]),
265         },
266         {
267                 .type = RTE_ACL_FIELD_TYPE_MASK,
268                 .size = sizeof(uint32_t),
269                 .field_index = SRC2_FIELD_IPV6,
270                 .input_index = SRC2_FIELD_IPV6,
271                 .offset = offsetof(struct ipv6_5tuple, ip_src[1]),
272         },
273         {
274                 .type = RTE_ACL_FIELD_TYPE_MASK,
275                 .size = sizeof(uint32_t),
276                 .field_index = SRC3_FIELD_IPV6,
277                 .input_index = SRC3_FIELD_IPV6,
278                 .offset = offsetof(struct ipv6_5tuple, ip_src[2]),
279         },
280         {
281                 .type = RTE_ACL_FIELD_TYPE_MASK,
282                 .size = sizeof(uint32_t),
283                 .field_index = SRC4_FIELD_IPV6,
284                 .input_index = SRC4_FIELD_IPV6,
285                 .offset = offsetof(struct ipv6_5tuple, ip_src[3]),
286         },
287         {
288                 .type = RTE_ACL_FIELD_TYPE_MASK,
289                 .size = sizeof(uint32_t),
290                 .field_index = DST1_FIELD_IPV6,
291                 .input_index = DST1_FIELD_IPV6,
292                 .offset = offsetof(struct ipv6_5tuple, ip_dst[0]),
293         },
294         {
295                 .type = RTE_ACL_FIELD_TYPE_MASK,
296                 .size = sizeof(uint32_t),
297                 .field_index = DST2_FIELD_IPV6,
298                 .input_index = DST2_FIELD_IPV6,
299                 .offset = offsetof(struct ipv6_5tuple, ip_dst[1]),
300         },
301         {
302                 .type = RTE_ACL_FIELD_TYPE_MASK,
303                 .size = sizeof(uint32_t),
304                 .field_index = DST3_FIELD_IPV6,
305                 .input_index = DST3_FIELD_IPV6,
306                 .offset = offsetof(struct ipv6_5tuple, ip_dst[2]),
307         },
308         {
309                 .type = RTE_ACL_FIELD_TYPE_MASK,
310                 .size = sizeof(uint32_t),
311                 .field_index = DST4_FIELD_IPV6,
312                 .input_index = DST4_FIELD_IPV6,
313                 .offset = offsetof(struct ipv6_5tuple, ip_dst[3]),
314         },
315         {
316                 .type = RTE_ACL_FIELD_TYPE_RANGE,
317                 .size = sizeof(uint16_t),
318                 .field_index = SRCP_FIELD_IPV6,
319                 .input_index = SRCP_FIELD_IPV6,
320                 .offset = offsetof(struct ipv6_5tuple, port_src),
321         },
322         {
323                 .type = RTE_ACL_FIELD_TYPE_RANGE,
324                 .size = sizeof(uint16_t),
325                 .field_index = DSTP_FIELD_IPV6,
326                 .input_index = SRCP_FIELD_IPV6,
327                 .offset = offsetof(struct ipv6_5tuple, port_dst),
328         },
329 };
330
331
332 enum {
333         CB_FLD_SRC_ADDR,
334         CB_FLD_DST_ADDR,
335         CB_FLD_SRC_PORT_LOW,
336         CB_FLD_SRC_PORT_DLM,
337         CB_FLD_SRC_PORT_HIGH,
338         CB_FLD_DST_PORT_LOW,
339         CB_FLD_DST_PORT_DLM,
340         CB_FLD_DST_PORT_HIGH,
341         CB_FLD_PROTO,
342         CB_FLD_NUM,
343 };
344
345 enum {
346         CB_TRC_SRC_ADDR,
347         CB_TRC_DST_ADDR,
348         CB_TRC_SRC_PORT,
349         CB_TRC_DST_PORT,
350         CB_TRC_PROTO,
351         CB_TRC_NUM,
352 };
353
354 RTE_ACL_RULE_DEF(acl_rule, RTE_ACL_MAX_FIELDS);
355
356 static const char cb_port_delim[] = ":";
357
358 static char line[LINE_MAX];
359
360 #define dump_verbose(lvl, fh, fmt, args...)     do { \
361         if ((lvl) <= (int32_t)config.verbose)        \
362                 fprintf(fh, fmt, ##args);            \
363 } while (0)
364
365
366 /*
367  * Parse ClassBench input trace (test vectors and expected results) file.
368  * Expected format:
369  * <src_ipv4_addr> <space> <dst_ipv4_addr> <space> \
370  * <src_port> <space> <dst_port> <space> <proto>
371  */
372 static int
373 parse_cb_ipv4_trace(char *str, struct ipv4_5tuple *v)
374 {
375         int i;
376         char *s, *sp, *in[CB_TRC_NUM];
377         static const char *dlm = " \t\n";
378
379         s = str;
380         for (i = 0; i != RTE_DIM(in); i++) {
381                 in[i] = strtok_r(s, dlm, &sp);
382                 if (in[i] == NULL)
383                         return -EINVAL;
384                 s = NULL;
385         }
386
387         GET_CB_FIELD(in[CB_TRC_SRC_ADDR], v->ip_src, 0, UINT32_MAX, 0);
388         GET_CB_FIELD(in[CB_TRC_DST_ADDR], v->ip_dst, 0, UINT32_MAX, 0);
389         GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
390         GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
391         GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
392
393         /* convert to network byte order. */
394         v->ip_src = rte_cpu_to_be_32(v->ip_src);
395         v->ip_dst = rte_cpu_to_be_32(v->ip_dst);
396         v->port_src = rte_cpu_to_be_16(v->port_src);
397         v->port_dst = rte_cpu_to_be_16(v->port_dst);
398
399         return 0;
400 }
401
402 /*
403  * Parses IPV6 address, exepcts the following format:
404  * XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX (where X - is a hexedecimal digit).
405  */
406 static int
407 parse_ipv6_addr(const char *in, const char **end, uint32_t v[IPV6_ADDR_U32],
408         char dlm)
409 {
410         uint32_t addr[IPV6_ADDR_U16];
411
412         GET_CB_FIELD(in, addr[0], 16, UINT16_MAX, ':');
413         GET_CB_FIELD(in, addr[1], 16, UINT16_MAX, ':');
414         GET_CB_FIELD(in, addr[2], 16, UINT16_MAX, ':');
415         GET_CB_FIELD(in, addr[3], 16, UINT16_MAX, ':');
416         GET_CB_FIELD(in, addr[4], 16, UINT16_MAX, ':');
417         GET_CB_FIELD(in, addr[5], 16, UINT16_MAX, ':');
418         GET_CB_FIELD(in, addr[6], 16, UINT16_MAX, ':');
419         GET_CB_FIELD(in, addr[7], 16, UINT16_MAX, dlm);
420
421         *end = in;
422
423         v[0] = (addr[0] << 16) + addr[1];
424         v[1] = (addr[2] << 16) + addr[3];
425         v[2] = (addr[4] << 16) + addr[5];
426         v[3] = (addr[6] << 16) + addr[7];
427
428         return 0;
429 }
430
431 static int
432 parse_cb_ipv6_addr_trace(const char *in, uint32_t v[IPV6_ADDR_U32])
433 {
434         int32_t rc;
435         const char *end;
436
437         rc = parse_ipv6_addr(in, &end, v, 0);
438         if (rc != 0)
439                 return rc;
440
441         v[0] = rte_cpu_to_be_32(v[0]);
442         v[1] = rte_cpu_to_be_32(v[1]);
443         v[2] = rte_cpu_to_be_32(v[2]);
444         v[3] = rte_cpu_to_be_32(v[3]);
445
446         return 0;
447 }
448
449 /*
450  * Parse ClassBench input trace (test vectors and expected results) file.
451  * Expected format:
452  * <src_ipv6_addr> <space> <dst_ipv6_addr> <space> \
453  * <src_port> <space> <dst_port> <space> <proto>
454  */
455 static int
456 parse_cb_ipv6_trace(char *str, struct ipv6_5tuple *v)
457 {
458         int32_t i, rc;
459         char *s, *sp, *in[CB_TRC_NUM];
460         static const char *dlm = " \t\n";
461
462         s = str;
463         for (i = 0; i != RTE_DIM(in); i++) {
464                 in[i] = strtok_r(s, dlm, &sp);
465                 if (in[i] == NULL)
466                         return -EINVAL;
467                 s = NULL;
468         }
469
470         /* get ip6 src address. */
471         rc = parse_cb_ipv6_addr_trace(in[CB_TRC_SRC_ADDR], v->ip_src);
472         if (rc != 0)
473                 return rc;
474
475         /* get ip6 dst address. */
476         rc = parse_cb_ipv6_addr_trace(in[CB_TRC_DST_ADDR], v->ip_dst);
477         if (rc != 0)
478                 return rc;
479
480         GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
481         GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
482         GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
483
484         /* convert to network byte order. */
485         v->port_src = rte_cpu_to_be_16(v->port_src);
486         v->port_dst = rte_cpu_to_be_16(v->port_dst);
487
488         return 0;
489 }
490
491 static void
492 tracef_init(void)
493 {
494         static const char name[] = APP_NAME;
495         FILE *f;
496         size_t sz;
497         uint32_t n;
498         struct ipv4_5tuple *v;
499         struct ipv6_5tuple *w;
500
501         sz = config.nb_traces * (config.ipv6 ? sizeof(*w) : sizeof(*v));
502         config.traces = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE,
503                         SOCKET_ID_ANY);
504         if (config.traces == NULL)
505                 rte_exit(EXIT_FAILURE, "Cannot allocate %zu bytes for "
506                         "requested %u number of trace records\n",
507                         sz, config.nb_traces);
508
509         f = fopen(config.trace_file, "r");
510         if (f == NULL)
511                 rte_exit(-EINVAL, "failed to open file: %s\n",
512                         config.trace_file);
513
514         v = config.traces;
515         w = config.traces;
516         for (n = 0; n != config.nb_traces; n++) {
517
518                 if (fgets(line, sizeof(line), f) == NULL)
519                         break;
520
521                 if (config.ipv6) {
522                         if (parse_cb_ipv6_trace(line, w + n) != 0)
523                                 rte_exit(EXIT_FAILURE,
524                                         "%s: failed to parse ipv6 trace "
525                                         "record at line %u\n",
526                                         config.trace_file, n + 1);
527                 } else {
528                         if (parse_cb_ipv4_trace(line, v + n) != 0)
529                                 rte_exit(EXIT_FAILURE,
530                                         "%s: failed to parse ipv4 trace "
531                                         "record at line %u\n",
532                                         config.trace_file, n + 1);
533                 }
534         }
535
536         config.used_traces = n;
537         fclose(f);
538 }
539
540 static int
541 parse_ipv6_net(const char *in, struct rte_acl_field field[4])
542 {
543         int32_t rc;
544         const char *mp;
545         uint32_t i, m, v[4];
546         const uint32_t nbu32 = sizeof(uint32_t) * CHAR_BIT;
547
548         /* get address. */
549         rc = parse_ipv6_addr(in, &mp, v, '/');
550         if (rc != 0)
551                 return rc;
552
553         /* get mask. */
554         GET_CB_FIELD(mp, m, 0, CHAR_BIT * sizeof(v), 0);
555
556         /* put all together. */
557         for (i = 0; i != RTE_DIM(v); i++) {
558                 if (m >= (i + 1) * nbu32)
559                         field[i].mask_range.u32 = nbu32;
560                 else
561                         field[i].mask_range.u32 = m > (i * nbu32) ?
562                                 m - (i * 32) : 0;
563
564                 field[i].value.u32 = v[i];
565         }
566
567         return 0;
568 }
569
570
571 static int
572 parse_cb_ipv6_rule(char *str, struct acl_rule *v)
573 {
574         int i, rc;
575         char *s, *sp, *in[CB_FLD_NUM];
576         static const char *dlm = " \t\n";
577
578         /*
579          * Skip leading '@'
580          */
581         if (strchr(str, '@') != str)
582                 return -EINVAL;
583
584         s = str + 1;
585
586         for (i = 0; i != RTE_DIM(in); i++) {
587                 in[i] = strtok_r(s, dlm, &sp);
588                 if (in[i] == NULL)
589                         return -EINVAL;
590                 s = NULL;
591         }
592
593         rc = parse_ipv6_net(in[CB_FLD_SRC_ADDR], v->field + SRC1_FIELD_IPV6);
594         if (rc != 0) {
595                 RTE_LOG(ERR, TESTACL,
596                         "failed to read source address/mask: %s\n",
597                         in[CB_FLD_SRC_ADDR]);
598                 return rc;
599         }
600
601         rc = parse_ipv6_net(in[CB_FLD_DST_ADDR], v->field + DST1_FIELD_IPV6);
602         if (rc != 0) {
603                 RTE_LOG(ERR, TESTACL,
604                         "failed to read destination address/mask: %s\n",
605                         in[CB_FLD_DST_ADDR]);
606                 return rc;
607         }
608
609         /* source port. */
610         GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
611                 v->field[SRCP_FIELD_IPV6].value.u16,
612                 0, UINT16_MAX, 0);
613         GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
614                 v->field[SRCP_FIELD_IPV6].mask_range.u16,
615                 0, UINT16_MAX, 0);
616
617         if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
618                         sizeof(cb_port_delim)) != 0)
619                 return -EINVAL;
620
621         /* destination port. */
622         GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
623                 v->field[DSTP_FIELD_IPV6].value.u16,
624                 0, UINT16_MAX, 0);
625         GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
626                 v->field[DSTP_FIELD_IPV6].mask_range.u16,
627                 0, UINT16_MAX, 0);
628
629         if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
630                         sizeof(cb_port_delim)) != 0)
631                 return -EINVAL;
632
633         GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].value.u8,
634                 0, UINT8_MAX, '/');
635         GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].mask_range.u8,
636                 0, UINT8_MAX, 0);
637
638         return 0;
639 }
640
641 static int
642 parse_ipv4_net(const char *in, uint32_t *addr, uint32_t *mask_len)
643 {
644         uint8_t a, b, c, d, m;
645
646         GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
647         GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
648         GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
649         GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
650         GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);
651
652         addr[0] = IPv4(a, b, c, d);
653         mask_len[0] = m;
654
655         return 0;
656 }
657 /*
658  * Parse ClassBench rules file.
659  * Expected format:
660  * '@'<src_ipv4_addr>'/'<masklen> <space> \
661  * <dst_ipv4_addr>'/'<masklen> <space> \
662  * <src_port_low> <space> ":" <src_port_high> <space> \
663  * <dst_port_low> <space> ":" <dst_port_high> <space> \
664  * <proto>'/'<mask>
665  */
666 static int
667 parse_cb_ipv4_rule(char *str, struct acl_rule *v)
668 {
669         int i, rc;
670         char *s, *sp, *in[CB_FLD_NUM];
671         static const char *dlm = " \t\n";
672
673         /*
674          * Skip leading '@'
675          */
676         if (strchr(str, '@') != str)
677                 return -EINVAL;
678
679         s = str + 1;
680
681         for (i = 0; i != RTE_DIM(in); i++) {
682                 in[i] = strtok_r(s, dlm, &sp);
683                 if (in[i] == NULL)
684                         return -EINVAL;
685                 s = NULL;
686         }
687
688         rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
689                         &v->field[SRC_FIELD_IPV4].value.u32,
690                         &v->field[SRC_FIELD_IPV4].mask_range.u32);
691         if (rc != 0) {
692                 RTE_LOG(ERR, TESTACL,
693                         "failed to read source address/mask: %s\n",
694                         in[CB_FLD_SRC_ADDR]);
695                 return rc;
696         }
697
698         rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
699                         &v->field[DST_FIELD_IPV4].value.u32,
700                         &v->field[DST_FIELD_IPV4].mask_range.u32);
701         if (rc != 0) {
702                 RTE_LOG(ERR, TESTACL,
703                         "failed to read destination address/mask: %s\n",
704                         in[CB_FLD_DST_ADDR]);
705                 return rc;
706         }
707
708         /* source port. */
709         GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
710                 v->field[SRCP_FIELD_IPV4].value.u16,
711                 0, UINT16_MAX, 0);
712         GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
713                 v->field[SRCP_FIELD_IPV4].mask_range.u16,
714                 0, UINT16_MAX, 0);
715
716         if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
717                         sizeof(cb_port_delim)) != 0)
718                 return -EINVAL;
719
720         /* destination port. */
721         GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
722                 v->field[DSTP_FIELD_IPV4].value.u16,
723                 0, UINT16_MAX, 0);
724         GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
725                 v->field[DSTP_FIELD_IPV4].mask_range.u16,
726                 0, UINT16_MAX, 0);
727
728         if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
729                         sizeof(cb_port_delim)) != 0)
730                 return -EINVAL;
731
732         GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].value.u8,
733                 0, UINT8_MAX, '/');
734         GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].mask_range.u8,
735                 0, UINT8_MAX, 0);
736
737         return 0;
738 }
739
740 typedef int (*parse_5tuple)(char *text, struct acl_rule *rule);
741
742 static int
743 add_cb_rules(FILE *f, struct rte_acl_ctx *ctx)
744 {
745         int rc;
746         uint32_t n;
747         struct acl_rule v;
748         parse_5tuple parser;
749
750         memset(&v, 0, sizeof(v));
751         parser = (config.ipv6 != 0) ? parse_cb_ipv6_rule : parse_cb_ipv4_rule;
752
753         for (n = 1; fgets(line, sizeof(line), f) != NULL; n++) {
754
755                 rc = parser(line, &v);
756                 if (rc != 0) {
757                         RTE_LOG(ERR, TESTACL, "line %u: parse_cb_ipv4vlan_rule"
758                                 " failed, error code: %d (%s)\n",
759                                 n, rc, strerror(-rc));
760                         return rc;
761                 }
762
763                 v.data.category_mask = RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES,
764                         typeof(v.data.category_mask));
765                 v.data.priority = RTE_ACL_MAX_PRIORITY - n;
766                 v.data.userdata = n;
767
768                 rc = rte_acl_add_rules(ctx, (struct rte_acl_rule *)&v, 1);
769                 if (rc != 0) {
770                         RTE_LOG(ERR, TESTACL, "line %u: failed to add rules "
771                                 "into ACL context, error code: %d (%s)\n",
772                                 n, rc, strerror(-rc));
773                         return rc;
774                 }
775         }
776
777         return 0;
778 }
779
780 static void
781 acx_init(void)
782 {
783         int ret;
784         FILE *f;
785         struct rte_acl_config cfg;
786
787         memset(&cfg, 0, sizeof(cfg));
788
789         /* setup ACL build config. */
790         if (config.ipv6) {
791                 cfg.num_fields = RTE_DIM(ipv6_defs);
792                 memcpy(&cfg.defs, ipv6_defs, sizeof(ipv6_defs));
793         } else {
794                 cfg.num_fields = RTE_DIM(ipv4_defs);
795                 memcpy(&cfg.defs, ipv4_defs, sizeof(ipv4_defs));
796         }
797         cfg.num_categories = config.bld_categories;
798         cfg.max_size = config.max_size;
799
800         /* setup ACL creation parameters. */
801         prm.rule_size = RTE_ACL_RULE_SZ(cfg.num_fields);
802         prm.max_rule_num = config.nb_rules;
803
804         config.acx = rte_acl_create(&prm);
805         if (config.acx == NULL)
806                 rte_exit(rte_errno, "failed to create ACL context\n");
807
808         /* set default classify method for this context. */
809         if (config.alg.alg != RTE_ACL_CLASSIFY_DEFAULT) {
810                 ret = rte_acl_set_ctx_classify(config.acx, config.alg.alg);
811                 if (ret != 0)
812                         rte_exit(ret, "failed to setup %s method "
813                                 "for ACL context\n", config.alg.name);
814         }
815
816         /* add ACL rules. */
817         f = fopen(config.rule_file, "r");
818         if (f == NULL)
819                 rte_exit(-EINVAL, "failed to open file %s\n",
820                         config.rule_file);
821
822         ret = add_cb_rules(f, config.acx);
823         if (ret != 0)
824                 rte_exit(ret, "failed to add rules into ACL context\n");
825
826         fclose(f);
827
828         /* perform build. */
829         ret = rte_acl_build(config.acx, &cfg);
830
831         dump_verbose(DUMP_NONE, stdout,
832                 "rte_acl_build(%u) finished with %d\n",
833                 config.bld_categories, ret);
834
835         rte_acl_dump(config.acx);
836
837         if (ret != 0)
838                 rte_exit(ret, "failed to build search context\n");
839 }
840
841 static uint32_t
842 search_ip5tuples_once(uint32_t categories, uint32_t step, const char *alg)
843 {
844         int ret;
845         uint32_t i, j, k, n, r;
846         const uint8_t *data[step], *v;
847         uint32_t results[step * categories];
848
849         v = config.traces;
850         for (i = 0; i != config.used_traces; i += n) {
851
852                 n = RTE_MIN(step, config.used_traces - i);
853
854                 for (j = 0; j != n; j++) {
855                         data[j] = v;
856                         v += config.trace_sz;
857                 }
858
859                 ret = rte_acl_classify(config.acx, data, results,
860                         n, categories);
861
862                 if (ret != 0)
863                         rte_exit(ret, "classify for ipv%c_5tuples returns %d\n",
864                                 config.ipv6 ? '6' : '4', ret);
865
866                 for (r = 0, j = 0; j != n; j++) {
867                         for (k = 0; k != categories; k++, r++) {
868                                 dump_verbose(DUMP_PKT, stdout,
869                                         "ipv%c_5tuple: %u, category: %u, "
870                                         "result: %u\n",
871                                         config.ipv6 ? '6' : '4',
872                                         i + j + 1, k, results[r] - 1);
873                         }
874
875                 }
876         }
877
878         dump_verbose(DUMP_SEARCH, stdout,
879                 "%s(%u, %u, %s) returns %u\n", __func__,
880                 categories, step, alg, i);
881         return i;
882 }
883
884 static int
885 search_ip5tuples(__attribute__((unused)) void *arg)
886 {
887         uint64_t pkt, start, tm;
888         uint32_t i, lcore;
889
890         lcore = rte_lcore_id();
891         start = rte_rdtsc();
892         pkt = 0;
893
894         for (i = 0; i != config.iter_num; i++) {
895                 pkt += search_ip5tuples_once(config.run_categories,
896                         config.trace_step, config.alg.name);
897         }
898
899         tm = rte_rdtsc() - start;
900         dump_verbose(DUMP_NONE, stdout,
901                 "%s  @lcore %u: %" PRIu32 " iterations, %" PRIu64 " pkts, %"
902                 PRIu32 " categories, %" PRIu64 " cycles, %#Lf cycles/pkt\n",
903                 __func__, lcore, i, pkt, config.run_categories,
904                 tm, (pkt == 0) ? 0 : (long double)tm / pkt);
905
906         return 0;
907 }
908
909 static unsigned long
910 get_ulong_opt(const char *opt, const char *name, size_t min, size_t max)
911 {
912         unsigned long val;
913         char *end;
914
915         errno = 0;
916         val = strtoul(opt, &end, 0);
917         if (errno != 0 || end[0] != 0 || val > max || val < min)
918                 rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
919                         opt, name);
920         return val;
921 }
922
923 static void
924 get_alg_opt(const char *opt, const char *name)
925 {
926         uint32_t i;
927
928         for (i = 0; i != RTE_DIM(acl_alg); i++) {
929                 if (strcmp(opt, acl_alg[i].name) == 0) {
930                         config.alg = acl_alg[i];
931                         return;
932                 }
933         }
934
935         rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
936                 opt, name);
937 }
938
939 static void
940 print_usage(const char *prgname)
941 {
942         uint32_t i, n, rc;
943         char buf[PATH_MAX];
944
945         n = 0;
946         buf[0] = 0;
947
948         for (i = 0; i < RTE_DIM(acl_alg) - 1; i++) {
949                 rc = snprintf(buf + n, sizeof(buf) - n, "%s|",
950                         acl_alg[i].name);
951                 if (rc > sizeof(buf) - n)
952                         break;
953                 n += rc;
954         }
955
956         snprintf(buf + n, sizeof(buf) - n, "%s", acl_alg[i].name);
957
958         fprintf(stdout,
959                 PRINT_USAGE_START
960                 "--" OPT_RULE_FILE "=<rules set file>\n"
961                 "[--" OPT_TRACE_FILE "=<input traces file>]\n"
962                 "[--" OPT_RULE_NUM
963                         "=<maximum number of rules for ACL context>]\n"
964                 "[--" OPT_TRACE_NUM
965                         "=<number of traces to read binary file in>]\n"
966                 "[--" OPT_TRACE_STEP
967                         "=<number of traces to classify per one call>]\n"
968                 "[--" OPT_BLD_CATEGORIES
969                         "=<number of categories to build with>]\n"
970                 "[--" OPT_RUN_CATEGORIES
971                         "=<number of categories to run with> "
972                         "should be either 1 or multiple of %zu, "
973                         "but not greater then %u]\n"
974                 "[--" OPT_MAX_SIZE
975                         "=<size limit (in bytes) for runtime ACL strucutures> "
976                         "leave 0 for default behaviour]\n"
977                 "[--" OPT_ITER_NUM "=<number of iterations to perform>]\n"
978                 "[--" OPT_VERBOSE "=<verbose level>]\n"
979                 "[--" OPT_SEARCH_ALG "=%s]\n"
980                 "[--" OPT_IPV6 "=<IPv6 rules and trace files>]\n",
981                 prgname, RTE_ACL_RESULTS_MULTIPLIER,
982                 (uint32_t)RTE_ACL_MAX_CATEGORIES,
983                 buf);
984 }
985
986 static void
987 dump_config(FILE *f)
988 {
989         fprintf(f, "%s:\n", __func__);
990         fprintf(f, "%s:%s\n", OPT_RULE_FILE, config.rule_file);
991         fprintf(f, "%s:%s\n", OPT_TRACE_FILE, config.trace_file);
992         fprintf(f, "%s:%u\n", OPT_RULE_NUM, config.nb_rules);
993         fprintf(f, "%s:%u\n", OPT_TRACE_NUM, config.nb_traces);
994         fprintf(f, "%s:%u\n", OPT_TRACE_STEP, config.trace_step);
995         fprintf(f, "%s:%u\n", OPT_BLD_CATEGORIES, config.bld_categories);
996         fprintf(f, "%s:%u\n", OPT_RUN_CATEGORIES, config.run_categories);
997         fprintf(f, "%s:%zu\n", OPT_MAX_SIZE, config.max_size);
998         fprintf(f, "%s:%u\n", OPT_ITER_NUM, config.iter_num);
999         fprintf(f, "%s:%u\n", OPT_VERBOSE, config.verbose);
1000         fprintf(f, "%s:%u(%s)\n", OPT_SEARCH_ALG, config.alg.alg,
1001                 config.alg.name);
1002         fprintf(f, "%s:%u\n", OPT_IPV6, config.ipv6);
1003 }
1004
1005 static void
1006 check_config(void)
1007 {
1008         if (config.rule_file == NULL) {
1009                 print_usage(config.prgname);
1010                 rte_exit(-EINVAL, "mandatory option %s is not specified\n",
1011                         OPT_RULE_FILE);
1012         }
1013 }
1014
1015
1016 static void
1017 get_input_opts(int argc, char **argv)
1018 {
1019         static struct option lgopts[] = {
1020                 {OPT_RULE_FILE, 1, 0, 0},
1021                 {OPT_TRACE_FILE, 1, 0, 0},
1022                 {OPT_TRACE_NUM, 1, 0, 0},
1023                 {OPT_RULE_NUM, 1, 0, 0},
1024                 {OPT_MAX_SIZE, 1, 0, 0},
1025                 {OPT_TRACE_STEP, 1, 0, 0},
1026                 {OPT_BLD_CATEGORIES, 1, 0, 0},
1027                 {OPT_RUN_CATEGORIES, 1, 0, 0},
1028                 {OPT_ITER_NUM, 1, 0, 0},
1029                 {OPT_VERBOSE, 1, 0, 0},
1030                 {OPT_SEARCH_ALG, 1, 0, 0},
1031                 {OPT_IPV6, 0, 0, 0},
1032                 {NULL, 0, 0, 0}
1033         };
1034
1035         int opt, opt_idx;
1036
1037         while ((opt = getopt_long(argc, argv, "", lgopts,  &opt_idx)) != EOF) {
1038
1039                 if (opt != 0) {
1040                         print_usage(config.prgname);
1041                         rte_exit(-EINVAL, "unknown option: %c", opt);
1042                 }
1043
1044                 if (strcmp(lgopts[opt_idx].name, OPT_RULE_FILE) == 0) {
1045                         config.rule_file = optarg;
1046                 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_FILE) == 0) {
1047                         config.trace_file = optarg;
1048                 } else if (strcmp(lgopts[opt_idx].name, OPT_RULE_NUM) == 0) {
1049                         config.nb_rules = get_ulong_opt(optarg,
1050                                 lgopts[opt_idx].name, 1, RTE_ACL_MAX_INDEX + 1);
1051                 } else if (strcmp(lgopts[opt_idx].name, OPT_MAX_SIZE) == 0) {
1052                         config.max_size = get_ulong_opt(optarg,
1053                                 lgopts[opt_idx].name, 0, SIZE_MAX);
1054                 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_NUM) == 0) {
1055                         config.nb_traces = get_ulong_opt(optarg,
1056                                 lgopts[opt_idx].name, 1, UINT32_MAX);
1057                 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_STEP) == 0) {
1058                         config.trace_step = get_ulong_opt(optarg,
1059                                 lgopts[opt_idx].name, 1, TRACE_STEP_MAX);
1060                 } else if (strcmp(lgopts[opt_idx].name,
1061                                 OPT_BLD_CATEGORIES) == 0) {
1062                         config.bld_categories = get_ulong_opt(optarg,
1063                                 lgopts[opt_idx].name, 1,
1064                                 RTE_ACL_MAX_CATEGORIES);
1065                 } else if (strcmp(lgopts[opt_idx].name,
1066                                 OPT_RUN_CATEGORIES) == 0) {
1067                         config.run_categories = get_ulong_opt(optarg,
1068                                 lgopts[opt_idx].name, 1,
1069                                 RTE_ACL_MAX_CATEGORIES);
1070                 } else if (strcmp(lgopts[opt_idx].name, OPT_ITER_NUM) == 0) {
1071                         config.iter_num = get_ulong_opt(optarg,
1072                                 lgopts[opt_idx].name, 1, INT32_MAX);
1073                 } else if (strcmp(lgopts[opt_idx].name, OPT_VERBOSE) == 0) {
1074                         config.verbose = get_ulong_opt(optarg,
1075                                 lgopts[opt_idx].name, DUMP_NONE, DUMP_MAX);
1076                 } else if (strcmp(lgopts[opt_idx].name,
1077                                 OPT_SEARCH_ALG) == 0) {
1078                         get_alg_opt(optarg, lgopts[opt_idx].name);
1079                 } else if (strcmp(lgopts[opt_idx].name, OPT_IPV6) == 0) {
1080                         config.ipv6 = 1;
1081                 }
1082         }
1083         config.trace_sz = config.ipv6 ? sizeof(struct ipv6_5tuple) :
1084                                                 sizeof(struct ipv4_5tuple);
1085
1086 }
1087
1088 int
1089 main(int argc, char **argv)
1090 {
1091         int ret;
1092         uint32_t lcore;
1093
1094         ret = rte_eal_init(argc, argv);
1095         if (ret < 0)
1096                 rte_panic("Cannot init EAL\n");
1097
1098         argc -= ret;
1099         argv += ret;
1100
1101         config.prgname = argv[0];
1102
1103         get_input_opts(argc, argv);
1104         dump_config(stdout);
1105         check_config();
1106
1107         acx_init();
1108
1109         if (config.trace_file != NULL)
1110                 tracef_init();
1111
1112         RTE_LCORE_FOREACH_SLAVE(lcore)
1113                  rte_eal_remote_launch(search_ip5tuples, NULL, lcore);
1114
1115         search_ip5tuples(NULL);
1116
1117         rte_eal_mp_wait_lcore();
1118
1119         rte_acl_free(config.acx);
1120         return 0;
1121 }