test/test-acl/main.c

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