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