4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
38 #include <rte_cycles.h>
39 #include <rte_per_lcore.h>
40 #include <rte_lcore.h>
43 #define PRINT_USAGE_START "%s [EAL options]\n"
45 #define RTE_LOGTYPE_TESTACL RTE_LOGTYPE_USER1
47 #define APP_NAME "TESTACL"
49 #define GET_CB_FIELD(in, fd, base, lim, dlm) do { \
53 val = strtoul((in), &end_fld, (base)); \
54 if (errno != 0 || end_fld[0] != (dlm) || val > (lim)) \
56 (fd) = (typeof(fd))val; \
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"
73 #define TRACE_DEFAULT_NUM 0x10000
74 #define TRACE_STEP_MAX 0x1000
75 #define TRACE_STEP_DEF 0x100
77 #define RULE_NUM 0x10000
88 enum rte_acl_classify_alg alg;
91 static const struct acl_alg acl_alg[] = {
94 .alg = RTE_ACL_CLASSIFY_SCALAR,
98 .alg = RTE_ACL_CLASSIFY_SSE,
102 .alg = RTE_ACL_CLASSIFY_AVX2,
108 const char *rule_file;
109 const char *trace_file;
111 uint32_t bld_categories;
112 uint32_t run_categories;
121 uint32_t used_traces;
123 struct rte_acl_ctx *acx;
127 .nb_rules = RULE_NUM,
128 .nb_traces = TRACE_DEFAULT_NUM,
129 .trace_step = TRACE_STEP_DEF,
134 .alg = RTE_ACL_CLASSIFY_DEFAULT,
139 static struct rte_acl_param prm = {
141 .socket_id = SOCKET_ID_ANY,
145 * Rule and trace formats definitions.
166 * That effectively defines order of IPV4VLAN classifications:
168 * - VLAN (TAG and DOMAIN)
171 * - PORTS (SRC and DST)
174 RTE_ACL_IPV4VLAN_PROTO,
175 RTE_ACL_IPV4VLAN_VLAN,
176 RTE_ACL_IPV4VLAN_SRC,
177 RTE_ACL_IPV4VLAN_DST,
178 RTE_ACL_IPV4VLAN_PORTS,
182 struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
184 .type = RTE_ACL_FIELD_TYPE_BITMASK,
185 .size = sizeof(uint8_t),
186 .field_index = PROTO_FIELD_IPV4,
187 .input_index = RTE_ACL_IPV4VLAN_PROTO,
188 .offset = offsetof(struct ipv4_5tuple, proto),
191 .type = RTE_ACL_FIELD_TYPE_MASK,
192 .size = sizeof(uint32_t),
193 .field_index = SRC_FIELD_IPV4,
194 .input_index = RTE_ACL_IPV4VLAN_SRC,
195 .offset = offsetof(struct ipv4_5tuple, ip_src),
198 .type = RTE_ACL_FIELD_TYPE_MASK,
199 .size = sizeof(uint32_t),
200 .field_index = DST_FIELD_IPV4,
201 .input_index = RTE_ACL_IPV4VLAN_DST,
202 .offset = offsetof(struct ipv4_5tuple, ip_dst),
205 .type = RTE_ACL_FIELD_TYPE_RANGE,
206 .size = sizeof(uint16_t),
207 .field_index = SRCP_FIELD_IPV4,
208 .input_index = RTE_ACL_IPV4VLAN_PORTS,
209 .offset = offsetof(struct ipv4_5tuple, port_src),
212 .type = RTE_ACL_FIELD_TYPE_RANGE,
213 .size = sizeof(uint16_t),
214 .field_index = DSTP_FIELD_IPV4,
215 .input_index = RTE_ACL_IPV4VLAN_PORTS,
216 .offset = offsetof(struct ipv4_5tuple, port_dst),
220 #define IPV6_ADDR_LEN 16
221 #define IPV6_ADDR_U16 (IPV6_ADDR_LEN / sizeof(uint16_t))
222 #define IPV6_ADDR_U32 (IPV6_ADDR_LEN / sizeof(uint32_t))
226 uint32_t ip_src[IPV6_ADDR_U32];
227 uint32_t ip_dst[IPV6_ADDR_U32];
247 struct rte_acl_field_def ipv6_defs[NUM_FIELDS_IPV6] = {
249 .type = RTE_ACL_FIELD_TYPE_BITMASK,
250 .size = sizeof(uint8_t),
251 .field_index = PROTO_FIELD_IPV6,
252 .input_index = PROTO_FIELD_IPV6,
253 .offset = offsetof(struct ipv6_5tuple, proto),
256 .type = RTE_ACL_FIELD_TYPE_MASK,
257 .size = sizeof(uint32_t),
258 .field_index = SRC1_FIELD_IPV6,
259 .input_index = SRC1_FIELD_IPV6,
260 .offset = offsetof(struct ipv6_5tuple, ip_src[0]),
263 .type = RTE_ACL_FIELD_TYPE_MASK,
264 .size = sizeof(uint32_t),
265 .field_index = SRC2_FIELD_IPV6,
266 .input_index = SRC2_FIELD_IPV6,
267 .offset = offsetof(struct ipv6_5tuple, ip_src[1]),
270 .type = RTE_ACL_FIELD_TYPE_MASK,
271 .size = sizeof(uint32_t),
272 .field_index = SRC3_FIELD_IPV6,
273 .input_index = SRC3_FIELD_IPV6,
274 .offset = offsetof(struct ipv6_5tuple, ip_src[2]),
277 .type = RTE_ACL_FIELD_TYPE_MASK,
278 .size = sizeof(uint32_t),
279 .field_index = SRC4_FIELD_IPV6,
280 .input_index = SRC4_FIELD_IPV6,
281 .offset = offsetof(struct ipv6_5tuple, ip_src[3]),
284 .type = RTE_ACL_FIELD_TYPE_MASK,
285 .size = sizeof(uint32_t),
286 .field_index = DST1_FIELD_IPV6,
287 .input_index = DST1_FIELD_IPV6,
288 .offset = offsetof(struct ipv6_5tuple, ip_dst[0]),
291 .type = RTE_ACL_FIELD_TYPE_MASK,
292 .size = sizeof(uint32_t),
293 .field_index = DST2_FIELD_IPV6,
294 .input_index = DST2_FIELD_IPV6,
295 .offset = offsetof(struct ipv6_5tuple, ip_dst[1]),
298 .type = RTE_ACL_FIELD_TYPE_MASK,
299 .size = sizeof(uint32_t),
300 .field_index = DST3_FIELD_IPV6,
301 .input_index = DST3_FIELD_IPV6,
302 .offset = offsetof(struct ipv6_5tuple, ip_dst[2]),
305 .type = RTE_ACL_FIELD_TYPE_MASK,
306 .size = sizeof(uint32_t),
307 .field_index = DST4_FIELD_IPV6,
308 .input_index = DST4_FIELD_IPV6,
309 .offset = offsetof(struct ipv6_5tuple, ip_dst[3]),
312 .type = RTE_ACL_FIELD_TYPE_RANGE,
313 .size = sizeof(uint16_t),
314 .field_index = SRCP_FIELD_IPV6,
315 .input_index = SRCP_FIELD_IPV6,
316 .offset = offsetof(struct ipv6_5tuple, port_src),
319 .type = RTE_ACL_FIELD_TYPE_RANGE,
320 .size = sizeof(uint16_t),
321 .field_index = DSTP_FIELD_IPV6,
322 .input_index = SRCP_FIELD_IPV6,
323 .offset = offsetof(struct ipv6_5tuple, port_dst),
333 CB_FLD_SRC_PORT_HIGH,
336 CB_FLD_DST_PORT_HIGH,
350 RTE_ACL_RULE_DEF(acl_rule, RTE_ACL_MAX_FIELDS);
352 static const char cb_port_delim[] = ":";
354 static char line[LINE_MAX];
356 #define dump_verbose(lvl, fh, fmt, args...) do { \
357 if ((lvl) <= (int32_t)config.verbose) \
358 fprintf(fh, fmt, ##args); \
363 * Parse ClassBench input trace (test vectors and expected results) file.
365 * <src_ipv4_addr> <space> <dst_ipv4_addr> <space> \
366 * <src_port> <space> <dst_port> <space> <proto>
369 parse_cb_ipv4_trace(char *str, struct ipv4_5tuple *v)
372 char *s, *sp, *in[CB_TRC_NUM];
373 static const char *dlm = " \t\n";
376 for (i = 0; i != RTE_DIM(in); i++) {
377 in[i] = strtok_r(s, dlm, &sp);
383 GET_CB_FIELD(in[CB_TRC_SRC_ADDR], v->ip_src, 0, UINT32_MAX, 0);
384 GET_CB_FIELD(in[CB_TRC_DST_ADDR], v->ip_dst, 0, UINT32_MAX, 0);
385 GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
386 GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
387 GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
389 /* convert to network byte order. */
390 v->ip_src = rte_cpu_to_be_32(v->ip_src);
391 v->ip_dst = rte_cpu_to_be_32(v->ip_dst);
392 v->port_src = rte_cpu_to_be_16(v->port_src);
393 v->port_dst = rte_cpu_to_be_16(v->port_dst);
399 * Parses IPV6 address, exepcts the following format:
400 * XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX (where X - is a hexedecimal digit).
403 parse_ipv6_addr(const char *in, const char **end, uint32_t v[IPV6_ADDR_U32],
406 uint32_t addr[IPV6_ADDR_U16];
408 GET_CB_FIELD(in, addr[0], 16, UINT16_MAX, ':');
409 GET_CB_FIELD(in, addr[1], 16, UINT16_MAX, ':');
410 GET_CB_FIELD(in, addr[2], 16, UINT16_MAX, ':');
411 GET_CB_FIELD(in, addr[3], 16, UINT16_MAX, ':');
412 GET_CB_FIELD(in, addr[4], 16, UINT16_MAX, ':');
413 GET_CB_FIELD(in, addr[5], 16, UINT16_MAX, ':');
414 GET_CB_FIELD(in, addr[6], 16, UINT16_MAX, ':');
415 GET_CB_FIELD(in, addr[7], 16, UINT16_MAX, dlm);
419 v[0] = (addr[0] << 16) + addr[1];
420 v[1] = (addr[2] << 16) + addr[3];
421 v[2] = (addr[4] << 16) + addr[5];
422 v[3] = (addr[6] << 16) + addr[7];
428 parse_cb_ipv6_addr_trace(const char *in, uint32_t v[IPV6_ADDR_U32])
433 rc = parse_ipv6_addr(in, &end, v, 0);
437 v[0] = rte_cpu_to_be_32(v[0]);
438 v[1] = rte_cpu_to_be_32(v[1]);
439 v[2] = rte_cpu_to_be_32(v[2]);
440 v[3] = rte_cpu_to_be_32(v[3]);
446 * Parse ClassBench input trace (test vectors and expected results) file.
448 * <src_ipv6_addr> <space> <dst_ipv6_addr> <space> \
449 * <src_port> <space> <dst_port> <space> <proto>
452 parse_cb_ipv6_trace(char *str, struct ipv6_5tuple *v)
455 char *s, *sp, *in[CB_TRC_NUM];
456 static const char *dlm = " \t\n";
459 for (i = 0; i != RTE_DIM(in); i++) {
460 in[i] = strtok_r(s, dlm, &sp);
466 /* get ip6 src address. */
467 rc = parse_cb_ipv6_addr_trace(in[CB_TRC_SRC_ADDR], v->ip_src);
471 /* get ip6 dst address. */
472 rc = parse_cb_ipv6_addr_trace(in[CB_TRC_DST_ADDR], v->ip_dst);
476 GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
477 GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
478 GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
480 /* convert to network byte order. */
481 v->port_src = rte_cpu_to_be_16(v->port_src);
482 v->port_dst = rte_cpu_to_be_16(v->port_dst);
490 static const char name[] = APP_NAME;
494 struct ipv4_5tuple *v;
495 struct ipv6_5tuple *w;
497 sz = config.nb_traces * (config.ipv6 ? sizeof(*w) : sizeof(*v));
498 config.traces = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE,
500 if (config.traces == NULL)
501 rte_exit(EXIT_FAILURE, "Cannot allocate %zu bytes for "
502 "requested %u number of trace records\n",
503 sz, config.nb_traces);
505 f = fopen(config.trace_file, "r");
507 rte_exit(-EINVAL, "failed to open file: %s\n",
512 for (n = 0; n != config.nb_traces; n++) {
514 if (fgets(line, sizeof(line), f) == NULL)
518 if (parse_cb_ipv6_trace(line, w + n) != 0)
519 rte_exit(EXIT_FAILURE,
520 "%s: failed to parse ipv6 trace "
521 "record at line %u\n",
522 config.trace_file, n + 1);
524 if (parse_cb_ipv4_trace(line, v + n) != 0)
525 rte_exit(EXIT_FAILURE,
526 "%s: failed to parse ipv4 trace "
527 "record at line %u\n",
528 config.trace_file, n + 1);
532 config.used_traces = n;
537 parse_ipv6_net(const char *in, struct rte_acl_field field[4])
542 const uint32_t nbu32 = sizeof(uint32_t) * CHAR_BIT;
545 rc = parse_ipv6_addr(in, &mp, v, '/');
550 GET_CB_FIELD(mp, m, 0, CHAR_BIT * sizeof(v), 0);
552 /* put all together. */
553 for (i = 0; i != RTE_DIM(v); i++) {
554 if (m >= (i + 1) * nbu32)
555 field[i].mask_range.u32 = nbu32;
557 field[i].mask_range.u32 = m > (i * nbu32) ?
560 field[i].value.u32 = v[i];
568 parse_cb_ipv6_rule(char *str, struct acl_rule *v)
571 char *s, *sp, *in[CB_FLD_NUM];
572 static const char *dlm = " \t\n";
577 if (strchr(str, '@') != str)
582 for (i = 0; i != RTE_DIM(in); i++) {
583 in[i] = strtok_r(s, dlm, &sp);
589 rc = parse_ipv6_net(in[CB_FLD_SRC_ADDR], v->field + SRC1_FIELD_IPV6);
591 RTE_LOG(ERR, TESTACL,
592 "failed to read source address/mask: %s\n",
593 in[CB_FLD_SRC_ADDR]);
597 rc = parse_ipv6_net(in[CB_FLD_DST_ADDR], v->field + DST1_FIELD_IPV6);
599 RTE_LOG(ERR, TESTACL,
600 "failed to read destination address/mask: %s\n",
601 in[CB_FLD_DST_ADDR]);
606 GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
607 v->field[SRCP_FIELD_IPV6].value.u16,
609 GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
610 v->field[SRCP_FIELD_IPV6].mask_range.u16,
613 if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
614 sizeof(cb_port_delim)) != 0)
617 /* destination port. */
618 GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
619 v->field[DSTP_FIELD_IPV6].value.u16,
621 GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
622 v->field[DSTP_FIELD_IPV6].mask_range.u16,
625 if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
626 sizeof(cb_port_delim)) != 0)
629 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].value.u8,
631 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].mask_range.u8,
638 parse_ipv4_net(const char *in, uint32_t *addr, uint32_t *mask_len)
640 uint8_t a, b, c, d, m;
642 GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
643 GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
644 GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
645 GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
646 GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);
648 addr[0] = IPv4(a, b, c, d);
654 * Parse ClassBench rules file.
656 * '@'<src_ipv4_addr>'/'<masklen> <space> \
657 * <dst_ipv4_addr>'/'<masklen> <space> \
658 * <src_port_low> <space> ":" <src_port_high> <space> \
659 * <dst_port_low> <space> ":" <dst_port_high> <space> \
663 parse_cb_ipv4_rule(char *str, struct acl_rule *v)
666 char *s, *sp, *in[CB_FLD_NUM];
667 static const char *dlm = " \t\n";
672 if (strchr(str, '@') != str)
677 for (i = 0; i != RTE_DIM(in); i++) {
678 in[i] = strtok_r(s, dlm, &sp);
684 rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
685 &v->field[SRC_FIELD_IPV4].value.u32,
686 &v->field[SRC_FIELD_IPV4].mask_range.u32);
688 RTE_LOG(ERR, TESTACL,
689 "failed to read source address/mask: %s\n",
690 in[CB_FLD_SRC_ADDR]);
694 rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
695 &v->field[DST_FIELD_IPV4].value.u32,
696 &v->field[DST_FIELD_IPV4].mask_range.u32);
698 RTE_LOG(ERR, TESTACL,
699 "failed to read destination address/mask: %s\n",
700 in[CB_FLD_DST_ADDR]);
705 GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
706 v->field[SRCP_FIELD_IPV4].value.u16,
708 GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
709 v->field[SRCP_FIELD_IPV4].mask_range.u16,
712 if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
713 sizeof(cb_port_delim)) != 0)
716 /* destination port. */
717 GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
718 v->field[DSTP_FIELD_IPV4].value.u16,
720 GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
721 v->field[DSTP_FIELD_IPV4].mask_range.u16,
724 if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
725 sizeof(cb_port_delim)) != 0)
728 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].value.u8,
730 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].mask_range.u8,
736 typedef int (*parse_5tuple)(char *text, struct acl_rule *rule);
739 add_cb_rules(FILE *f, struct rte_acl_ctx *ctx)
746 memset(&v, 0, sizeof(v));
747 parser = (config.ipv6 != 0) ? parse_cb_ipv6_rule : parse_cb_ipv4_rule;
749 for (n = 1; fgets(line, sizeof(line), f) != NULL; n++) {
751 rc = parser(line, &v);
753 RTE_LOG(ERR, TESTACL, "line %u: parse_cb_ipv4vlan_rule"
754 " failed, error code: %d (%s)\n",
755 n, rc, strerror(-rc));
759 v.data.category_mask = RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES,
760 typeof(v.data.category_mask));
761 v.data.priority = RTE_ACL_MAX_PRIORITY - n;
764 rc = rte_acl_add_rules(ctx, (struct rte_acl_rule *)&v, 1);
766 RTE_LOG(ERR, TESTACL, "line %u: failed to add rules "
767 "into ACL context, error code: %d (%s)\n",
768 n, rc, strerror(-rc));
781 struct rte_acl_config cfg;
783 memset(&cfg, 0, sizeof(cfg));
785 /* setup ACL build config. */
787 cfg.num_fields = RTE_DIM(ipv6_defs);
788 memcpy(&cfg.defs, ipv6_defs, sizeof(ipv6_defs));
790 cfg.num_fields = RTE_DIM(ipv4_defs);
791 memcpy(&cfg.defs, ipv4_defs, sizeof(ipv4_defs));
793 cfg.num_categories = config.bld_categories;
794 cfg.max_size = config.max_size;
796 /* setup ACL creation parameters. */
797 prm.rule_size = RTE_ACL_RULE_SZ(cfg.num_fields);
798 prm.max_rule_num = config.nb_rules;
800 config.acx = rte_acl_create(&prm);
801 if (config.acx == NULL)
802 rte_exit(rte_errno, "failed to create ACL context\n");
804 /* set default classify method for this context. */
805 if (config.alg.alg != RTE_ACL_CLASSIFY_DEFAULT) {
806 ret = rte_acl_set_ctx_classify(config.acx, config.alg.alg);
808 rte_exit(ret, "failed to setup %s method "
809 "for ACL context\n", config.alg.name);
813 f = fopen(config.rule_file, "r");
815 rte_exit(-EINVAL, "failed to open file %s\n",
818 ret = add_cb_rules(f, config.acx);
820 rte_exit(ret, "failed to add rules into ACL context\n");
825 ret = rte_acl_build(config.acx, &cfg);
827 dump_verbose(DUMP_NONE, stdout,
828 "rte_acl_build(%u) finished with %d\n",
829 config.bld_categories, ret);
831 rte_acl_dump(config.acx);
834 rte_exit(ret, "failed to build search context\n");
838 search_ip5tuples_once(uint32_t categories, uint32_t step, const char *alg)
841 uint32_t i, j, k, n, r;
842 const uint8_t *data[step], *v;
843 uint32_t results[step * categories];
846 for (i = 0; i != config.used_traces; i += n) {
848 n = RTE_MIN(step, config.used_traces - i);
850 for (j = 0; j != n; j++) {
852 v += config.trace_sz;
855 ret = rte_acl_classify(config.acx, data, results,
859 rte_exit(ret, "classify for ipv%c_5tuples returns %d\n",
860 config.ipv6 ? '6' : '4', ret);
862 for (r = 0, j = 0; j != n; j++) {
863 for (k = 0; k != categories; k++, r++) {
864 dump_verbose(DUMP_PKT, stdout,
865 "ipv%c_5tuple: %u, category: %u, "
867 config.ipv6 ? '6' : '4',
868 i + j + 1, k, results[r] - 1);
874 dump_verbose(DUMP_SEARCH, stdout,
875 "%s(%u, %u, %s) returns %u\n", __func__,
876 categories, step, alg, i);
881 search_ip5tuples(__attribute__((unused)) void *arg)
883 uint64_t pkt, start, tm;
886 lcore = rte_lcore_id();
890 for (i = 0; i != config.iter_num; i++) {
891 pkt += search_ip5tuples_once(config.run_categories,
892 config.trace_step, config.alg.name);
895 tm = rte_rdtsc() - start;
896 dump_verbose(DUMP_NONE, stdout,
897 "%s @lcore %u: %" PRIu32 " iterations, %" PRIu64 " pkts, %"
898 PRIu32 " categories, %" PRIu64 " cycles, %#Lf cycles/pkt\n",
899 __func__, lcore, i, pkt, config.run_categories,
900 tm, (long double)tm / pkt);
906 get_ulong_opt(const char *opt, const char *name, size_t min, size_t max)
912 val = strtoul(opt, &end, 0);
913 if (errno != 0 || end[0] != 0 || val > max || val < min)
914 rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
920 get_alg_opt(const char *opt, const char *name)
924 for (i = 0; i != RTE_DIM(acl_alg); i++) {
925 if (strcmp(opt, acl_alg[i].name) == 0) {
926 config.alg = acl_alg[i];
931 rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
936 print_usage(const char *prgname)
944 for (i = 0; i < RTE_DIM(acl_alg) - 1; i++) {
945 rc = snprintf(buf + n, sizeof(buf) - n, "%s|",
947 if (rc > sizeof(buf) - n)
952 snprintf(buf + n, sizeof(buf) - n, "%s", acl_alg[i].name);
956 "--" OPT_RULE_FILE "=<rules set file>\n"
957 "[--" OPT_TRACE_FILE "=<input traces file>]\n"
959 "=<maximum number of rules for ACL context>]\n"
961 "=<number of traces to read binary file in>]\n"
963 "=<number of traces to classify per one call>]\n"
964 "[--" OPT_BLD_CATEGORIES
965 "=<number of categories to build with>]\n"
966 "[--" OPT_RUN_CATEGORIES
967 "=<number of categories to run with> "
968 "should be either 1 or multiple of %zu, "
969 "but not greater then %u]\n"
971 "=<size limit (in bytes) for runtime ACL strucutures> "
972 "leave 0 for default behaviour]\n"
973 "[--" OPT_ITER_NUM "=<number of iterations to perform>]\n"
974 "[--" OPT_VERBOSE "=<verbose level>]\n"
975 "[--" OPT_SEARCH_ALG "=%s]\n"
976 "[--" OPT_IPV6 "=<IPv6 rules and trace files>]\n",
977 prgname, RTE_ACL_RESULTS_MULTIPLIER,
978 (uint32_t)RTE_ACL_MAX_CATEGORIES,
985 fprintf(f, "%s:\n", __func__);
986 fprintf(f, "%s:%s\n", OPT_RULE_FILE, config.rule_file);
987 fprintf(f, "%s:%s\n", OPT_TRACE_FILE, config.trace_file);
988 fprintf(f, "%s:%u\n", OPT_RULE_NUM, config.nb_rules);
989 fprintf(f, "%s:%u\n", OPT_TRACE_NUM, config.nb_traces);
990 fprintf(f, "%s:%u\n", OPT_TRACE_STEP, config.trace_step);
991 fprintf(f, "%s:%u\n", OPT_BLD_CATEGORIES, config.bld_categories);
992 fprintf(f, "%s:%u\n", OPT_RUN_CATEGORIES, config.run_categories);
993 fprintf(f, "%s:%zu\n", OPT_MAX_SIZE, config.max_size);
994 fprintf(f, "%s:%u\n", OPT_ITER_NUM, config.iter_num);
995 fprintf(f, "%s:%u\n", OPT_VERBOSE, config.verbose);
996 fprintf(f, "%s:%u(%s)\n", OPT_SEARCH_ALG, config.alg.alg,
998 fprintf(f, "%s:%u\n", OPT_IPV6, config.ipv6);
1004 if (config.rule_file == NULL) {
1005 print_usage(config.prgname);
1006 rte_exit(-EINVAL, "mandatory option %s is not specified\n",
1013 get_input_opts(int argc, char **argv)
1015 static struct option lgopts[] = {
1016 {OPT_RULE_FILE, 1, 0, 0},
1017 {OPT_TRACE_FILE, 1, 0, 0},
1018 {OPT_TRACE_NUM, 1, 0, 0},
1019 {OPT_RULE_NUM, 1, 0, 0},
1020 {OPT_MAX_SIZE, 1, 0, 0},
1021 {OPT_TRACE_STEP, 1, 0, 0},
1022 {OPT_BLD_CATEGORIES, 1, 0, 0},
1023 {OPT_RUN_CATEGORIES, 1, 0, 0},
1024 {OPT_ITER_NUM, 1, 0, 0},
1025 {OPT_VERBOSE, 1, 0, 0},
1026 {OPT_SEARCH_ALG, 1, 0, 0},
1027 {OPT_IPV6, 0, 0, 0},
1033 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) {
1036 print_usage(config.prgname);
1037 rte_exit(-EINVAL, "unknown option: %c", opt);
1040 if (strcmp(lgopts[opt_idx].name, OPT_RULE_FILE) == 0) {
1041 config.rule_file = optarg;
1042 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_FILE) == 0) {
1043 config.trace_file = optarg;
1044 } else if (strcmp(lgopts[opt_idx].name, OPT_RULE_NUM) == 0) {
1045 config.nb_rules = get_ulong_opt(optarg,
1046 lgopts[opt_idx].name, 1, RTE_ACL_MAX_INDEX + 1);
1047 } else if (strcmp(lgopts[opt_idx].name, OPT_MAX_SIZE) == 0) {
1048 config.max_size = get_ulong_opt(optarg,
1049 lgopts[opt_idx].name, 0, SIZE_MAX);
1050 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_NUM) == 0) {
1051 config.nb_traces = get_ulong_opt(optarg,
1052 lgopts[opt_idx].name, 1, UINT32_MAX);
1053 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_STEP) == 0) {
1054 config.trace_step = get_ulong_opt(optarg,
1055 lgopts[opt_idx].name, 1, TRACE_STEP_MAX);
1056 } else if (strcmp(lgopts[opt_idx].name,
1057 OPT_BLD_CATEGORIES) == 0) {
1058 config.bld_categories = get_ulong_opt(optarg,
1059 lgopts[opt_idx].name, 1,
1060 RTE_ACL_MAX_CATEGORIES);
1061 } else if (strcmp(lgopts[opt_idx].name,
1062 OPT_RUN_CATEGORIES) == 0) {
1063 config.run_categories = get_ulong_opt(optarg,
1064 lgopts[opt_idx].name, 1,
1065 RTE_ACL_MAX_CATEGORIES);
1066 } else if (strcmp(lgopts[opt_idx].name, OPT_ITER_NUM) == 0) {
1067 config.iter_num = get_ulong_opt(optarg,
1068 lgopts[opt_idx].name, 1, INT32_MAX);
1069 } else if (strcmp(lgopts[opt_idx].name, OPT_VERBOSE) == 0) {
1070 config.verbose = get_ulong_opt(optarg,
1071 lgopts[opt_idx].name, DUMP_NONE, DUMP_MAX);
1072 } else if (strcmp(lgopts[opt_idx].name,
1073 OPT_SEARCH_ALG) == 0) {
1074 get_alg_opt(optarg, lgopts[opt_idx].name);
1075 } else if (strcmp(lgopts[opt_idx].name, OPT_IPV6) == 0) {
1079 config.trace_sz = config.ipv6 ? sizeof(struct ipv6_5tuple) :
1080 sizeof(struct ipv4_5tuple);
1085 main(int argc, char **argv)
1090 ret = rte_eal_init(argc, argv);
1092 rte_panic("Cannot init EAL\n");
1097 config.prgname = argv[0];
1099 get_input_opts(argc, argv);
1100 dump_config(stdout);
1105 if (config.trace_file != NULL)
1108 RTE_LCORE_FOREACH_SLAVE(lcore)
1109 rte_eal_remote_launch(search_ip5tuples, NULL, lcore);
1111 search_ip5tuples(NULL);
1113 rte_eal_mp_wait_lcore();
1115 rte_acl_free(config.acx);