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