app/test-acl/main.c

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