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