app/test/test_table_acl.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_hexdump.h>
  35 #include "test_table.h"
  36 #include "test_table_acl.h"
  37
  38 #define IPv4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) |              \
  39         (((b) & 0xff) << 16) |                                          \
  40         (((c) & 0xff) << 8) |                                           \
  41         ((d) & 0xff))
  42
  43 /*
  44  * Rule and trace formats definitions.
  45  **/
  46
  47 struct ipv4_5tuple {
  48         uint8_t  proto;
  49         uint32_t ip_src;
  50         uint32_t ip_dst;
  51         uint16_t port_src;
  52         uint16_t port_dst;
  53 };
  54
  55 enum {
  56         PROTO_FIELD_IPV4,
  57         SRC_FIELD_IPV4,
  58         DST_FIELD_IPV4,
  59         SRCP_FIELD_IPV4,
  60         DSTP_FIELD_IPV4,
  61         NUM_FIELDS_IPV4
  62 };
  63
  64 struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
  65         {
  66                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  67                 .size = sizeof(uint8_t),
  68                 .field_index = PROTO_FIELD_IPV4,
  69                 .input_index = PROTO_FIELD_IPV4,
  70                 .offset = offsetof(struct ipv4_5tuple, proto),
  71         },
  72         {
  73                 .type = RTE_ACL_FIELD_TYPE_MASK,
  74                 .size = sizeof(uint32_t),
  75                 .field_index = SRC_FIELD_IPV4,
  76                 .input_index = SRC_FIELD_IPV4,
  77                 .offset = offsetof(struct ipv4_5tuple, ip_src),
  78         },
  79         {
  80                 .type = RTE_ACL_FIELD_TYPE_MASK,
  81                 .size = sizeof(uint32_t),
  82                 .field_index = DST_FIELD_IPV4,
  83                 .input_index = DST_FIELD_IPV4,
  84                 .offset = offsetof(struct ipv4_5tuple, ip_dst),
  85         },
  86         {
  87                 .type = RTE_ACL_FIELD_TYPE_RANGE,
  88                 .size = sizeof(uint16_t),
  89                 .field_index = SRCP_FIELD_IPV4,
  90                 .input_index = SRCP_FIELD_IPV4,
  91                 .offset = offsetof(struct ipv4_5tuple, port_src),
  92         },
  93         {
  94                 .type = RTE_ACL_FIELD_TYPE_RANGE,
  95                 .size = sizeof(uint16_t),
  96                 .field_index = DSTP_FIELD_IPV4,
  97                 .input_index = SRCP_FIELD_IPV4,
  98                 .offset = offsetof(struct ipv4_5tuple, port_dst),
  99         },
 100 };
 101
 102 struct rte_table_acl_rule_add_params table_acl_IPv4_rule;
 103
 104 typedef int (*parse_5tuple)(char *text,
 105         struct rte_table_acl_rule_add_params *rule);
 106
 107 /*
 108 * The order of the fields in the rule string after the initial '@'
 109 */
 110 enum {
 111         CB_FLD_SRC_ADDR,
 112         CB_FLD_DST_ADDR,
 113         CB_FLD_SRC_PORT_RANGE,
 114         CB_FLD_DST_PORT_RANGE,
 115         CB_FLD_PROTO,
 116         CB_FLD_NUM,
 117 };
 118
 119
 120 #define GET_CB_FIELD(in, fd, base, lim, dlm)                            \
 121 do {                                                                    \
 122         unsigned long val;                                              \
 123         char *end;                                                      \
 124                                                                         \
 125         errno = 0;                                                      \
 126         val = strtoul((in), &end, (base));                              \
 127         if (errno != 0 || end[0] != (dlm) || val > (lim))               \
 128                 return -EINVAL;                                         \
 129         (fd) = (typeof(fd)) val;                                        \
 130         (in) = end + 1;                                                 \
 131 } while (0)
 132
 133
 134
 135
 136 static int
 137 parse_ipv4_net(const char *in, uint32_t *addr, uint32_t *mask_len)
 138 {
 139         uint8_t a, b, c, d, m;
 140
 141         GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
 142         GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
 143         GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
 144         GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
 145         GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);
 146
 147         addr[0] = IPv4(a, b, c, d);
 148         mask_len[0] = m;
 149
 150         return 0;
 151 }
 152
 153 static int
 154 parse_port_range(const char *in, uint16_t *port_low, uint16_t *port_high)
 155 {
 156         uint16_t a, b;
 157
 158         GET_CB_FIELD(in, a, 0, UINT16_MAX, ':');
 159         GET_CB_FIELD(in, b, 0, UINT16_MAX, 0);
 160
 161         port_low[0] = a;
 162         port_high[0] = b;
 163
 164         return 0;
 165 }
 166
 167 static int
 168 parse_cb_ipv4_rule(char *str, struct rte_table_acl_rule_add_params *v)
 169 {
 170         int i, rc;
 171         char *s, *sp, *in[CB_FLD_NUM];
 172         static const char *dlm = " \t\n";
 173
 174         /*
 175         ** Skip leading '@'
 176         */
 177         if (strchr(str, '@') != str)
 178                 return -EINVAL;
 179
 180         s = str + 1;
 181
 182         /*
 183         * Populate the 'in' array with the location of each
 184         * field in the string we're parsing
 185         */
 186         for (i = 0; i != DIM(in); i++) {
 187                 in[i] = strtok_r(s, dlm, &sp);
 188                 if (in[i] == NULL)
 189                         return -EINVAL;
 190                 s = NULL;
 191         }
 192
 193         /* Parse x.x.x.x/x */
 194         rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
 195                 &v->field_value[SRC_FIELD_IPV4].value.u32,
 196                 &v->field_value[SRC_FIELD_IPV4].mask_range.u32);
 197         if (rc != 0) {
 198                 RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
 199                         in[CB_FLD_SRC_ADDR]);
 200                 return rc;
 201         }
 202
 203         printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
 204                 v->field_value[SRC_FIELD_IPV4].mask_range.u32);
 205
 206         /* Parse x.x.x.x/x */
 207         rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
 208                 &v->field_value[DST_FIELD_IPV4].value.u32,
 209                 &v->field_value[DST_FIELD_IPV4].mask_range.u32);
 210         if (rc != 0) {
 211                 RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
 212                         in[CB_FLD_DST_ADDR]);
 213                 return rc;
 214         }
 215
 216         printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
 217         v->field_value[DST_FIELD_IPV4].mask_range.u32);
 218         /* Parse n:n */
 219         rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
 220                 &v->field_value[SRCP_FIELD_IPV4].value.u16,
 221                 &v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
 222         if (rc != 0) {
 223                 RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
 224                         in[CB_FLD_SRC_PORT_RANGE]);
 225                 return rc;
 226         }
 227
 228         printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
 229                 v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
 230         /* Parse n:n */
 231         rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
 232                 &v->field_value[DSTP_FIELD_IPV4].value.u16,
 233                 &v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 234         if (rc != 0) {
 235                 RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
 236                         in[CB_FLD_DST_PORT_RANGE]);
 237                 return rc;
 238         }
 239
 240         printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
 241                 v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 242         /* parse 0/0xnn */
 243         GET_CB_FIELD(in[CB_FLD_PROTO],
 244                 v->field_value[PROTO_FIELD_IPV4].value.u8,
 245                 0, UINT8_MAX, '/');
 246         GET_CB_FIELD(in[CB_FLD_PROTO],
 247                 v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
 248                 0, UINT8_MAX, 0);
 249
 250         printf("V=%u, mask=%u\n",
 251                 (unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
 252                 v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
 253         return 0;
 254 }
 255
 256 static int
 257 parse_cb_ipv4_rule_del(char *str, struct rte_table_acl_rule_delete_params *v)
 258 {
 259         int i, rc;
 260         char *s, *sp, *in[CB_FLD_NUM];
 261         static const char *dlm = " \t\n";
 262
 263         /*
 264         ** Skip leading '@'
 265         */
 266         if (strchr(str, '@') != str)
 267                 return -EINVAL;
 268
 269         s = str + 1;
 270
 271         /*
 272         * Populate the 'in' array with the location of each
 273         * field in the string we're parsing
 274         */
 275         for (i = 0; i != DIM(in); i++) {
 276                 in[i] = strtok_r(s, dlm, &sp);
 277                 if (in[i] == NULL)
 278                         return -EINVAL;
 279                 s = NULL;
 280         }
 281
 282         /* Parse x.x.x.x/x */
 283         rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
 284                 &v->field_value[SRC_FIELD_IPV4].value.u32,
 285                 &v->field_value[SRC_FIELD_IPV4].mask_range.u32);
 286         if (rc != 0) {
 287                 RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
 288                         in[CB_FLD_SRC_ADDR]);
 289                 return rc;
 290         }
 291
 292         printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
 293                 v->field_value[SRC_FIELD_IPV4].mask_range.u32);
 294
 295         /* Parse x.x.x.x/x */
 296         rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
 297                 &v->field_value[DST_FIELD_IPV4].value.u32,
 298                 &v->field_value[DST_FIELD_IPV4].mask_range.u32);
 299         if (rc != 0) {
 300                 RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
 301                         in[CB_FLD_DST_ADDR]);
 302                 return rc;
 303         }
 304
 305         printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
 306         v->field_value[DST_FIELD_IPV4].mask_range.u32);
 307         /* Parse n:n */
 308         rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
 309                 &v->field_value[SRCP_FIELD_IPV4].value.u16,
 310                 &v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
 311         if (rc != 0) {
 312                 RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
 313                         in[CB_FLD_SRC_PORT_RANGE]);
 314                 return rc;
 315         }
 316
 317         printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
 318                 v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
 319         /* Parse n:n */
 320         rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
 321                 &v->field_value[DSTP_FIELD_IPV4].value.u16,
 322                 &v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 323         if (rc != 0) {
 324                 RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
 325                         in[CB_FLD_DST_PORT_RANGE]);
 326                 return rc;
 327         }
 328
 329         printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
 330                 v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 331         /* parse 0/0xnn */
 332         GET_CB_FIELD(in[CB_FLD_PROTO],
 333                 v->field_value[PROTO_FIELD_IPV4].value.u8,
 334                 0, UINT8_MAX, '/');
 335         GET_CB_FIELD(in[CB_FLD_PROTO],
 336                 v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
 337                 0, UINT8_MAX, 0);
 338
 339         printf("V=%u, mask=%u\n",
 340                 (unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
 341                 v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
 342         return 0;
 343 }
 344
 345 /*
 346  * The format for these rules DO NOT need the port ranges to be
 347  * separated by ' : ', just ':'. It's a lot more readable and
 348  * cleaner, IMO.
 349  */
 350 char lines[][128] = {
 351         "@0.0.0.0/0 0.0.0.0/0 0:65535 0:65535 2/0xff", /* Protocol check */
 352         "@192.168.3.1/32 0.0.0.0/0 0:65535 0:65535 0/0", /* Src IP checl */
 353         "@0.0.0.0/0 10.4.4.1/32 0:65535 0:65535 0/0", /* dst IP check */
 354         "@0.0.0.0/0 0.0.0.0/0 105:105 0:65535 0/0", /* src port check */
 355         "@0.0.0.0/0 0.0.0.0/0 0:65535 206:206 0/0", /* dst port check */
 356 };
 357
 358 char line[128];
 359
 360
 361 static int
 362 setup_acl_pipeline(void)
 363 {
 364         int ret;
 365         int i;
 366         struct rte_pipeline_params pipeline_params = {
 367                 .name = "PIPELINE",
 368                 .socket_id = 0,
 369         };
 370         uint32_t n;
 371         struct rte_table_acl_rule_add_params rule_params;
 372         struct rte_pipeline_table_acl_rule_delete_params *delete_params;
 373         parse_5tuple parser;
 374         char acl_name[64];
 375
 376         /* Pipeline configuration */
 377         p = rte_pipeline_create(&pipeline_params);
 378         if (p == NULL) {
 379                 RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n",
 380                         __func__);
 381                 goto fail;
 382         }
 383
 384         /* Input port configuration */
 385         for (i = 0; i < N_PORTS; i++) {
 386                 struct rte_port_ring_reader_params port_ring_params = {
 387                         .ring = rings_rx[i],
 388                 };
 389
 390                 struct rte_pipeline_port_in_params port_params = {
 391                         .ops = &rte_port_ring_reader_ops,
 392                         .arg_create = (void *) &port_ring_params,
 393                         .f_action = NULL,
 394                         .burst_size = BURST_SIZE,
 395                 };
 396
 397                 /* Put in action for some ports */
 398                 if (i)
 399                         port_params.f_action = port_in_action;
 400
 401                 ret = rte_pipeline_port_in_create(p, &port_params,
 402                         &port_in_id[i]);
 403                 if (ret) {
 404                         rte_panic("Unable to configure input port %d, ret:%d\n",
 405                                 i, ret);
 406                         goto fail;
 407                 }
 408         }
 409
 410         /* output Port configuration */
 411         for (i = 0; i < N_PORTS; i++) {
 412                 struct rte_port_ring_writer_params port_ring_params = {
 413                         .ring = rings_tx[i],
 414                         .tx_burst_sz = BURST_SIZE,
 415                 };
 416
 417                 struct rte_pipeline_port_out_params port_params = {
 418                         .ops = &rte_port_ring_writer_ops,
 419                         .arg_create = (void *) &port_ring_params,
 420                         .f_action = NULL,
 421                         .arg_ah = NULL,
 422                 };
 423
 424
 425                 if (rte_pipeline_port_out_create(p, &port_params,
 426                         &port_out_id[i])) {
 427                         rte_panic("Unable to configure output port %d\n", i);
 428                         goto fail;
 429                 }
 430         }
 431
 432         /* Table configuration  */
 433         for (i = 0; i < N_PORTS; i++) {
 434                 struct rte_pipeline_table_params table_params;
 435
 436                 /* Set up defaults for stub */
 437                 table_params.ops = &rte_table_stub_ops;
 438                 table_params.arg_create = NULL;
 439                 table_params.f_action_hit = action_handler_hit;
 440                 table_params.f_action_miss = NULL;
 441                 table_params.action_data_size = 0;
 442
 443                 RTE_LOG(INFO, PIPELINE, "miss_action=%x\n",
 444                         table_entry_miss_action);
 445
 446                 printf("RTE_ACL_RULE_SZ(%zu) = %zu\n", DIM(ipv4_defs),
 447                         RTE_ACL_RULE_SZ(DIM(ipv4_defs)));
 448
 449                 struct rte_table_acl_params acl_params;
 450
 451                 acl_params.n_rules = 1 << 5;
 452                 acl_params.n_rule_fields = DIM(ipv4_defs);
 453                 snprintf(acl_name, sizeof(acl_name), "ACL%d", i);
 454                 acl_params.name = acl_name;
 455                 memcpy(acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
 456
 457                 table_params.ops = &rte_table_acl_ops;
 458                 table_params.arg_create = &acl_params;
 459
 460                 if (rte_pipeline_table_create(p, &table_params, &table_id[i])) {
 461                         rte_panic("Unable to configure table %u\n", i);
 462                         goto fail;
 463                 }
 464
 465                 if (connect_miss_action_to_table) {
 466                         if (rte_pipeline_table_create(p, &table_params,
 467                                 &table_id[i+2])) {
 468                                 rte_panic("Unable to configure table %u\n", i);
 469                                 goto fail;
 470                         }
 471                 }
 472         }
 473
 474         for (i = 0; i < N_PORTS; i++) {
 475                 if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
 476                         table_id[i])) {
 477                         rte_panic("Unable to connect input port %u to "
 478                                 "table %u\n",
 479                                 port_in_id[i],  table_id[i]);
 480                         goto fail;
 481                 }
 482         }
 483
 484         /* Add bulk entries to tables */
 485         for (i = 0; i < N_PORTS; i++) {
 486                 struct rte_table_acl_rule_add_params keys[5];
 487                 struct rte_pipeline_table_entry entries[5];
 488                 struct rte_table_acl_rule_add_params *key_array[5];
 489                 struct rte_pipeline_table_entry *table_entries[5];
 490                 int key_found[5];
 491                 struct rte_pipeline_table_entry *table_entries_ptr[5];
 492                 struct rte_pipeline_table_entry entries_ptr[5];
 493
 494                 parser = parse_cb_ipv4_rule;
 495                 for (n = 0; n < 5; n++) {
 496                         memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_add_params));
 497                         key_array[n] = &keys[n];
 498
 499                         snprintf(line, sizeof(line), "%s", lines[n]);
 500                         printf("PARSING [%s]\n", line);
 501
 502                         ret = parser(line, &keys[n]);
 503                         if (ret != 0) {
 504                                 RTE_LOG(ERR, PIPELINE,
 505                                         "line %u: parse_cb_ipv4vlan_rule"
 506                                         " failed, error code: %d (%s)\n",
 507                                         n, ret, strerror(-ret));
 508                                 return ret;
 509                         }
 510
 511                         keys[n].priority = RTE_ACL_MAX_PRIORITY - n - 1;
 512
 513                         entries[n].action = RTE_PIPELINE_ACTION_PORT;
 514                         entries[n].port_id = port_out_id[i^1];
 515                         table_entries[n] = &entries[n];
 516                         table_entries_ptr[n] = &entries_ptr[n];
 517                 }
 518
 519                 ret = rte_pipeline_table_entry_add_bulk(p, table_id[i],
 520                                 (void **)key_array, table_entries, 5, key_found, table_entries_ptr);
 521                 if (ret < 0) {
 522                         rte_panic("Add entry bulk to table %u failed (%d)\n",
 523                                 table_id[i], ret);
 524                         goto fail;
 525                 }
 526         }
 527
 528         /* Delete bulk entries from tables */
 529         for (i = 0; i < N_PORTS; i++) {
 530                 struct rte_table_acl_rule_delete_params keys[5];
 531                 struct rte_table_acl_rule_delete_params *key_array[5];
 532                 struct rte_pipeline_table_entry *table_entries[5];
 533                 int key_found[5];
 534
 535                 for (n = 0; n < 5; n++) {
 536                         memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_delete_params));
 537                         key_array[n] = &keys[n];
 538
 539                         snprintf(line, sizeof(line), "%s", lines[n]);
 540                         printf("PARSING [%s]\n", line);
 541
 542                         ret = parse_cb_ipv4_rule_del(line, &keys[n]);
 543                         if (ret != 0) {
 544                                 RTE_LOG(ERR, PIPELINE,
 545                                         "line %u: parse_cb_ipv4vlan_rule"
 546                                         " failed, error code: %d (%s)\n",
 547                                         n, ret, strerror(-ret));
 548                                 return ret;
 549                         }
 550                 }
 551
 552                 ret = rte_pipeline_table_entry_delete_bulk(p, table_id[i],
 553                         (void **)key_array, 5, key_found, table_entries);
 554                 if (ret < 0) {
 555                         rte_panic("Delete bulk entries from table %u failed (%d)\n",
 556                                 table_id[i], ret);
 557                         goto fail;
 558                 } else
 559                         printf("Bulk deleted rules.\n");
 560         }
 561
 562         /* Add entries to tables */
 563         for (i = 0; i < N_PORTS; i++) {
 564                 struct rte_pipeline_table_entry table_entry = {
 565                         .action = RTE_PIPELINE_ACTION_PORT,
 566                         {.port_id = port_out_id[i^1]},
 567                 };
 568                 int key_found;
 569                 struct rte_pipeline_table_entry *entry_ptr;
 570
 571                 memset(&rule_params, 0, sizeof(rule_params));
 572                 parser = parse_cb_ipv4_rule;
 573
 574                 for (n = 1; n <= 5; n++) {
 575                         snprintf(line, sizeof(line), "%s", lines[n-1]);
 576                         printf("PARSING [%s]\n", line);
 577
 578                         ret = parser(line, &rule_params);
 579                         if (ret != 0) {
 580                                 RTE_LOG(ERR, PIPELINE,
 581                                         "line %u: parse_cb_ipv4vlan_rule"
 582                                         " failed, error code: %d (%s)\n",
 583                                         n, ret, strerror(-ret));
 584                                 return ret;
 585                         }
 586
 587                         rule_params.priority = RTE_ACL_MAX_PRIORITY - n;
 588
 589                         ret = rte_pipeline_table_entry_add(p, table_id[i],
 590                                 &rule_params,
 591                                 &table_entry, &key_found, &entry_ptr);
 592                         if (ret < 0) {
 593                                 rte_panic("Add entry to table %u failed (%d)\n",
 594                                         table_id[i], ret);
 595                                 goto fail;
 596                         }
 597                 }
 598
 599                 /* delete a few rules */
 600                 for (n = 2; n <= 3; n++) {
 601                         snprintf(line, sizeof(line), "%s", lines[n-1]);
 602                         printf("PARSING [%s]\n", line);
 603
 604                         ret = parser(line, &rule_params);
 605                         if (ret != 0) {
 606                                 RTE_LOG(ERR, PIPELINE, "line %u: parse rule "
 607                                         " failed, error code: %d (%s)\n",
 608                                         n, ret, strerror(-ret));
 609                                 return ret;
 610                         }
 611
 612                         delete_params = (struct
 613                                 rte_pipeline_table_acl_rule_delete_params *)
 614                                 &(rule_params.field_value[0]);
 615                         ret = rte_pipeline_table_entry_delete(p, table_id[i],
 616                                 delete_params, &key_found, NULL);
 617                         if (ret < 0) {
 618                                 rte_panic("Add entry to table %u failed (%d)\n",
 619                                         table_id[i], ret);
 620                                 goto fail;
 621                         } else
 622                                 printf("Deleted Rule.\n");
 623                 }
 624
 625
 626                 /* Try to add duplicates */
 627                 for (n = 1; n <= 5; n++) {
 628                         snprintf(line, sizeof(line), "%s", lines[n-1]);
 629                         printf("PARSING [%s]\n", line);
 630
 631                         ret = parser(line, &rule_params);
 632                         if (ret != 0) {
 633                                 RTE_LOG(ERR, PIPELINE, "line %u: parse rule"
 634                                         " failed, error code: %d (%s)\n",
 635                                         n, ret, strerror(-ret));
 636                                 return ret;
 637                         }
 638
 639                         rule_params.priority = RTE_ACL_MAX_PRIORITY - n;
 640
 641                         ret = rte_pipeline_table_entry_add(p, table_id[i],
 642                                 &rule_params,
 643                                 &table_entry, &key_found, &entry_ptr);
 644                         if (ret < 0) {
 645                                 rte_panic("Add entry to table %u failed (%d)\n",
 646                                         table_id[i], ret);
 647                                 goto fail;
 648                         }
 649                 }
 650         }
 651
 652         /* Enable input ports */
 653         for (i = 0; i < N_PORTS ; i++)
 654                 if (rte_pipeline_port_in_enable(p, port_in_id[i]))
 655                         rte_panic("Unable to enable input port %u\n",
 656                                 port_in_id[i]);
 657
 658         /* Check pipeline consistency */
 659         if (rte_pipeline_check(p) < 0) {
 660                 rte_panic("Pipeline consistency check failed\n");
 661                 goto fail;
 662         }
 663
 664         return  0;
 665 fail:
 666
 667         return -1;
 668 }
 669
 670 static int
 671 test_pipeline_single_filter(int expected_count)
 672 {
 673         int i, j, ret, tx_count;
 674         struct ipv4_5tuple five_tuple;
 675
 676         /* Allocate a few mbufs and manually insert into the rings. */
 677         for (i = 0; i < N_PORTS; i++) {
 678                 for (j = 0; j < 8; j++) {
 679                         struct rte_mbuf *mbuf;
 680
 681                         mbuf = rte_pktmbuf_alloc(pool);
 682                         if (mbuf == NULL)
 683                                 /* this will cause test failure after cleanup
 684                                  * of already enqueued mbufs, as the mbuf
 685                                  * counts won't match */
 686                                 break;
 687                         memset(rte_pktmbuf_mtod(mbuf, char *), 0x00,
 688                                 sizeof(struct ipv4_5tuple));
 689
 690                         five_tuple.proto = j;
 691                         five_tuple.ip_src = rte_bswap32(IPv4(192, 168, j, 1));
 692                         five_tuple.ip_dst = rte_bswap32(IPv4(10, 4, j, 1));
 693                         five_tuple.port_src = rte_bswap16(100 + j);
 694                         five_tuple.port_dst = rte_bswap16(200 + j);
 695
 696                         memcpy(rte_pktmbuf_mtod(mbuf, char *), &five_tuple,
 697                                 sizeof(struct ipv4_5tuple));
 698                         RTE_LOG(INFO, PIPELINE, "%s: Enqueue onto ring %d\n",
 699                                 __func__, i);
 700                         rte_ring_enqueue(rings_rx[i], mbuf);
 701                 }
 702         }
 703
 704         /* Run pipeline once */
 705         for (i = 0; i< N_PORTS; i++)
 706                 rte_pipeline_run(p);
 707
 708         rte_pipeline_flush(p);
 709
 710         tx_count = 0;
 711
 712         for (i = 0; i < N_PORTS; i++) {
 713                 void *objs[RING_TX_SIZE];
 714                 struct rte_mbuf *mbuf;
 715
 716                 ret = rte_ring_sc_dequeue_burst(rings_tx[i], objs, 10);
 717                 if (ret <= 0) {
 718                         printf("Got no objects from ring %d - error code %d\n",
 719                                 i, ret);
 720                 } else {
 721                         printf("Got %d object(s) from ring %d!\n", ret, i);
 722                         for (j = 0; j < ret; j++) {
 723                                 mbuf = (struct rte_mbuf *)objs[j];
 724                                 rte_hexdump(stdout, "mbuf",
 725                                         rte_pktmbuf_mtod(mbuf, char *), 64);
 726                                 rte_pktmbuf_free(mbuf);
 727                         }
 728                         tx_count += ret;
 729                 }
 730         }
 731
 732         if (tx_count != expected_count) {
 733                 RTE_LOG(INFO, PIPELINE,
 734                         "%s: Unexpected packets for ACL test, "
 735                         "expected %d, got %d\n",
 736                         __func__, expected_count, tx_count);
 737                 goto fail;
 738         }
 739
 740         rte_pipeline_free(p);
 741
 742         return  0;
 743 fail:
 744         return -1;
 745
 746 }
 747
 748 int
 749 test_table_acl(void)
 750 {
 751
 752
 753         override_hit_mask = 0xFF; /* All packets are a hit */
 754
 755         setup_acl_pipeline();
 756         if (test_pipeline_single_filter(10) < 0)
 757                 return -1;
 758
 759         return 0;
 760 }