examples/ip_pipeline/cli.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdint.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_cycles.h>
  12 #include <rte_ethdev.h>
  13
  14 #include "cli.h"
  15
  16 #include "cryptodev.h"
  17 #include "kni.h"
  18 #include "link.h"
  19 #include "mempool.h"
  20 #include "parser.h"
  21 #include "pipeline.h"
  22 #include "swq.h"
  23 #include "tap.h"
  24 #include "thread.h"
  25 #include "tmgr.h"
  26
  27 #ifndef CMD_MAX_TOKENS
  28 #define CMD_MAX_TOKENS     256
  29 #endif
  30
  31 #define MSG_OUT_OF_MEMORY   "Not enough memory.\n"
  32 #define MSG_CMD_UNKNOWN     "Unknown command \"%s\".\n"
  33 #define MSG_CMD_UNIMPLEM    "Command \"%s\" not implemented.\n"
  34 #define MSG_ARG_NOT_ENOUGH  "Not enough arguments for command \"%s\".\n"
  35 #define MSG_ARG_TOO_MANY    "Too many arguments for command \"%s\".\n"
  36 #define MSG_ARG_MISMATCH    "Wrong number of arguments for command \"%s\".\n"
  37 #define MSG_ARG_NOT_FOUND   "Argument \"%s\" not found.\n"
  38 #define MSG_ARG_INVALID     "Invalid value for argument \"%s\".\n"
  39 #define MSG_FILE_ERR        "Error in file \"%s\" at line %u.\n"
  40 #define MSG_FILE_NOT_ENOUGH "Not enough rules in file \"%s\".\n"
  41 #define MSG_CMD_FAIL        "Command \"%s\" failed.\n"
  42
  43 static int
  44 is_comment(char *in)
  45 {
  46         if ((strlen(in) && index("!#%;", in[0])) ||
  47                 (strncmp(in, "//", 2) == 0) ||
  48                 (strncmp(in, "--", 2) == 0))
  49                 return 1;
  50
  51         return 0;
  52 }
  53
  54 static const char cmd_mempool_help[] =
  55 "mempool <mempool_name>\n"
  56 "   buffer <buffer_size>\n"
  57 "   pool <pool_size>\n"
  58 "   cache <cache_size>\n"
  59 "   cpu <cpu_id>\n";
  60
  61 static void
  62 cmd_mempool(char **tokens,
  63         uint32_t n_tokens,
  64         char *out,
  65         size_t out_size)
  66 {
  67         struct mempool_params p;
  68         char *name;
  69         struct mempool *mempool;
  70
  71         if (n_tokens != 10) {
  72                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
  73                 return;
  74         }
  75
  76         name = tokens[1];
  77
  78         if (strcmp(tokens[2], "buffer") != 0) {
  79                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buffer");
  80                 return;
  81         }
  82
  83         if (parser_read_uint32(&p.buffer_size, tokens[3]) != 0) {
  84                 snprintf(out, out_size, MSG_ARG_INVALID, "buffer_size");
  85                 return;
  86         }
  87
  88         if (strcmp(tokens[4], "pool") != 0) {
  89                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pool");
  90                 return;
  91         }
  92
  93         if (parser_read_uint32(&p.pool_size, tokens[5]) != 0) {
  94                 snprintf(out, out_size, MSG_ARG_INVALID, "pool_size");
  95                 return;
  96         }
  97
  98         if (strcmp(tokens[6], "cache") != 0) {
  99                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cache");
 100                 return;
 101         }
 102
 103         if (parser_read_uint32(&p.cache_size, tokens[7]) != 0) {
 104                 snprintf(out, out_size, MSG_ARG_INVALID, "cache_size");
 105                 return;
 106         }
 107
 108         if (strcmp(tokens[8], "cpu") != 0) {
 109                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
 110                 return;
 111         }
 112
 113         if (parser_read_uint32(&p.cpu_id, tokens[9]) != 0) {
 114                 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
 115                 return;
 116         }
 117
 118         mempool = mempool_create(name, &p);
 119         if (mempool == NULL) {
 120                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 121                 return;
 122         }
 123 }
 124
 125 static const char cmd_link_help[] =
 126 "link <link_name>\n"
 127 "   dev <device_name> | port <port_id>\n"
 128 "   rxq <n_queues> <queue_size> <mempool_name>\n"
 129 "   txq <n_queues> <queue_size>\n"
 130 "   promiscuous on | off\n"
 131 "   [rss <qid_0> ... <qid_n>]\n";
 132
 133 static void
 134 cmd_link(char **tokens,
 135         uint32_t n_tokens,
 136         char *out,
 137         size_t out_size)
 138 {
 139         struct link_params p;
 140         struct link_params_rss rss;
 141         struct link *link;
 142         char *name;
 143
 144         memset(&p, 0, sizeof(p));
 145
 146         if ((n_tokens < 13) || (n_tokens > 14 + LINK_RXQ_RSS_MAX)) {
 147                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 148                 return;
 149         }
 150         name = tokens[1];
 151
 152         if (strcmp(tokens[2], "dev") == 0)
 153                 p.dev_name = tokens[3];
 154         else if (strcmp(tokens[2], "port") == 0) {
 155                 p.dev_name = NULL;
 156
 157                 if (parser_read_uint16(&p.port_id, tokens[3]) != 0) {
 158                         snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
 159                         return;
 160                 }
 161         } else {
 162                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dev or port");
 163                 return;
 164         }
 165
 166         if (strcmp(tokens[4], "rxq") != 0) {
 167                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
 168                 return;
 169         }
 170
 171         if (parser_read_uint32(&p.rx.n_queues, tokens[5]) != 0) {
 172                 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
 173                 return;
 174         }
 175         if (parser_read_uint32(&p.rx.queue_size, tokens[6]) != 0) {
 176                 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
 177                 return;
 178         }
 179
 180         p.rx.mempool_name = tokens[7];
 181
 182         if (strcmp(tokens[8], "txq") != 0) {
 183                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
 184                 return;
 185         }
 186
 187         if (parser_read_uint32(&p.tx.n_queues, tokens[9]) != 0) {
 188                 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
 189                 return;
 190         }
 191
 192         if (parser_read_uint32(&p.tx.queue_size, tokens[10]) != 0) {
 193                 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
 194                 return;
 195         }
 196
 197         if (strcmp(tokens[11], "promiscuous") != 0) {
 198                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "promiscuous");
 199                 return;
 200         }
 201
 202         if (strcmp(tokens[12], "on") == 0)
 203                 p.promiscuous = 1;
 204         else if (strcmp(tokens[12], "off") == 0)
 205                 p.promiscuous = 0;
 206         else {
 207                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "on or off");
 208                 return;
 209         }
 210
 211         /* RSS */
 212         p.rx.rss = NULL;
 213         if (n_tokens > 13) {
 214                 uint32_t queue_id, i;
 215
 216                 if (strcmp(tokens[13], "rss") != 0) {
 217                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rss");
 218                         return;
 219                 }
 220
 221                 p.rx.rss = &rss;
 222
 223                 rss.n_queues = 0;
 224                 for (i = 14; i < n_tokens; i++) {
 225                         if (parser_read_uint32(&queue_id, tokens[i]) != 0) {
 226                                 snprintf(out, out_size, MSG_ARG_INVALID,
 227                                         "queue_id");
 228                                 return;
 229                         }
 230
 231                         rss.queue_id[rss.n_queues] = queue_id;
 232                         rss.n_queues++;
 233                 }
 234         }
 235
 236         link = link_create(name, &p);
 237         if (link == NULL) {
 238                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 239                 return;
 240         }
 241 }
 242
 243 /* Print the link stats and info */
 244 static void
 245 print_link_info(struct link *link, char *out, size_t out_size)
 246 {
 247         struct rte_eth_stats stats;
 248         struct rte_ether_addr mac_addr;
 249         struct rte_eth_link eth_link;
 250         uint16_t mtu;
 251         int ret;
 252
 253         memset(&stats, 0, sizeof(stats));
 254         rte_eth_stats_get(link->port_id, &stats);
 255
 256         ret = rte_eth_macaddr_get(link->port_id, &mac_addr);
 257         if (ret != 0) {
 258                 snprintf(out, out_size, "\n%s: MAC address get failed: %s",
 259                          link->name, rte_strerror(-ret));
 260                 return;
 261         }
 262
 263         ret = rte_eth_link_get(link->port_id, &eth_link);
 264         if (ret < 0) {
 265                 snprintf(out, out_size, "\n%s: link get failed: %s",
 266                          link->name, rte_strerror(-ret));
 267                 return;
 268         }
 269
 270         rte_eth_dev_get_mtu(link->port_id, &mtu);
 271
 272         snprintf(out, out_size,
 273                 "\n"
 274                 "%s: flags=<%s> mtu %u\n"
 275                 "\tether %02X:%02X:%02X:%02X:%02X:%02X rxqueues %u txqueues %u\n"
 276                 "\tport# %u  speed %u Mbps\n"
 277                 "\tRX packets %" PRIu64"  bytes %" PRIu64"\n"
 278                 "\tRX errors %" PRIu64"  missed %" PRIu64"  no-mbuf %" PRIu64"\n"
 279                 "\tTX packets %" PRIu64"  bytes %" PRIu64"\n"
 280                 "\tTX errors %" PRIu64"\n",
 281                 link->name,
 282                 eth_link.link_status == 0 ? "DOWN" : "UP",
 283                 mtu,
 284                 mac_addr.addr_bytes[0], mac_addr.addr_bytes[1],
 285                 mac_addr.addr_bytes[2], mac_addr.addr_bytes[3],
 286                 mac_addr.addr_bytes[4], mac_addr.addr_bytes[5],
 287                 link->n_rxq,
 288                 link->n_txq,
 289                 link->port_id,
 290                 eth_link.link_speed,
 291                 stats.ipackets,
 292                 stats.ibytes,
 293                 stats.ierrors,
 294                 stats.imissed,
 295                 stats.rx_nombuf,
 296                 stats.opackets,
 297                 stats.obytes,
 298                 stats.oerrors);
 299 }
 300
 301 /*
 302  * link show [<link_name>]
 303  */
 304 static void
 305 cmd_link_show(char **tokens, uint32_t n_tokens, char *out, size_t out_size)
 306 {
 307         struct link *link;
 308         char *link_name;
 309
 310         if (n_tokens != 2 && n_tokens != 3) {
 311                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 312                 return;
 313         }
 314
 315         if (n_tokens == 2) {
 316                 link = link_next(NULL);
 317
 318                 while (link != NULL) {
 319                         out_size = out_size - strlen(out);
 320                         out = &out[strlen(out)];
 321
 322                         print_link_info(link, out, out_size);
 323                         link = link_next(link);
 324                 }
 325         } else {
 326                 out_size = out_size - strlen(out);
 327                 out = &out[strlen(out)];
 328
 329                 link_name = tokens[2];
 330                 link = link_find(link_name);
 331
 332                 if (link == NULL) {
 333                         snprintf(out, out_size, MSG_ARG_INVALID,
 334                                         "Link does not exist");
 335                         return;
 336                 }
 337                 print_link_info(link, out, out_size);
 338         }
 339 }
 340
 341 static const char cmd_swq_help[] =
 342 "swq <swq_name>\n"
 343 "   size <size>\n"
 344 "   cpu <cpu_id>\n";
 345
 346 static void
 347 cmd_swq(char **tokens,
 348         uint32_t n_tokens,
 349         char *out,
 350         size_t out_size)
 351 {
 352         struct swq_params p;
 353         char *name;
 354         struct swq *swq;
 355
 356         if (n_tokens != 6) {
 357                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 358                 return;
 359         }
 360
 361         name = tokens[1];
 362
 363         if (strcmp(tokens[2], "size") != 0) {
 364                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
 365                 return;
 366         }
 367
 368         if (parser_read_uint32(&p.size, tokens[3]) != 0) {
 369                 snprintf(out, out_size, MSG_ARG_INVALID, "size");
 370                 return;
 371         }
 372
 373         if (strcmp(tokens[4], "cpu") != 0) {
 374                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
 375                 return;
 376         }
 377
 378         if (parser_read_uint32(&p.cpu_id, tokens[5]) != 0) {
 379                 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
 380                 return;
 381         }
 382
 383         swq = swq_create(name, &p);
 384         if (swq == NULL) {
 385                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 386                 return;
 387         }
 388 }
 389
 390 static const char cmd_tmgr_subport_profile_help[] =
 391 "tmgr subport profile\n"
 392 "   <tb_rate> <tb_size>\n"
 393 "   <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate> <tc4_rate>"
 394 "        <tc5_rate> <tc6_rate> <tc7_rate> <tc8_rate>"
 395 "        <tc9_rate> <tc10_rate> <tc11_rate> <tc12_rate>\n"
 396 "   <tc_period>\n"
 397 "   pps <n_pipes_per_subport>\n"
 398 "   qsize <qsize_tc0> <qsize_tc1> <qsize_tc2>"
 399 "       <qsize_tc3> <qsize_tc4> <qsize_tc5> <qsize_tc6>"
 400 "       <qsize_tc7> <qsize_tc8> <qsize_tc9> <qsize_tc10>"
 401 "       <qsize_tc11> <qsize_tc12>";
 402
 403 static void
 404 cmd_tmgr_subport_profile(char **tokens,
 405         uint32_t n_tokens,
 406         char *out,
 407         size_t out_size)
 408 {
 409         struct rte_sched_subport_params p;
 410         int status, i;
 411
 412         if (n_tokens != 35) {
 413                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 414                 return;
 415         }
 416
 417         if (parser_read_uint64(&p.tb_rate, tokens[3]) != 0) {
 418                 snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate");
 419                 return;
 420         }
 421
 422         if (parser_read_uint64(&p.tb_size, tokens[4]) != 0) {
 423                 snprintf(out, out_size, MSG_ARG_INVALID, "tb_size");
 424                 return;
 425         }
 426
 427         for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
 428                 if (parser_read_uint64(&p.tc_rate[i], tokens[5 + i]) != 0) {
 429                         snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate");
 430                         return;
 431                 }
 432
 433         if (parser_read_uint64(&p.tc_period, tokens[18]) != 0) {
 434                 snprintf(out, out_size, MSG_ARG_INVALID, "tc_period");
 435                 return;
 436         }
 437
 438         if (strcmp(tokens[19], "pps") != 0) {
 439                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pps");
 440                 return;
 441         }
 442
 443         if (parser_read_uint32(&p.n_pipes_per_subport_enabled, tokens[20]) != 0) {
 444                 snprintf(out, out_size, MSG_ARG_INVALID, "n_pipes_per_subport");
 445                 return;
 446         }
 447
 448         if (strcmp(tokens[21], "qsize") != 0) {
 449                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "qsize");
 450                 return;
 451         }
 452
 453         for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
 454                 if (parser_read_uint16(&p.qsize[i], tokens[22 + i]) != 0) {
 455                         snprintf(out, out_size, MSG_ARG_INVALID, "qsize");
 456                         return;
 457                 }
 458
 459         status = tmgr_subport_profile_add(&p);
 460         if (status != 0) {
 461                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 462                 return;
 463         }
 464 }
 465
 466 static const char cmd_tmgr_pipe_profile_help[] =
 467 "tmgr pipe profile\n"
 468 "   <tb_rate> <tb_size>\n"
 469 "   <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate> <tc4_rate>"
 470 "     <tc5_rate> <tc6_rate> <tc7_rate> <tc8_rate>"
 471 "     <tc9_rate> <tc10_rate> <tc11_rate> <tc12_rate>\n"
 472 "   <tc_period>\n"
 473 "   <tc_ov_weight>\n"
 474 "   <wrr_weight0..3>\n";
 475
 476 static void
 477 cmd_tmgr_pipe_profile(char **tokens,
 478         uint32_t n_tokens,
 479         char *out,
 480         size_t out_size)
 481 {
 482         struct rte_sched_pipe_params p;
 483         int status, i;
 484
 485         if (n_tokens != 24) {
 486                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 487                 return;
 488         }
 489
 490         if (parser_read_uint64(&p.tb_rate, tokens[3]) != 0) {
 491                 snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate");
 492                 return;
 493         }
 494
 495         if (parser_read_uint64(&p.tb_size, tokens[4]) != 0) {
 496                 snprintf(out, out_size, MSG_ARG_INVALID, "tb_size");
 497                 return;
 498         }
 499
 500         for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
 501                 if (parser_read_uint64(&p.tc_rate[i], tokens[5 + i]) != 0) {
 502                         snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate");
 503                         return;
 504                 }
 505
 506         if (parser_read_uint64(&p.tc_period, tokens[18]) != 0) {
 507                 snprintf(out, out_size, MSG_ARG_INVALID, "tc_period");
 508                 return;
 509         }
 510
 511         if (parser_read_uint8(&p.tc_ov_weight, tokens[19]) != 0) {
 512                 snprintf(out, out_size, MSG_ARG_INVALID, "tc_ov_weight");
 513                 return;
 514         }
 515
 516         for (i = 0; i < RTE_SCHED_BE_QUEUES_PER_PIPE; i++)
 517                 if (parser_read_uint8(&p.wrr_weights[i], tokens[20 + i]) != 0) {
 518                         snprintf(out, out_size, MSG_ARG_INVALID, "wrr_weights");
 519                         return;
 520                 }
 521
 522         status = tmgr_pipe_profile_add(&p);
 523         if (status != 0) {
 524                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 525                 return;
 526         }
 527 }
 528
 529 static const char cmd_tmgr_help[] =
 530 "tmgr <tmgr_name>\n"
 531 "   rate <rate>\n"
 532 "   spp <n_subports_per_port>\n"
 533 "   fo <frame_overhead>\n"
 534 "   mtu <mtu>\n"
 535 "   cpu <cpu_id>\n";
 536
 537 static void
 538 cmd_tmgr(char **tokens,
 539         uint32_t n_tokens,
 540         char *out,
 541         size_t out_size)
 542 {
 543         struct tmgr_port_params p;
 544         char *name;
 545         struct tmgr_port *tmgr_port;
 546
 547         if (n_tokens != 12) {
 548                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 549                 return;
 550         }
 551
 552         name = tokens[1];
 553
 554         if (strcmp(tokens[2], "rate") != 0) {
 555                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rate");
 556                 return;
 557         }
 558
 559         if (parser_read_uint64(&p.rate, tokens[3]) != 0) {
 560                 snprintf(out, out_size, MSG_ARG_INVALID, "rate");
 561                 return;
 562         }
 563
 564         if (strcmp(tokens[4], "spp") != 0) {
 565                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp");
 566                 return;
 567         }
 568
 569         if (parser_read_uint32(&p.n_subports_per_port, tokens[5]) != 0) {
 570                 snprintf(out, out_size, MSG_ARG_INVALID, "n_subports_per_port");
 571                 return;
 572         }
 573
 574         if (strcmp(tokens[6], "fo") != 0) {
 575                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fo");
 576                 return;
 577         }
 578
 579         if (parser_read_uint32(&p.frame_overhead, tokens[7]) != 0) {
 580                 snprintf(out, out_size, MSG_ARG_INVALID, "frame_overhead");
 581                 return;
 582         }
 583
 584         if (strcmp(tokens[8], "mtu") != 0) {
 585                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mtu");
 586                 return;
 587         }
 588
 589         if (parser_read_uint32(&p.mtu, tokens[9]) != 0) {
 590                 snprintf(out, out_size, MSG_ARG_INVALID, "mtu");
 591                 return;
 592         }
 593
 594         if (strcmp(tokens[10], "cpu") != 0) {
 595                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
 596                 return;
 597         }
 598
 599         if (parser_read_uint32(&p.cpu_id, tokens[11]) != 0) {
 600                 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
 601                 return;
 602         }
 603
 604         tmgr_port = tmgr_port_create(name, &p);
 605         if (tmgr_port == NULL) {
 606                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 607                 return;
 608         }
 609 }
 610
 611 static const char cmd_tmgr_subport_help[] =
 612 "tmgr <tmgr_name> subport <subport_id>\n"
 613 "   profile <subport_profile_id>\n";
 614
 615 static void
 616 cmd_tmgr_subport(char **tokens,
 617         uint32_t n_tokens,
 618         char *out,
 619         size_t out_size)
 620 {
 621         uint32_t subport_id, subport_profile_id;
 622         int status;
 623         char *name;
 624
 625         if (n_tokens != 6) {
 626                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 627                 return;
 628         }
 629
 630         name = tokens[1];
 631
 632         if (parser_read_uint32(&subport_id, tokens[3]) != 0) {
 633                 snprintf(out, out_size, MSG_ARG_INVALID, "subport_id");
 634                 return;
 635         }
 636
 637         if (parser_read_uint32(&subport_profile_id, tokens[5]) != 0) {
 638                 snprintf(out, out_size, MSG_ARG_INVALID, "subport_profile_id");
 639                 return;
 640         }
 641
 642         status = tmgr_subport_config(name, subport_id, subport_profile_id);
 643         if (status) {
 644                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 645                 return;
 646         }
 647 }
 648
 649
 650 static const char cmd_tmgr_subport_pipe_help[] =
 651 "tmgr <tmgr_name> subport <subport_id> pipe\n"
 652 "   from <pipe_id_first> to <pipe_id_last>\n"
 653 "   profile <pipe_profile_id>\n";
 654
 655 static void
 656 cmd_tmgr_subport_pipe(char **tokens,
 657         uint32_t n_tokens,
 658         char *out,
 659         size_t out_size)
 660 {
 661         uint32_t subport_id, pipe_id_first, pipe_id_last, pipe_profile_id;
 662         int status;
 663         char *name;
 664
 665         if (n_tokens != 11) {
 666                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 667                 return;
 668         }
 669
 670         name = tokens[1];
 671
 672         if (parser_read_uint32(&subport_id, tokens[3]) != 0) {
 673                 snprintf(out, out_size, MSG_ARG_INVALID, "subport_id");
 674                 return;
 675         }
 676
 677         if (strcmp(tokens[4], "pipe") != 0) {
 678                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipe");
 679                 return;
 680         }
 681
 682         if (strcmp(tokens[5], "from") != 0) {
 683                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "from");
 684                 return;
 685         }
 686
 687         if (parser_read_uint32(&pipe_id_first, tokens[6]) != 0) {
 688                 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_first");
 689                 return;
 690         }
 691
 692         if (strcmp(tokens[7], "to") != 0) {
 693                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "to");
 694                 return;
 695         }
 696
 697         if (parser_read_uint32(&pipe_id_last, tokens[8]) != 0) {
 698                 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_last");
 699                 return;
 700         }
 701
 702         if (strcmp(tokens[9], "profile") != 0) {
 703                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
 704                 return;
 705         }
 706
 707         if (parser_read_uint32(&pipe_profile_id, tokens[10]) != 0) {
 708                 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_profile_id");
 709                 return;
 710         }
 711
 712         status = tmgr_pipe_config(name, subport_id, pipe_id_first,
 713                         pipe_id_last, pipe_profile_id);
 714         if (status) {
 715                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 716                 return;
 717         }
 718 }
 719
 720
 721 static const char cmd_tap_help[] =
 722 "tap <tap_name>\n";
 723
 724 static void
 725 cmd_tap(char **tokens,
 726         uint32_t n_tokens,
 727         char *out,
 728         size_t out_size)
 729 {
 730         char *name;
 731         struct tap *tap;
 732
 733         if (n_tokens != 2) {
 734                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 735                 return;
 736         }
 737
 738         name = tokens[1];
 739
 740         tap = tap_create(name);
 741         if (tap == NULL) {
 742                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 743                 return;
 744         }
 745 }
 746
 747 static const char cmd_kni_help[] =
 748 "kni <kni_name>\n"
 749 "   link <link_name>\n"
 750 "   mempool <mempool_name>\n"
 751 "   [thread <thread_id>]\n";
 752
 753 static void
 754 cmd_kni(char **tokens,
 755         uint32_t n_tokens,
 756         char *out,
 757         size_t out_size)
 758 {
 759         struct kni_params p;
 760         char *name;
 761         struct kni *kni;
 762
 763         memset(&p, 0, sizeof(p));
 764         if ((n_tokens != 6) && (n_tokens != 8)) {
 765                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 766                 return;
 767         }
 768
 769         name = tokens[1];
 770
 771         if (strcmp(tokens[2], "link") != 0) {
 772                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "link");
 773                 return;
 774         }
 775
 776         p.link_name = tokens[3];
 777
 778         if (strcmp(tokens[4], "mempool") != 0) {
 779                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mempool");
 780                 return;
 781         }
 782
 783         p.mempool_name = tokens[5];
 784
 785         if (n_tokens == 8) {
 786                 if (strcmp(tokens[6], "thread") != 0) {
 787                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "thread");
 788                         return;
 789                 }
 790
 791                 if (parser_read_uint32(&p.thread_id, tokens[7]) != 0) {
 792                         snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
 793                         return;
 794                 }
 795
 796                 p.force_bind = 1;
 797         } else
 798                 p.force_bind = 0;
 799
 800         kni = kni_create(name, &p);
 801         if (kni == NULL) {
 802                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 803                 return;
 804         }
 805 }
 806
 807 static const char cmd_cryptodev_help[] =
 808 "cryptodev <cryptodev_name>\n"
 809 "   dev <device_name> | dev_id <device_id>\n"
 810 "   queue <n_queues> <queue_size>\n"
 811 "   max_sessions <n_sessions>";
 812
 813 static void
 814 cmd_cryptodev(char **tokens,
 815         uint32_t n_tokens,
 816         char *out,
 817         size_t out_size)
 818 {
 819         struct cryptodev_params params;
 820         char *name;
 821
 822         memset(&params, 0, sizeof(params));
 823         if (n_tokens != 9) {
 824                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 825                 return;
 826         }
 827
 828         name = tokens[1];
 829
 830         if (strcmp(tokens[2], "dev") == 0)
 831                 params.dev_name = tokens[3];
 832         else if (strcmp(tokens[2], "dev_id") == 0) {
 833                 if (parser_read_uint32(&params.dev_id, tokens[3]) < 0) {
 834                         snprintf(out, out_size, MSG_ARG_INVALID,
 835                                 "dev_id");
 836                         return;
 837                 }
 838         } else {
 839                 snprintf(out, out_size, MSG_ARG_INVALID,
 840                         "cryptodev");
 841                 return;
 842         }
 843
 844         if (strcmp(tokens[4], "queue")) {
 845                 snprintf(out, out_size, MSG_ARG_NOT_FOUND,
 846                         "queue");
 847                 return;
 848         }
 849
 850         if (parser_read_uint32(&params.n_queues, tokens[5]) < 0) {
 851                 snprintf(out, out_size, MSG_ARG_INVALID,
 852                         "q");
 853                 return;
 854         }
 855
 856         if (parser_read_uint32(&params.queue_size, tokens[6]) < 0) {
 857                 snprintf(out, out_size, MSG_ARG_INVALID,
 858                         "queue_size");
 859                 return;
 860         }
 861
 862         if (strcmp(tokens[7], "max_sessions")) {
 863                 snprintf(out, out_size, MSG_ARG_NOT_FOUND,
 864                         "max_sessions");
 865                 return;
 866         }
 867
 868         if (parser_read_uint32(&params.session_pool_size, tokens[8]) < 0) {
 869                 snprintf(out, out_size, MSG_ARG_INVALID,
 870                         "queue_size");
 871                 return;
 872         }
 873
 874         if (cryptodev_create(name, &params) == NULL) {
 875                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
 876                 return;
 877         }
 878 }
 879
 880 static const char cmd_port_in_action_profile_help[] =
 881 "port in action profile <profile_name>\n"
 882 "   [filter match | mismatch offset <key_offset> mask <key_mask> key <key_value> port <port_id>]\n"
 883 "   [balance offset <key_offset> mask <key_mask> port <port_id0> ... <port_id15>]\n";
 884
 885 static void
 886 cmd_port_in_action_profile(char **tokens,
 887         uint32_t n_tokens,
 888         char *out,
 889         size_t out_size)
 890 {
 891         struct port_in_action_profile_params p;
 892         struct port_in_action_profile *ap;
 893         char *name;
 894         uint32_t t0;
 895
 896         memset(&p, 0, sizeof(p));
 897
 898         if (n_tokens < 5) {
 899                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
 900                 return;
 901         }
 902
 903         if (strcmp(tokens[1], "in") != 0) {
 904                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
 905                 return;
 906         }
 907
 908         if (strcmp(tokens[2], "action") != 0) {
 909                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action");
 910                 return;
 911         }
 912
 913         if (strcmp(tokens[3], "profile") != 0) {
 914                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
 915                 return;
 916         }
 917
 918         name = tokens[4];
 919
 920         t0 = 5;
 921
 922         if ((t0 < n_tokens) && (strcmp(tokens[t0], "filter") == 0)) {
 923                 uint32_t size;
 924
 925                 if (n_tokens < t0 + 10) {
 926                         snprintf(out, out_size, MSG_ARG_MISMATCH, "port in action profile filter");
 927                         return;
 928                 }
 929
 930                 if (strcmp(tokens[t0 + 1], "match") == 0)
 931                         p.fltr.filter_on_match = 1;
 932                 else if (strcmp(tokens[t0 + 1], "mismatch") == 0)
 933                         p.fltr.filter_on_match = 0;
 934                 else {
 935                         snprintf(out, out_size, MSG_ARG_INVALID, "match or mismatch");
 936                         return;
 937                 }
 938
 939                 if (strcmp(tokens[t0 + 2], "offset") != 0) {
 940                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
 941                         return;
 942                 }
 943
 944                 if (parser_read_uint32(&p.fltr.key_offset, tokens[t0 + 3]) != 0) {
 945                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
 946                         return;
 947                 }
 948
 949                 if (strcmp(tokens[t0 + 4], "mask") != 0) {
 950                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
 951                         return;
 952                 }
 953
 954                 size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE;
 955                 if ((parse_hex_string(tokens[t0 + 5], p.fltr.key_mask, &size) != 0) ||
 956                         (size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) {
 957                         snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
 958                         return;
 959                 }
 960
 961                 if (strcmp(tokens[t0 + 6], "key") != 0) {
 962                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key");
 963                         return;
 964                 }
 965
 966                 size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE;
 967                 if ((parse_hex_string(tokens[t0 + 7], p.fltr.key, &size) != 0) ||
 968                         (size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) {
 969                         snprintf(out, out_size, MSG_ARG_INVALID, "key_value");
 970                         return;
 971                 }
 972
 973                 if (strcmp(tokens[t0 + 8], "port") != 0) {
 974                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
 975                         return;
 976                 }
 977
 978                 if (parser_read_uint32(&p.fltr.port_id, tokens[t0 + 9]) != 0) {
 979                         snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
 980                         return;
 981                 }
 982
 983                 p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_FLTR;
 984                 t0 += 10;
 985         } /* filter */
 986
 987         if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) {
 988                 uint32_t i;
 989
 990                 if (n_tokens < t0 + 22) {
 991                         snprintf(out, out_size, MSG_ARG_MISMATCH,
 992                                 "port in action profile balance");
 993                         return;
 994                 }
 995
 996                 if (strcmp(tokens[t0 + 1], "offset") != 0) {
 997                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
 998                         return;
 999                 }
1000
1001                 if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) {
1002                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
1003                         return;
1004                 }
1005
1006                 if (strcmp(tokens[t0 + 3], "mask") != 0) {
1007                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
1008                         return;
1009                 }
1010
1011                 p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX;
1012                 if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) {
1013                         snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
1014                         return;
1015                 }
1016
1017                 if (strcmp(tokens[t0 + 5], "port") != 0) {
1018                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
1019                         return;
1020                 }
1021
1022                 for (i = 0; i < 16; i++)
1023                         if (parser_read_uint32(&p.lb.port_id[i], tokens[t0 + 6 + i]) != 0) {
1024                                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
1025                                 return;
1026                         }
1027
1028                 p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_LB;
1029                 t0 += 22;
1030         } /* balance */
1031
1032         if (t0 < n_tokens) {
1033                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1034                 return;
1035         }
1036
1037         ap = port_in_action_profile_create(name, &p);
1038         if (ap == NULL) {
1039                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
1040                 return;
1041         }
1042 }
1043
1044
1045 static const char cmd_table_action_profile_help[] =
1046 "table action profile <profile_name>\n"
1047 "   ipv4 | ipv6\n"
1048 "   offset <ip_offset>\n"
1049 "   fwd\n"
1050 "   [balance offset <key_offset> mask <key_mask> outoffset <out_offset>]\n"
1051 "   [meter srtcm | trtcm\n"
1052 "       tc <n_tc>\n"
1053 "       stats none | pkts | bytes | both]\n"
1054 "   [tm spp <n_subports_per_port> pps <n_pipes_per_subport>]\n"
1055 "   [encap ether | vlan | qinq | mpls | pppoe | qinq_pppoe \n"
1056 "       vxlan offset <ether_offset> ipv4 | ipv6 vlan on | off]\n"
1057 "   [nat src | dst\n"
1058 "       proto udp | tcp]\n"
1059 "   [ttl drop | fwd\n"
1060 "       stats none | pkts]\n"
1061 "   [stats pkts | bytes | both]\n"
1062 "   [time]\n"
1063 "   [sym_crypto dev <CRYPTODEV_NAME> offset <op_offset>]\n"
1064 "   [tag]\n"
1065 "   [decap]\n";
1066
1067 static void
1068 cmd_table_action_profile(char **tokens,
1069         uint32_t n_tokens,
1070         char *out,
1071         size_t out_size)
1072 {
1073         struct table_action_profile_params p;
1074         struct table_action_profile *ap;
1075         char *name;
1076         uint32_t t0;
1077
1078         memset(&p, 0, sizeof(p));
1079
1080         if (n_tokens < 8) {
1081                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1082                 return;
1083         }
1084
1085         if (strcmp(tokens[1], "action") != 0) {
1086                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action");
1087                 return;
1088         }
1089
1090         if (strcmp(tokens[2], "profile") != 0) {
1091                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
1092                 return;
1093         }
1094
1095         name = tokens[3];
1096
1097         if (strcmp(tokens[4], "ipv4") == 0)
1098                 p.common.ip_version = 1;
1099         else if (strcmp(tokens[4], "ipv6") == 0)
1100                 p.common.ip_version = 0;
1101         else {
1102                 snprintf(out, out_size, MSG_ARG_INVALID, "ipv4 or ipv6");
1103                 return;
1104         }
1105
1106         if (strcmp(tokens[5], "offset") != 0) {
1107                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
1108                 return;
1109         }
1110
1111         if (parser_read_uint32(&p.common.ip_offset, tokens[6]) != 0) {
1112                 snprintf(out, out_size, MSG_ARG_INVALID, "ip_offset");
1113                 return;
1114         }
1115
1116         if (strcmp(tokens[7], "fwd") != 0) {
1117                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fwd");
1118                 return;
1119         }
1120
1121         p.action_mask |= 1LLU << RTE_TABLE_ACTION_FWD;
1122
1123         t0 = 8;
1124         if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) {
1125                 if (n_tokens < t0 + 7) {
1126                         snprintf(out, out_size, MSG_ARG_MISMATCH, "table action profile balance");
1127                         return;
1128                 }
1129
1130                 if (strcmp(tokens[t0 + 1], "offset") != 0) {
1131                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
1132                         return;
1133                 }
1134
1135                 if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) {
1136                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
1137                         return;
1138                 }
1139
1140                 if (strcmp(tokens[t0 + 3], "mask") != 0) {
1141                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
1142                         return;
1143                 }
1144
1145                 p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX;
1146                 if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) {
1147                         snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
1148                         return;
1149                 }
1150
1151                 if (strcmp(tokens[t0 + 5], "outoffset") != 0) {
1152                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "outoffset");
1153                         return;
1154                 }
1155
1156                 if (parser_read_uint32(&p.lb.out_offset, tokens[t0 + 6]) != 0) {
1157                         snprintf(out, out_size, MSG_ARG_INVALID, "out_offset");
1158                         return;
1159                 }
1160
1161                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_LB;
1162                 t0 += 7;
1163         } /* balance */
1164
1165         if ((t0 < n_tokens) && (strcmp(tokens[t0], "meter") == 0)) {
1166                 if (n_tokens < t0 + 6) {
1167                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1168                                 "table action profile meter");
1169                         return;
1170                 }
1171
1172                 if (strcmp(tokens[t0 + 1], "srtcm") == 0)
1173                         p.mtr.alg = RTE_TABLE_ACTION_METER_SRTCM;
1174                 else if (strcmp(tokens[t0 + 1], "trtcm") == 0)
1175                         p.mtr.alg = RTE_TABLE_ACTION_METER_TRTCM;
1176                 else {
1177                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1178                                 "srtcm or trtcm");
1179                         return;
1180                 }
1181
1182                 if (strcmp(tokens[t0 + 2], "tc") != 0) {
1183                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc");
1184                         return;
1185                 }
1186
1187                 if (parser_read_uint32(&p.mtr.n_tc, tokens[t0 + 3]) != 0) {
1188                         snprintf(out, out_size, MSG_ARG_INVALID, "n_tc");
1189                         return;
1190                 }
1191
1192                 if (strcmp(tokens[t0 + 4], "stats") != 0) {
1193                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
1194                         return;
1195                 }
1196
1197                 if (strcmp(tokens[t0 + 5], "none") == 0) {
1198                         p.mtr.n_packets_enabled = 0;
1199                         p.mtr.n_bytes_enabled = 0;
1200                 } else if (strcmp(tokens[t0 + 5], "pkts") == 0) {
1201                         p.mtr.n_packets_enabled = 1;
1202                         p.mtr.n_bytes_enabled = 0;
1203                 } else if (strcmp(tokens[t0 + 5], "bytes") == 0) {
1204                         p.mtr.n_packets_enabled = 0;
1205                         p.mtr.n_bytes_enabled = 1;
1206                 } else if (strcmp(tokens[t0 + 5], "both") == 0) {
1207                         p.mtr.n_packets_enabled = 1;
1208                         p.mtr.n_bytes_enabled = 1;
1209                 } else {
1210                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1211                                 "none or pkts or bytes or both");
1212                         return;
1213                 }
1214
1215                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_MTR;
1216                 t0 += 6;
1217         } /* meter */
1218
1219         if ((t0 < n_tokens) && (strcmp(tokens[t0], "tm") == 0)) {
1220                 if (n_tokens < t0 + 5) {
1221                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1222                                 "table action profile tm");
1223                         return;
1224                 }
1225
1226                 if (strcmp(tokens[t0 + 1], "spp") != 0) {
1227                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp");
1228                         return;
1229                 }
1230
1231                 if (parser_read_uint32(&p.tm.n_subports_per_port,
1232                         tokens[t0 + 2]) != 0) {
1233                         snprintf(out, out_size, MSG_ARG_INVALID,
1234                                 "n_subports_per_port");
1235                         return;
1236                 }
1237
1238                 if (strcmp(tokens[t0 + 3], "pps") != 0) {
1239                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pps");
1240                         return;
1241                 }
1242
1243                 if (parser_read_uint32(&p.tm.n_pipes_per_subport,
1244                         tokens[t0 + 4]) != 0) {
1245                         snprintf(out, out_size, MSG_ARG_INVALID,
1246                                 "n_pipes_per_subport");
1247                         return;
1248                 }
1249
1250                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TM;
1251                 t0 += 5;
1252         } /* tm */
1253
1254         if ((t0 < n_tokens) && (strcmp(tokens[t0], "encap") == 0)) {
1255                 uint32_t n_extra_tokens = 0;
1256
1257                 if (n_tokens < t0 + 2) {
1258                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1259                                 "action profile encap");
1260                         return;
1261                 }
1262
1263                 if (strcmp(tokens[t0 + 1], "ether") == 0)
1264                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_ETHER;
1265                 else if (strcmp(tokens[t0 + 1], "vlan") == 0)
1266                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VLAN;
1267                 else if (strcmp(tokens[t0 + 1], "qinq") == 0)
1268                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_QINQ;
1269                 else if (strcmp(tokens[t0 + 1], "mpls") == 0)
1270                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_MPLS;
1271                 else if (strcmp(tokens[t0 + 1], "pppoe") == 0)
1272                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_PPPOE;
1273                 else if (strcmp(tokens[t0 + 1], "vxlan") == 0) {
1274                         if (n_tokens < t0 + 2 + 5) {
1275                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
1276                                         "action profile encap vxlan");
1277                                 return;
1278                         }
1279
1280                         if (strcmp(tokens[t0 + 2], "offset") != 0) {
1281                                 snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1282                                         "vxlan: offset");
1283                                 return;
1284                         }
1285
1286                         if (parser_read_uint32(&p.encap.vxlan.data_offset,
1287                                 tokens[t0 + 2 + 1]) != 0) {
1288                                 snprintf(out, out_size, MSG_ARG_INVALID,
1289                                         "vxlan: ether_offset");
1290                                 return;
1291                         }
1292
1293                         if (strcmp(tokens[t0 + 2 + 2], "ipv4") == 0)
1294                                 p.encap.vxlan.ip_version = 1;
1295                         else if (strcmp(tokens[t0 + 2 + 2], "ipv6") == 0)
1296                                 p.encap.vxlan.ip_version = 0;
1297                         else {
1298                                 snprintf(out, out_size, MSG_ARG_INVALID,
1299                                         "vxlan: ipv4 or ipv6");
1300                                 return;
1301                         }
1302
1303                         if (strcmp(tokens[t0 + 2 + 3], "vlan") != 0) {
1304                                 snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1305                                         "vxlan: vlan");
1306                                 return;
1307                         }
1308
1309                         if (strcmp(tokens[t0 + 2 + 4], "on") == 0)
1310                                 p.encap.vxlan.vlan = 1;
1311                         else if (strcmp(tokens[t0 + 2 + 4], "off") == 0)
1312                                 p.encap.vxlan.vlan = 0;
1313                         else {
1314                                 snprintf(out, out_size, MSG_ARG_INVALID,
1315                                         "vxlan: on or off");
1316                                 return;
1317                         }
1318
1319                         p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VXLAN;
1320                         n_extra_tokens = 5;
1321                 } else if (strcmp(tokens[t0 + 1], "qinq_pppoe") == 0)
1322                         p.encap.encap_mask =
1323                                 1LLU << RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
1324                 else {
1325                         snprintf(out, out_size, MSG_ARG_MISMATCH, "encap");
1326                         return;
1327                 }
1328
1329                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_ENCAP;
1330                 t0 += 2 + n_extra_tokens;
1331         } /* encap */
1332
1333         if ((t0 < n_tokens) && (strcmp(tokens[t0], "nat") == 0)) {
1334                 if (n_tokens < t0 + 4) {
1335                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1336                                 "table action profile nat");
1337                         return;
1338                 }
1339
1340                 if (strcmp(tokens[t0 + 1], "src") == 0)
1341                         p.nat.source_nat = 1;
1342                 else if (strcmp(tokens[t0 + 1], "dst") == 0)
1343                         p.nat.source_nat = 0;
1344                 else {
1345                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1346                                 "src or dst");
1347                         return;
1348                 }
1349
1350                 if (strcmp(tokens[t0 + 2], "proto") != 0) {
1351                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "proto");
1352                         return;
1353                 }
1354
1355                 if (strcmp(tokens[t0 + 3], "tcp") == 0)
1356                         p.nat.proto = 0x06;
1357                 else if (strcmp(tokens[t0 + 3], "udp") == 0)
1358                         p.nat.proto = 0x11;
1359                 else {
1360                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1361                                 "tcp or udp");
1362                         return;
1363                 }
1364
1365                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_NAT;
1366                 t0 += 4;
1367         } /* nat */
1368
1369         if ((t0 < n_tokens) && (strcmp(tokens[t0], "ttl") == 0)) {
1370                 if (n_tokens < t0 + 4) {
1371                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1372                                 "table action profile ttl");
1373                         return;
1374                 }
1375
1376                 if (strcmp(tokens[t0 + 1], "drop") == 0)
1377                         p.ttl.drop = 1;
1378                 else if (strcmp(tokens[t0 + 1], "fwd") == 0)
1379                         p.ttl.drop = 0;
1380                 else {
1381                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1382                                 "drop or fwd");
1383                         return;
1384                 }
1385
1386                 if (strcmp(tokens[t0 + 2], "stats") != 0) {
1387                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
1388                         return;
1389                 }
1390
1391                 if (strcmp(tokens[t0 + 3], "none") == 0)
1392                         p.ttl.n_packets_enabled = 0;
1393                 else if (strcmp(tokens[t0 + 3], "pkts") == 0)
1394                         p.ttl.n_packets_enabled = 1;
1395                 else {
1396                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1397                                 "none or pkts");
1398                         return;
1399                 }
1400
1401                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TTL;
1402                 t0 += 4;
1403         } /* ttl */
1404
1405         if ((t0 < n_tokens) && (strcmp(tokens[t0], "stats") == 0)) {
1406                 if (n_tokens < t0 + 2) {
1407                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1408                                 "table action profile stats");
1409                         return;
1410                 }
1411
1412                 if (strcmp(tokens[t0 + 1], "pkts") == 0) {
1413                         p.stats.n_packets_enabled = 1;
1414                         p.stats.n_bytes_enabled = 0;
1415                 } else if (strcmp(tokens[t0 + 1], "bytes") == 0) {
1416                         p.stats.n_packets_enabled = 0;
1417                         p.stats.n_bytes_enabled = 1;
1418                 } else if (strcmp(tokens[t0 + 1], "both") == 0) {
1419                         p.stats.n_packets_enabled = 1;
1420                         p.stats.n_bytes_enabled = 1;
1421                 } else {
1422                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1423                                 "pkts or bytes or both");
1424                         return;
1425                 }
1426
1427                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_STATS;
1428                 t0 += 2;
1429         } /* stats */
1430
1431         if ((t0 < n_tokens) && (strcmp(tokens[t0], "time") == 0)) {
1432                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TIME;
1433                 t0 += 1;
1434         } /* time */
1435
1436         if ((t0 < n_tokens) && (strcmp(tokens[t0], "sym_crypto") == 0)) {
1437                 struct cryptodev *cryptodev;
1438
1439                 if (n_tokens < t0 + 5 ||
1440                                 strcmp(tokens[t0 + 1], "dev") ||
1441                                 strcmp(tokens[t0 + 3], "offset")) {
1442                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1443                                 "table action profile sym_crypto");
1444                         return;
1445                 }
1446
1447                 cryptodev = cryptodev_find(tokens[t0 + 2]);
1448                 if (cryptodev == NULL) {
1449                         snprintf(out, out_size, MSG_ARG_INVALID,
1450                                 "table action profile sym_crypto");
1451                         return;
1452                 }
1453
1454                 p.sym_crypto.cryptodev_id = cryptodev->dev_id;
1455
1456                 if (parser_read_uint32(&p.sym_crypto.op_offset,
1457                                 tokens[t0 + 4]) != 0) {
1458                         snprintf(out, out_size, MSG_ARG_INVALID,
1459                                         "table action profile sym_crypto");
1460                         return;
1461                 }
1462
1463                 p.sym_crypto.mp_create = cryptodev->mp_create;
1464                 p.sym_crypto.mp_init = cryptodev->mp_init;
1465
1466                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_SYM_CRYPTO;
1467
1468                 t0 += 5;
1469         } /* sym_crypto */
1470
1471         if ((t0 < n_tokens) && (strcmp(tokens[t0], "tag") == 0)) {
1472                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TAG;
1473                 t0 += 1;
1474         } /* tag */
1475
1476         if ((t0 < n_tokens) && (strcmp(tokens[t0], "decap") == 0)) {
1477                 p.action_mask |= 1LLU << RTE_TABLE_ACTION_DECAP;
1478                 t0 += 1;
1479         } /* decap */
1480
1481         if (t0 < n_tokens) {
1482                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1483                 return;
1484         }
1485
1486         ap = table_action_profile_create(name, &p);
1487         if (ap == NULL) {
1488                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
1489                 return;
1490         }
1491 }
1492
1493 static const char cmd_pipeline_help[] =
1494 "pipeline <pipeline_name>\n"
1495 "   period <timer_period_ms>\n"
1496 "   offset_port_id <offset_port_id>\n"
1497 "   cpu <cpu_id>\n";
1498
1499 static void
1500 cmd_pipeline(char **tokens,
1501         uint32_t n_tokens,
1502         char *out,
1503         size_t out_size)
1504 {
1505         struct pipeline_params p;
1506         char *name;
1507         struct pipeline *pipeline;
1508
1509         if (n_tokens != 8) {
1510                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1511                 return;
1512         }
1513
1514         name = tokens[1];
1515
1516         if (strcmp(tokens[2], "period") != 0) {
1517                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "period");
1518                 return;
1519         }
1520
1521         if (parser_read_uint32(&p.timer_period_ms, tokens[3]) != 0) {
1522                 snprintf(out, out_size, MSG_ARG_INVALID, "timer_period_ms");
1523                 return;
1524         }
1525
1526         if (strcmp(tokens[4], "offset_port_id") != 0) {
1527                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset_port_id");
1528                 return;
1529         }
1530
1531         if (parser_read_uint32(&p.offset_port_id, tokens[5]) != 0) {
1532                 snprintf(out, out_size, MSG_ARG_INVALID, "offset_port_id");
1533                 return;
1534         }
1535
1536         if (strcmp(tokens[6], "cpu") != 0) {
1537                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
1538                 return;
1539         }
1540
1541         if (parser_read_uint32(&p.cpu_id, tokens[7]) != 0) {
1542                 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
1543                 return;
1544         }
1545
1546         pipeline = pipeline_create(name, &p);
1547         if (pipeline == NULL) {
1548                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
1549                 return;
1550         }
1551 }
1552
1553 static const char cmd_pipeline_port_in_help[] =
1554 "pipeline <pipeline_name> port in\n"
1555 "   bsz <burst_size>\n"
1556 "   link <link_name> rxq <queue_id>\n"
1557 "   | swq <swq_name>\n"
1558 "   | tmgr <tmgr_name>\n"
1559 "   | tap <tap_name> mempool <mempool_name> mtu <mtu>\n"
1560 "   | kni <kni_name>\n"
1561 "   | source mempool <mempool_name> file <file_name> bpp <n_bytes_per_pkt>\n"
1562 "   | cryptodev <cryptodev_name> rxq <queue_id>\n"
1563 "   [action <port_in_action_profile_name>]\n"
1564 "   [disabled]\n";
1565
1566 static void
1567 cmd_pipeline_port_in(char **tokens,
1568         uint32_t n_tokens,
1569         char *out,
1570         size_t out_size)
1571 {
1572         struct port_in_params p;
1573         char *pipeline_name;
1574         uint32_t t0;
1575         int enabled, status;
1576
1577         if (n_tokens < 7) {
1578                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1579                 return;
1580         }
1581
1582         pipeline_name = tokens[1];
1583
1584         if (strcmp(tokens[2], "port") != 0) {
1585                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
1586                 return;
1587         }
1588
1589         if (strcmp(tokens[3], "in") != 0) {
1590                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
1591                 return;
1592         }
1593
1594         if (strcmp(tokens[4], "bsz") != 0) {
1595                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
1596                 return;
1597         }
1598
1599         if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) {
1600                 snprintf(out, out_size, MSG_ARG_INVALID, "burst_size");
1601                 return;
1602         }
1603
1604         t0 = 6;
1605
1606         if (strcmp(tokens[t0], "link") == 0) {
1607                 if (n_tokens < t0 + 4) {
1608                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1609                                 "pipeline port in link");
1610                         return;
1611                 }
1612
1613                 p.type = PORT_IN_RXQ;
1614
1615                 p.dev_name = tokens[t0 + 1];
1616
1617                 if (strcmp(tokens[t0 + 2], "rxq") != 0) {
1618                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
1619                         return;
1620                 }
1621
1622                 if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) {
1623                         snprintf(out, out_size, MSG_ARG_INVALID,
1624                                 "queue_id");
1625                         return;
1626                 }
1627                 t0 += 4;
1628         } else if (strcmp(tokens[t0], "swq") == 0) {
1629                 if (n_tokens < t0 + 2) {
1630                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1631                                 "pipeline port in swq");
1632                         return;
1633                 }
1634
1635                 p.type = PORT_IN_SWQ;
1636
1637                 p.dev_name = tokens[t0 + 1];
1638
1639                 t0 += 2;
1640         } else if (strcmp(tokens[t0], "tmgr") == 0) {
1641                 if (n_tokens < t0 + 2) {
1642                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1643                                 "pipeline port in tmgr");
1644                         return;
1645                 }
1646
1647                 p.type = PORT_IN_TMGR;
1648
1649                 p.dev_name = tokens[t0 + 1];
1650
1651                 t0 += 2;
1652         } else if (strcmp(tokens[t0], "tap") == 0) {
1653                 if (n_tokens < t0 + 6) {
1654                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1655                                 "pipeline port in tap");
1656                         return;
1657                 }
1658
1659                 p.type = PORT_IN_TAP;
1660
1661                 p.dev_name = tokens[t0 + 1];
1662
1663                 if (strcmp(tokens[t0 + 2], "mempool") != 0) {
1664                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1665                                 "mempool");
1666                         return;
1667                 }
1668
1669                 p.tap.mempool_name = tokens[t0 + 3];
1670
1671                 if (strcmp(tokens[t0 + 4], "mtu") != 0) {
1672                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1673                                 "mtu");
1674                         return;
1675                 }
1676
1677                 if (parser_read_uint32(&p.tap.mtu, tokens[t0 + 5]) != 0) {
1678                         snprintf(out, out_size, MSG_ARG_INVALID, "mtu");
1679                         return;
1680                 }
1681
1682                 t0 += 6;
1683         } else if (strcmp(tokens[t0], "kni") == 0) {
1684                 if (n_tokens < t0 + 2) {
1685                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1686                                 "pipeline port in kni");
1687                         return;
1688                 }
1689
1690                 p.type = PORT_IN_KNI;
1691
1692                 p.dev_name = tokens[t0 + 1];
1693
1694                 t0 += 2;
1695         } else if (strcmp(tokens[t0], "source") == 0) {
1696                 if (n_tokens < t0 + 6) {
1697                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1698                                 "pipeline port in source");
1699                         return;
1700                 }
1701
1702                 p.type = PORT_IN_SOURCE;
1703
1704                 p.dev_name = NULL;
1705
1706                 if (strcmp(tokens[t0 + 1], "mempool") != 0) {
1707                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1708                                 "mempool");
1709                         return;
1710                 }
1711
1712                 p.source.mempool_name = tokens[t0 + 2];
1713
1714                 if (strcmp(tokens[t0 + 3], "file") != 0) {
1715                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1716                                 "file");
1717                         return;
1718                 }
1719
1720                 p.source.file_name = tokens[t0 + 4];
1721
1722                 if (strcmp(tokens[t0 + 5], "bpp") != 0) {
1723                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1724                                 "bpp");
1725                         return;
1726                 }
1727
1728                 if (parser_read_uint32(&p.source.n_bytes_per_pkt, tokens[t0 + 6]) != 0) {
1729                         snprintf(out, out_size, MSG_ARG_INVALID,
1730                                 "n_bytes_per_pkt");
1731                         return;
1732                 }
1733
1734                 t0 += 7;
1735         } else if (strcmp(tokens[t0], "cryptodev") == 0) {
1736                 if (n_tokens < t0 + 3) {
1737                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1738                                 "pipeline port in cryptodev");
1739                         return;
1740                 }
1741
1742                 p.type = PORT_IN_CRYPTODEV;
1743
1744                 p.dev_name = tokens[t0 + 1];
1745                 if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) {
1746                         snprintf(out, out_size, MSG_ARG_INVALID,
1747                                 "rxq");
1748                         return;
1749                 }
1750
1751                 p.cryptodev.arg_callback = NULL;
1752                 p.cryptodev.f_callback = NULL;
1753
1754                 t0 += 4;
1755         } else {
1756                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
1757                 return;
1758         }
1759
1760         p.action_profile_name = NULL;
1761         if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) {
1762                 if (n_tokens < t0 + 2) {
1763                         snprintf(out, out_size, MSG_ARG_MISMATCH, "action");
1764                         return;
1765                 }
1766
1767                 p.action_profile_name = tokens[t0 + 1];
1768
1769                 t0 += 2;
1770         }
1771
1772         enabled = 1;
1773         if ((n_tokens > t0) &&
1774                 (strcmp(tokens[t0], "disabled") == 0)) {
1775                 enabled = 0;
1776
1777                 t0 += 1;
1778         }
1779
1780         if (n_tokens != t0) {
1781                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1782                 return;
1783         }
1784
1785         status = pipeline_port_in_create(pipeline_name,
1786                 &p, enabled);
1787         if (status) {
1788                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
1789                 return;
1790         }
1791 }
1792
1793 static const char cmd_pipeline_port_out_help[] =
1794 "pipeline <pipeline_name> port out\n"
1795 "   bsz <burst_size>\n"
1796 "   link <link_name> txq <txq_id>\n"
1797 "   | swq <swq_name>\n"
1798 "   | tmgr <tmgr_name>\n"
1799 "   | tap <tap_name>\n"
1800 "   | kni <kni_name>\n"
1801 "   | sink [file <file_name> pkts <max_n_pkts>]\n"
1802 "   | cryptodev <cryptodev_name> txq <txq_id> offset <crypto_op_offset>\n";
1803
1804 static void
1805 cmd_pipeline_port_out(char **tokens,
1806         uint32_t n_tokens,
1807         char *out,
1808         size_t out_size)
1809 {
1810         struct port_out_params p;
1811         char *pipeline_name;
1812         int status;
1813
1814         memset(&p, 0, sizeof(p));
1815
1816         if (n_tokens < 7) {
1817                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1818                 return;
1819         }
1820
1821         pipeline_name = tokens[1];
1822
1823         if (strcmp(tokens[2], "port") != 0) {
1824                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
1825                 return;
1826         }
1827
1828         if (strcmp(tokens[3], "out") != 0) {
1829                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out");
1830                 return;
1831         }
1832
1833         if (strcmp(tokens[4], "bsz") != 0) {
1834                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
1835                 return;
1836         }
1837
1838         if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) {
1839                 snprintf(out, out_size, MSG_ARG_INVALID, "burst_size");
1840                 return;
1841         }
1842
1843         if (strcmp(tokens[6], "link") == 0) {
1844                 if (n_tokens != 10) {
1845                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1846                                 "pipeline port out link");
1847                         return;
1848                 }
1849
1850                 p.type = PORT_OUT_TXQ;
1851
1852                 p.dev_name = tokens[7];
1853
1854                 if (strcmp(tokens[8], "txq") != 0) {
1855                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
1856                         return;
1857                 }
1858
1859                 if (parser_read_uint16(&p.txq.queue_id, tokens[9]) != 0) {
1860                         snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
1861                         return;
1862                 }
1863         } else if (strcmp(tokens[6], "swq") == 0) {
1864                 if (n_tokens != 8) {
1865                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1866                                 "pipeline port out swq");
1867                         return;
1868                 }
1869
1870                 p.type = PORT_OUT_SWQ;
1871
1872                 p.dev_name = tokens[7];
1873         } else if (strcmp(tokens[6], "tmgr") == 0) {
1874                 if (n_tokens != 8) {
1875                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1876                                 "pipeline port out tmgr");
1877                         return;
1878                 }
1879
1880                 p.type = PORT_OUT_TMGR;
1881
1882                 p.dev_name = tokens[7];
1883         } else if (strcmp(tokens[6], "tap") == 0) {
1884                 if (n_tokens != 8) {
1885                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1886                                 "pipeline port out tap");
1887                         return;
1888                 }
1889
1890                 p.type = PORT_OUT_TAP;
1891
1892                 p.dev_name = tokens[7];
1893         } else if (strcmp(tokens[6], "kni") == 0) {
1894                 if (n_tokens != 8) {
1895                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1896                                 "pipeline port out kni");
1897                         return;
1898                 }
1899
1900                 p.type = PORT_OUT_KNI;
1901
1902                 p.dev_name = tokens[7];
1903         } else if (strcmp(tokens[6], "sink") == 0) {
1904                 if ((n_tokens != 7) && (n_tokens != 11)) {
1905                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1906                                 "pipeline port out sink");
1907                         return;
1908                 }
1909
1910                 p.type = PORT_OUT_SINK;
1911
1912                 p.dev_name = NULL;
1913
1914                 if (n_tokens == 7) {
1915                         p.sink.file_name = NULL;
1916                         p.sink.max_n_pkts = 0;
1917                 } else {
1918                         if (strcmp(tokens[7], "file") != 0) {
1919                                 snprintf(out, out_size, MSG_ARG_NOT_FOUND,
1920                                         "file");
1921                                 return;
1922                         }
1923
1924                         p.sink.file_name = tokens[8];
1925
1926                         if (strcmp(tokens[9], "pkts") != 0) {
1927                                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pkts");
1928                                 return;
1929                         }
1930
1931                         if (parser_read_uint32(&p.sink.max_n_pkts, tokens[10]) != 0) {
1932                                 snprintf(out, out_size, MSG_ARG_INVALID, "max_n_pkts");
1933                                 return;
1934                         }
1935                 }
1936
1937         } else if (strcmp(tokens[6], "cryptodev") == 0) {
1938                 if (n_tokens != 12) {
1939                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1940                                 "pipeline port out cryptodev");
1941                         return;
1942                 }
1943
1944                 p.type = PORT_OUT_CRYPTODEV;
1945
1946                 p.dev_name = tokens[7];
1947
1948                 if (strcmp(tokens[8], "txq")) {
1949                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1950                                 "pipeline port out cryptodev");
1951                         return;
1952                 }
1953
1954                 if (parser_read_uint16(&p.cryptodev.queue_id, tokens[9])
1955                                 != 0) {
1956                         snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
1957                         return;
1958                 }
1959
1960                 if (strcmp(tokens[10], "offset")) {
1961                         snprintf(out, out_size, MSG_ARG_MISMATCH,
1962                                 "pipeline port out cryptodev");
1963                         return;
1964                 }
1965
1966                 if (parser_read_uint32(&p.cryptodev.op_offset, tokens[11])
1967                                 != 0) {
1968                         snprintf(out, out_size, MSG_ARG_INVALID, "queue_id");
1969                         return;
1970                 }
1971         } else {
1972                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
1973                 return;
1974         }
1975
1976         status = pipeline_port_out_create(pipeline_name, &p);
1977         if (status) {
1978                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
1979                 return;
1980         }
1981 }
1982
1983 static const char cmd_pipeline_table_help[] =
1984 "pipeline <pipeline_name> table\n"
1985 "       match\n"
1986 "       acl\n"
1987 "           ipv4 | ipv6\n"
1988 "           offset <ip_header_offset>\n"
1989 "           size <n_rules>\n"
1990 "       | array\n"
1991 "           offset <key_offset>\n"
1992 "           size <n_keys>\n"
1993 "       | hash\n"
1994 "           ext | lru\n"
1995 "           key <key_size>\n"
1996 "           mask <key_mask>\n"
1997 "           offset <key_offset>\n"
1998 "           buckets <n_buckets>\n"
1999 "           size <n_keys>\n"
2000 "       | lpm\n"
2001 "           ipv4 | ipv6\n"
2002 "           offset <ip_header_offset>\n"
2003 "           size <n_rules>\n"
2004 "       | stub\n"
2005 "   [action <table_action_profile_name>]\n";
2006
2007 static void
2008 cmd_pipeline_table(char **tokens,
2009         uint32_t n_tokens,
2010         char *out,
2011         size_t out_size)
2012 {
2013         uint8_t key_mask[TABLE_RULE_MATCH_SIZE_MAX];
2014         struct table_params p;
2015         char *pipeline_name;
2016         uint32_t t0;
2017         int status;
2018
2019         if (n_tokens < 5) {
2020                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2021                 return;
2022         }
2023
2024         pipeline_name = tokens[1];
2025
2026         if (strcmp(tokens[2], "table") != 0) {
2027                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
2028                 return;
2029         }
2030
2031         if (strcmp(tokens[3], "match") != 0) {
2032                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
2033                 return;
2034         }
2035
2036         t0 = 4;
2037         if (strcmp(tokens[t0], "acl") == 0) {
2038                 if (n_tokens < t0 + 6) {
2039                         snprintf(out, out_size, MSG_ARG_MISMATCH,
2040                                 "pipeline table acl");
2041                         return;
2042                 }
2043
2044                 p.match_type = TABLE_ACL;
2045
2046                 if (strcmp(tokens[t0 + 1], "ipv4") == 0)
2047                         p.match.acl.ip_version = 1;
2048                 else if (strcmp(tokens[t0 + 1], "ipv6") == 0)
2049                         p.match.acl.ip_version = 0;
2050                 else {
2051                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
2052                                 "ipv4 or ipv6");
2053                         return;
2054                 }
2055
2056                 if (strcmp(tokens[t0 + 2], "offset") != 0) {
2057                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
2058                         return;
2059                 }
2060
2061                 if (parser_read_uint32(&p.match.acl.ip_header_offset,
2062                         tokens[t0 + 3]) != 0) {
2063                         snprintf(out, out_size, MSG_ARG_INVALID,
2064                                 "ip_header_offset");
2065                         return;
2066                 }
2067
2068                 if (strcmp(tokens[t0 + 4], "size") != 0) {
2069                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
2070                         return;
2071                 }
2072
2073                 if (parser_read_uint32(&p.match.acl.n_rules,
2074                         tokens[t0 + 5]) != 0) {
2075                         snprintf(out, out_size, MSG_ARG_INVALID, "n_rules");
2076                         return;
2077                 }
2078
2079                 t0 += 6;
2080         } else if (strcmp(tokens[t0], "array") == 0) {
2081                 if (n_tokens < t0 + 5) {
2082                         snprintf(out, out_size, MSG_ARG_MISMATCH,
2083                                 "pipeline table array");
2084                         return;
2085                 }
2086
2087                 p.match_type = TABLE_ARRAY;
2088
2089                 if (strcmp(tokens[t0 + 1], "offset") != 0) {
2090                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
2091                         return;
2092                 }
2093
2094                 if (parser_read_uint32(&p.match.array.key_offset,
2095                         tokens[t0 + 2]) != 0) {
2096                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
2097                         return;
2098                 }
2099
2100                 if (strcmp(tokens[t0 + 3], "size") != 0) {
2101                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
2102                         return;
2103                 }
2104
2105                 if (parser_read_uint32(&p.match.array.n_keys,
2106                         tokens[t0 + 4]) != 0) {
2107                         snprintf(out, out_size, MSG_ARG_INVALID, "n_keys");
2108                         return;
2109                 }
2110
2111                 t0 += 5;
2112         } else if (strcmp(tokens[t0], "hash") == 0) {
2113                 uint32_t key_mask_size = TABLE_RULE_MATCH_SIZE_MAX;
2114
2115                 if (n_tokens < t0 + 12) {
2116                         snprintf(out, out_size, MSG_ARG_MISMATCH,
2117                                 "pipeline table hash");
2118                         return;
2119                 }
2120
2121                 p.match_type = TABLE_HASH;
2122
2123                 if (strcmp(tokens[t0 + 1], "ext") == 0)
2124                         p.match.hash.extendable_bucket = 1;
2125                 else if (strcmp(tokens[t0 + 1], "lru") == 0)
2126                         p.match.hash.extendable_bucket = 0;
2127                 else {
2128                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
2129                                 "ext or lru");
2130                         return;
2131                 }
2132
2133                 if (strcmp(tokens[t0 + 2], "key") != 0) {
2134                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key");
2135                         return;
2136                 }
2137
2138                 if ((parser_read_uint32(&p.match.hash.key_size,
2139                         tokens[t0 + 3]) != 0) ||
2140                         (p.match.hash.key_size == 0) ||
2141                         (p.match.hash.key_size > TABLE_RULE_MATCH_SIZE_MAX)) {
2142                         snprintf(out, out_size, MSG_ARG_INVALID, "key_size");
2143                         return;
2144                 }
2145
2146                 if (strcmp(tokens[t0 + 4], "mask") != 0) {
2147                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask");
2148                         return;
2149                 }
2150
2151                 if ((parse_hex_string(tokens[t0 + 5],
2152                         key_mask, &key_mask_size) != 0) ||
2153                         (key_mask_size != p.match.hash.key_size)) {
2154                         snprintf(out, out_size, MSG_ARG_INVALID, "key_mask");
2155                         return;
2156                 }
2157                 p.match.hash.key_mask = key_mask;
2158
2159                 if (strcmp(tokens[t0 + 6], "offset") != 0) {
2160                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
2161                         return;
2162                 }
2163
2164                 if (parser_read_uint32(&p.match.hash.key_offset,
2165                         tokens[t0 + 7]) != 0) {
2166                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
2167                         return;
2168                 }
2169
2170                 if (strcmp(tokens[t0 + 8], "buckets") != 0) {
2171                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buckets");
2172                         return;
2173                 }
2174
2175                 if (parser_read_uint32(&p.match.hash.n_buckets,
2176                         tokens[t0 + 9]) != 0) {
2177                         snprintf(out, out_size, MSG_ARG_INVALID, "n_buckets");
2178                         return;
2179                 }
2180
2181                 if (strcmp(tokens[t0 + 10], "size") != 0) {
2182                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
2183                         return;
2184                 }
2185
2186                 if (parser_read_uint32(&p.match.hash.n_keys,
2187                         tokens[t0 + 11]) != 0) {
2188                         snprintf(out, out_size, MSG_ARG_INVALID, "n_keys");
2189                         return;
2190                 }
2191
2192                 t0 += 12;
2193         } else if (strcmp(tokens[t0], "lpm") == 0) {
2194                 if (n_tokens < t0 + 6) {
2195                         snprintf(out, out_size, MSG_ARG_MISMATCH,
2196                                 "pipeline table lpm");
2197                         return;
2198                 }
2199
2200                 p.match_type = TABLE_LPM;
2201
2202                 if (strcmp(tokens[t0 + 1], "ipv4") == 0)
2203                         p.match.lpm.key_size = 4;
2204                 else if (strcmp(tokens[t0 + 1], "ipv6") == 0)
2205                         p.match.lpm.key_size = 16;
2206                 else {
2207                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
2208                                 "ipv4 or ipv6");
2209                         return;
2210                 }
2211
2212                 if (strcmp(tokens[t0 + 2], "offset") != 0) {
2213                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset");
2214                         return;
2215                 }
2216
2217                 if (parser_read_uint32(&p.match.lpm.key_offset,
2218                         tokens[t0 + 3]) != 0) {
2219                         snprintf(out, out_size, MSG_ARG_INVALID, "key_offset");
2220                         return;
2221                 }
2222
2223                 if (strcmp(tokens[t0 + 4], "size") != 0) {
2224                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size");
2225                         return;
2226                 }
2227
2228                 if (parser_read_uint32(&p.match.lpm.n_rules,
2229                         tokens[t0 + 5]) != 0) {
2230                         snprintf(out, out_size, MSG_ARG_INVALID, "n_rules");
2231                         return;
2232                 }
2233
2234                 t0 += 6;
2235         } else if (strcmp(tokens[t0], "stub") == 0) {
2236                 p.match_type = TABLE_STUB;
2237
2238                 t0 += 1;
2239         } else {
2240                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
2241                 return;
2242         }
2243
2244         p.action_profile_name = NULL;
2245         if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) {
2246                 if (n_tokens < t0 + 2) {
2247                         snprintf(out, out_size, MSG_ARG_MISMATCH, "action");
2248                         return;
2249                 }
2250
2251                 p.action_profile_name = tokens[t0 + 1];
2252
2253                 t0 += 2;
2254         }
2255
2256         if (n_tokens > t0) {
2257                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2258                 return;
2259         }
2260
2261         status = pipeline_table_create(pipeline_name, &p);
2262         if (status) {
2263                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2264                 return;
2265         }
2266 }
2267
2268 static const char cmd_pipeline_port_in_table_help[] =
2269 "pipeline <pipeline_name> port in <port_id> table <table_id>\n";
2270
2271 static void
2272 cmd_pipeline_port_in_table(char **tokens,
2273         uint32_t n_tokens,
2274         char *out,
2275         size_t out_size)
2276 {
2277         char *pipeline_name;
2278         uint32_t port_id, table_id;
2279         int status;
2280
2281         if (n_tokens != 7) {
2282                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2283                 return;
2284         }
2285
2286         pipeline_name = tokens[1];
2287
2288         if (strcmp(tokens[2], "port") != 0) {
2289                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2290                 return;
2291         }
2292
2293         if (strcmp(tokens[3], "in") != 0) {
2294                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
2295                 return;
2296         }
2297
2298         if (parser_read_uint32(&port_id, tokens[4]) != 0) {
2299                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
2300                 return;
2301         }
2302
2303         if (strcmp(tokens[5], "table") != 0) {
2304                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
2305                 return;
2306         }
2307
2308         if (parser_read_uint32(&table_id, tokens[6]) != 0) {
2309                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
2310                 return;
2311         }
2312
2313         status = pipeline_port_in_connect_to_table(pipeline_name,
2314                 port_id,
2315                 table_id);
2316         if (status) {
2317                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2318                 return;
2319         }
2320 }
2321
2322
2323 static const char cmd_pipeline_port_in_stats_help[] =
2324 "pipeline <pipeline_name> port in <port_id> stats read [clear]\n";
2325
2326 #define MSG_PIPELINE_PORT_IN_STATS                         \
2327         "Pkts in: %" PRIu64 "\n"                           \
2328         "Pkts dropped by AH: %" PRIu64 "\n"                \
2329         "Pkts dropped by other: %" PRIu64 "\n"
2330
2331 static void
2332 cmd_pipeline_port_in_stats(char **tokens,
2333         uint32_t n_tokens,
2334         char *out,
2335         size_t out_size)
2336 {
2337         struct rte_pipeline_port_in_stats stats;
2338         char *pipeline_name;
2339         uint32_t port_id;
2340         int clear, status;
2341
2342         if ((n_tokens != 7) && (n_tokens != 8)) {
2343                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2344                 return;
2345         }
2346
2347         pipeline_name = tokens[1];
2348
2349         if (strcmp(tokens[2], "port") != 0) {
2350                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2351                 return;
2352         }
2353
2354         if (strcmp(tokens[3], "in") != 0) {
2355                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
2356                 return;
2357         }
2358
2359         if (parser_read_uint32(&port_id, tokens[4]) != 0) {
2360                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
2361                 return;
2362         }
2363
2364         if (strcmp(tokens[5], "stats") != 0) {
2365                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
2366                 return;
2367         }
2368
2369         if (strcmp(tokens[6], "read") != 0) {
2370                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
2371                 return;
2372         }
2373
2374         clear = 0;
2375         if (n_tokens == 8) {
2376                 if (strcmp(tokens[7], "clear") != 0) {
2377                         snprintf(out, out_size, MSG_ARG_INVALID, "clear");
2378                         return;
2379                 }
2380
2381                 clear = 1;
2382         }
2383
2384         status = pipeline_port_in_stats_read(pipeline_name,
2385                 port_id,
2386                 &stats,
2387                 clear);
2388         if (status) {
2389                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2390                 return;
2391         }
2392
2393         snprintf(out, out_size, MSG_PIPELINE_PORT_IN_STATS,
2394                 stats.stats.n_pkts_in,
2395                 stats.n_pkts_dropped_by_ah,
2396                 stats.stats.n_pkts_drop);
2397 }
2398
2399
2400 static const char cmd_pipeline_port_in_enable_help[] =
2401 "pipeline <pipeline_name> port in <port_id> enable\n";
2402
2403 static void
2404 cmd_pipeline_port_in_enable(char **tokens,
2405         uint32_t n_tokens,
2406         char *out,
2407         size_t out_size)
2408 {
2409         char *pipeline_name;
2410         uint32_t port_id;
2411         int status;
2412
2413         if (n_tokens != 6) {
2414                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2415                 return;
2416         }
2417
2418         pipeline_name = tokens[1];
2419
2420         if (strcmp(tokens[2], "port") != 0) {
2421                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2422                 return;
2423         }
2424
2425         if (strcmp(tokens[3], "in") != 0) {
2426                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
2427                 return;
2428         }
2429
2430         if (parser_read_uint32(&port_id, tokens[4]) != 0) {
2431                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
2432                 return;
2433         }
2434
2435         if (strcmp(tokens[5], "enable") != 0) {
2436                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable");
2437                 return;
2438         }
2439
2440         status = pipeline_port_in_enable(pipeline_name, port_id);
2441         if (status) {
2442                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2443                 return;
2444         }
2445 }
2446
2447
2448 static const char cmd_pipeline_port_in_disable_help[] =
2449 "pipeline <pipeline_name> port in <port_id> disable\n";
2450
2451 static void
2452 cmd_pipeline_port_in_disable(char **tokens,
2453         uint32_t n_tokens,
2454         char *out,
2455         size_t out_size)
2456 {
2457         char *pipeline_name;
2458         uint32_t port_id;
2459         int status;
2460
2461         if (n_tokens != 6) {
2462                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2463                 return;
2464         }
2465
2466         pipeline_name = tokens[1];
2467
2468         if (strcmp(tokens[2], "port") != 0) {
2469                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2470                 return;
2471         }
2472
2473         if (strcmp(tokens[3], "in") != 0) {
2474                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
2475                 return;
2476         }
2477
2478         if (parser_read_uint32(&port_id, tokens[4]) != 0) {
2479                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
2480                 return;
2481         }
2482
2483         if (strcmp(tokens[5], "disable") != 0) {
2484                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable");
2485                 return;
2486         }
2487
2488         status = pipeline_port_in_disable(pipeline_name, port_id);
2489         if (status) {
2490                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2491                 return;
2492         }
2493 }
2494
2495
2496 static const char cmd_pipeline_port_out_stats_help[] =
2497 "pipeline <pipeline_name> port out <port_id> stats read [clear]\n";
2498
2499 #define MSG_PIPELINE_PORT_OUT_STATS                        \
2500         "Pkts in: %" PRIu64 "\n"                           \
2501         "Pkts dropped by AH: %" PRIu64 "\n"                \
2502         "Pkts dropped by other: %" PRIu64 "\n"
2503
2504 static void
2505 cmd_pipeline_port_out_stats(char **tokens,
2506         uint32_t n_tokens,
2507         char *out,
2508         size_t out_size)
2509 {
2510         struct rte_pipeline_port_out_stats stats;
2511         char *pipeline_name;
2512         uint32_t port_id;
2513         int clear, status;
2514
2515         if ((n_tokens != 7) && (n_tokens != 8)) {
2516                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2517                 return;
2518         }
2519
2520         pipeline_name = tokens[1];
2521
2522         if (strcmp(tokens[2], "port") != 0) {
2523                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2524                 return;
2525         }
2526
2527         if (strcmp(tokens[3], "out") != 0) {
2528                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out");
2529                 return;
2530         }
2531
2532         if (parser_read_uint32(&port_id, tokens[4]) != 0) {
2533                 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
2534                 return;
2535         }
2536
2537         if (strcmp(tokens[5], "stats") != 0) {
2538                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
2539                 return;
2540         }
2541
2542         if (strcmp(tokens[6], "read") != 0) {
2543                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
2544                 return;
2545         }
2546
2547         clear = 0;
2548         if (n_tokens == 8) {
2549                 if (strcmp(tokens[7], "clear") != 0) {
2550                         snprintf(out, out_size, MSG_ARG_INVALID, "clear");
2551                         return;
2552                 }
2553
2554                 clear = 1;
2555         }
2556
2557         status = pipeline_port_out_stats_read(pipeline_name,
2558                 port_id,
2559                 &stats,
2560                 clear);
2561         if (status) {
2562                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2563                 return;
2564         }
2565
2566         snprintf(out, out_size, MSG_PIPELINE_PORT_OUT_STATS,
2567                 stats.stats.n_pkts_in,
2568                 stats.n_pkts_dropped_by_ah,
2569                 stats.stats.n_pkts_drop);
2570 }
2571
2572
2573 static const char cmd_pipeline_table_stats_help[] =
2574 "pipeline <pipeline_name> table <table_id> stats read [clear]\n";
2575
2576 #define MSG_PIPELINE_TABLE_STATS                                     \
2577         "Pkts in: %" PRIu64 "\n"                                     \
2578         "Pkts in with lookup miss: %" PRIu64 "\n"                    \
2579         "Pkts in with lookup hit dropped by AH: %" PRIu64 "\n"       \
2580         "Pkts in with lookup hit dropped by others: %" PRIu64 "\n"   \
2581         "Pkts in with lookup miss dropped by AH: %" PRIu64 "\n"      \
2582         "Pkts in with lookup miss dropped by others: %" PRIu64 "\n"
2583
2584 static void
2585 cmd_pipeline_table_stats(char **tokens,
2586         uint32_t n_tokens,
2587         char *out,
2588         size_t out_size)
2589 {
2590         struct rte_pipeline_table_stats stats;
2591         char *pipeline_name;
2592         uint32_t table_id;
2593         int clear, status;
2594
2595         if ((n_tokens != 6) && (n_tokens != 7)) {
2596                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2597                 return;
2598         }
2599
2600         pipeline_name = tokens[1];
2601
2602         if (strcmp(tokens[2], "table") != 0) {
2603                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
2604                 return;
2605         }
2606
2607         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
2608                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
2609                 return;
2610         }
2611
2612         if (strcmp(tokens[4], "stats") != 0) {
2613                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
2614                 return;
2615         }
2616
2617         if (strcmp(tokens[5], "read") != 0) {
2618                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
2619                 return;
2620         }
2621
2622         clear = 0;
2623         if (n_tokens == 7) {
2624                 if (strcmp(tokens[6], "clear") != 0) {
2625                         snprintf(out, out_size, MSG_ARG_INVALID, "clear");
2626                         return;
2627                 }
2628
2629                 clear = 1;
2630         }
2631
2632         status = pipeline_table_stats_read(pipeline_name,
2633                 table_id,
2634                 &stats,
2635                 clear);
2636         if (status) {
2637                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
2638                 return;
2639         }
2640
2641         snprintf(out, out_size, MSG_PIPELINE_TABLE_STATS,
2642                 stats.stats.n_pkts_in,
2643                 stats.stats.n_pkts_lookup_miss,
2644                 stats.n_pkts_dropped_by_lkp_hit_ah,
2645                 stats.n_pkts_dropped_lkp_hit,
2646                 stats.n_pkts_dropped_by_lkp_miss_ah,
2647                 stats.n_pkts_dropped_lkp_miss);
2648 }
2649
2650 /**
2651  * <match> ::=
2652  *
2653  * match
2654  *    acl
2655  *       priority <priority>
2656  *       ipv4 | ipv6 <sa> <sa_depth> <da> <da_depth>
2657  *       <sp0> <sp1> <dp0> <dp1> <proto>
2658  *    | array <pos>
2659  *    | hash
2660  *       raw <key>
2661  *       | ipv4_5tuple <sa> <da> <sp> <dp> <proto>
2662  *       | ipv6_5tuple <sa> <da> <sp> <dp> <proto>
2663  *       | ipv4_addr <addr>
2664  *       | ipv6_addr <addr>
2665  *       | qinq <svlan> <cvlan>
2666  *    | lpm
2667  *       ipv4 | ipv6 <addr> <depth>
2668  */
2669 struct pkt_key_qinq {
2670         uint16_t ethertype_svlan;
2671         uint16_t svlan;
2672         uint16_t ethertype_cvlan;
2673         uint16_t cvlan;
2674 } __rte_packed;
2675
2676 struct pkt_key_ipv4_5tuple {
2677         uint8_t time_to_live;
2678         uint8_t proto;
2679         uint16_t hdr_checksum;
2680         uint32_t sa;
2681         uint32_t da;
2682         uint16_t sp;
2683         uint16_t dp;
2684 } __rte_packed;
2685
2686 struct pkt_key_ipv6_5tuple {
2687         uint16_t payload_length;
2688         uint8_t proto;
2689         uint8_t hop_limit;
2690         uint8_t sa[16];
2691         uint8_t da[16];
2692         uint16_t sp;
2693         uint16_t dp;
2694 } __rte_packed;
2695
2696 struct pkt_key_ipv4_addr {
2697         uint32_t addr;
2698 } __rte_packed;
2699
2700 struct pkt_key_ipv6_addr {
2701         uint8_t addr[16];
2702 } __rte_packed;
2703
2704 static uint32_t
2705 parse_match(char **tokens,
2706         uint32_t n_tokens,
2707         char *out,
2708         size_t out_size,
2709         struct table_rule_match *m)
2710 {
2711         memset(m, 0, sizeof(*m));
2712
2713         if (n_tokens < 2)
2714                 return 0;
2715
2716         if (strcmp(tokens[0], "match") != 0) {
2717                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
2718                 return 0;
2719         }
2720
2721         if (strcmp(tokens[1], "acl") == 0) {
2722                 if (n_tokens < 14) {
2723                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2724                         return 0;
2725                 }
2726
2727                 m->match_type = TABLE_ACL;
2728
2729                 if (strcmp(tokens[2], "priority") != 0) {
2730                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "priority");
2731                         return 0;
2732                 }
2733
2734                 if (parser_read_uint32(&m->match.acl.priority,
2735                         tokens[3]) != 0) {
2736                         snprintf(out, out_size, MSG_ARG_INVALID, "priority");
2737                         return 0;
2738                 }
2739
2740                 if (strcmp(tokens[4], "ipv4") == 0) {
2741                         struct in_addr saddr, daddr;
2742
2743                         m->match.acl.ip_version = 1;
2744
2745                         if (parse_ipv4_addr(tokens[5], &saddr) != 0) {
2746                                 snprintf(out, out_size, MSG_ARG_INVALID, "sa");
2747                                 return 0;
2748                         }
2749                         m->match.acl.ipv4.sa = rte_be_to_cpu_32(saddr.s_addr);
2750
2751                         if (parse_ipv4_addr(tokens[7], &daddr) != 0) {
2752                                 snprintf(out, out_size, MSG_ARG_INVALID, "da");
2753                                 return 0;
2754                         }
2755                         m->match.acl.ipv4.da = rte_be_to_cpu_32(daddr.s_addr);
2756                 } else if (strcmp(tokens[4], "ipv6") == 0) {
2757                         struct in6_addr saddr, daddr;
2758
2759                         m->match.acl.ip_version = 0;
2760
2761                         if (parse_ipv6_addr(tokens[5], &saddr) != 0) {
2762                                 snprintf(out, out_size, MSG_ARG_INVALID, "sa");
2763                                 return 0;
2764                         }
2765                         memcpy(m->match.acl.ipv6.sa, saddr.s6_addr, 16);
2766
2767                         if (parse_ipv6_addr(tokens[7], &daddr) != 0) {
2768                                 snprintf(out, out_size, MSG_ARG_INVALID, "da");
2769                                 return 0;
2770                         }
2771                         memcpy(m->match.acl.ipv6.da, daddr.s6_addr, 16);
2772                 } else {
2773                         snprintf(out, out_size, MSG_ARG_NOT_FOUND,
2774                                 "ipv4 or ipv6");
2775                         return 0;
2776                 }
2777
2778                 if (parser_read_uint32(&m->match.acl.sa_depth,
2779                         tokens[6]) != 0) {
2780                         snprintf(out, out_size, MSG_ARG_INVALID, "sa_depth");
2781                         return 0;
2782                 }
2783
2784                 if (parser_read_uint32(&m->match.acl.da_depth,
2785                         tokens[8]) != 0) {
2786                         snprintf(out, out_size, MSG_ARG_INVALID, "da_depth");
2787                         return 0;
2788                 }
2789
2790                 if (parser_read_uint16(&m->match.acl.sp0, tokens[9]) != 0) {
2791                         snprintf(out, out_size, MSG_ARG_INVALID, "sp0");
2792                         return 0;
2793                 }
2794
2795                 if (parser_read_uint16(&m->match.acl.sp1, tokens[10]) != 0) {
2796                         snprintf(out, out_size, MSG_ARG_INVALID, "sp1");
2797                         return 0;
2798                 }
2799
2800                 if (parser_read_uint16(&m->match.acl.dp0, tokens[11]) != 0) {
2801                         snprintf(out, out_size, MSG_ARG_INVALID, "dp0");
2802                         return 0;
2803                 }
2804
2805                 if (parser_read_uint16(&m->match.acl.dp1, tokens[12]) != 0) {
2806                         snprintf(out, out_size, MSG_ARG_INVALID, "dp1");
2807                         return 0;
2808                 }
2809
2810                 if (parser_read_uint8(&m->match.acl.proto, tokens[13]) != 0) {
2811                         snprintf(out, out_size, MSG_ARG_INVALID, "proto");
2812                         return 0;
2813                 }
2814
2815                 m->match.acl.proto_mask = 0xff;
2816
2817                 return 14;
2818         } /* acl */
2819
2820         if (strcmp(tokens[1], "array") == 0) {
2821                 if (n_tokens < 3) {
2822                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2823                         return 0;
2824                 }
2825
2826                 m->match_type = TABLE_ARRAY;
2827
2828                 if (parser_read_uint32(&m->match.array.pos, tokens[2]) != 0) {
2829                         snprintf(out, out_size, MSG_ARG_INVALID, "pos");
2830                         return 0;
2831                 }
2832
2833                 return 3;
2834         } /* array */
2835
2836         if (strcmp(tokens[1], "hash") == 0) {
2837                 if (n_tokens < 3) {
2838                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
2839                         return 0;
2840                 }
2841
2842                 m->match_type = TABLE_HASH;
2843
2844                 if (strcmp(tokens[2], "raw") == 0) {
2845                         uint32_t key_size = TABLE_RULE_MATCH_SIZE_MAX;
2846
2847                         if (n_tokens < 4) {
2848                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
2849                                         tokens[0]);
2850                                 return 0;
2851                         }
2852
2853                         if (parse_hex_string(tokens[3],
2854                                 m->match.hash.key, &key_size) != 0) {
2855                                 snprintf(out, out_size, MSG_ARG_INVALID, "key");
2856                                 return 0;
2857                         }
2858
2859                         return 4;
2860                 } /* hash raw */
2861
2862                 if (strcmp(tokens[2], "ipv4_5tuple") == 0) {
2863                         struct pkt_key_ipv4_5tuple *ipv4 =
2864                                 (struct pkt_key_ipv4_5tuple *) m->match.hash.key;
2865                         struct in_addr saddr, daddr;
2866                         uint16_t sp, dp;
2867                         uint8_t proto;
2868
2869                         if (n_tokens < 8) {
2870                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
2871                                         tokens[0]);
2872                                 return 0;
2873                         }
2874
2875                         if (parse_ipv4_addr(tokens[3], &saddr) != 0) {
2876                                 snprintf(out, out_size, MSG_ARG_INVALID, "sa");
2877                                 return 0;
2878                         }
2879
2880                         if (parse_ipv4_addr(tokens[4], &daddr) != 0) {
2881                                 snprintf(out, out_size, MSG_ARG_INVALID, "da");
2882                                 return 0;
2883                         }
2884
2885                         if (parser_read_uint16(&sp, tokens[5]) != 0) {
2886                                 snprintf(out, out_size, MSG_ARG_INVALID, "sp");
2887                                 return 0;
2888                         }
2889
2890                         if (parser_read_uint16(&dp, tokens[6]) != 0) {
2891                                 snprintf(out, out_size, MSG_ARG_INVALID, "dp");
2892                                 return 0;
2893                         }
2894
2895                         if (parser_read_uint8(&proto, tokens[7]) != 0) {
2896                                 snprintf(out, out_size, MSG_ARG_INVALID,
2897                                         "proto");
2898                                 return 0;
2899                         }
2900
2901                         ipv4->sa = saddr.s_addr;
2902                         ipv4->da = daddr.s_addr;
2903                         ipv4->sp = rte_cpu_to_be_16(sp);
2904                         ipv4->dp = rte_cpu_to_be_16(dp);
2905                         ipv4->proto = proto;
2906
2907                         return 8;
2908                 } /* hash ipv4_5tuple */
2909
2910                 if (strcmp(tokens[2], "ipv6_5tuple") == 0) {
2911                         struct pkt_key_ipv6_5tuple *ipv6 =
2912                                 (struct pkt_key_ipv6_5tuple *) m->match.hash.key;
2913                         struct in6_addr saddr, daddr;
2914                         uint16_t sp, dp;
2915                         uint8_t proto;
2916
2917                         if (n_tokens < 8) {
2918                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
2919                                         tokens[0]);
2920                                 return 0;
2921                         }
2922
2923                         if (parse_ipv6_addr(tokens[3], &saddr) != 0) {
2924                                 snprintf(out, out_size, MSG_ARG_INVALID, "sa");
2925                                 return 0;
2926                         }
2927
2928                         if (parse_ipv6_addr(tokens[4], &daddr) != 0) {
2929                                 snprintf(out, out_size, MSG_ARG_INVALID, "da");
2930                                 return 0;
2931                         }
2932
2933                         if (parser_read_uint16(&sp, tokens[5]) != 0) {
2934                                 snprintf(out, out_size, MSG_ARG_INVALID, "sp");
2935                                 return 0;
2936                         }
2937
2938                         if (parser_read_uint16(&dp, tokens[6]) != 0) {
2939                                 snprintf(out, out_size, MSG_ARG_INVALID, "dp");
2940                                 return 0;
2941                         }
2942
2943                         if (parser_read_uint8(&proto, tokens[7]) != 0) {
2944                                 snprintf(out, out_size, MSG_ARG_INVALID,
2945                                         "proto");
2946                                 return 0;
2947                         }
2948
2949                         memcpy(ipv6->sa, saddr.s6_addr, 16);
2950                         memcpy(ipv6->da, daddr.s6_addr, 16);
2951                         ipv6->sp = rte_cpu_to_be_16(sp);
2952                         ipv6->dp = rte_cpu_to_be_16(dp);
2953                         ipv6->proto = proto;
2954
2955                         return 8;
2956                 } /* hash ipv6_5tuple */
2957
2958                 if (strcmp(tokens[2], "ipv4_addr") == 0) {
2959                         struct pkt_key_ipv4_addr *ipv4_addr =
2960                                 (struct pkt_key_ipv4_addr *) m->match.hash.key;
2961                         struct in_addr addr;
2962
2963                         if (n_tokens < 4) {
2964                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
2965                                         tokens[0]);
2966                                 return 0;
2967                         }
2968
2969                         if (parse_ipv4_addr(tokens[3], &addr) != 0) {
2970                                 snprintf(out, out_size, MSG_ARG_INVALID,
2971                                         "addr");
2972                                 return 0;
2973                         }
2974
2975                         ipv4_addr->addr = addr.s_addr;
2976
2977                         return 4;
2978                 } /* hash ipv4_addr */
2979
2980                 if (strcmp(tokens[2], "ipv6_addr") == 0) {
2981                         struct pkt_key_ipv6_addr *ipv6_addr =
2982                                 (struct pkt_key_ipv6_addr *) m->match.hash.key;
2983                         struct in6_addr addr;
2984
2985                         if (n_tokens < 4) {
2986                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
2987                                         tokens[0]);
2988                                 return 0;
2989                         }
2990
2991                         if (parse_ipv6_addr(tokens[3], &addr) != 0) {
2992                                 snprintf(out, out_size, MSG_ARG_INVALID,
2993                                         "addr");
2994                                 return 0;
2995                         }
2996
2997                         memcpy(ipv6_addr->addr, addr.s6_addr, 16);
2998
2999                         return 4;
3000                 } /* hash ipv6_5tuple */
3001
3002                 if (strcmp(tokens[2], "qinq") == 0) {
3003                         struct pkt_key_qinq *qinq =
3004                                 (struct pkt_key_qinq *) m->match.hash.key;
3005                         uint16_t svlan, cvlan;
3006
3007                         if (n_tokens < 5) {
3008                                 snprintf(out, out_size, MSG_ARG_MISMATCH,
3009                                         tokens[0]);
3010                                 return 0;
3011                         }
3012
3013                         if ((parser_read_uint16(&svlan, tokens[3]) != 0) ||
3014                                 (svlan > 0xFFF)) {
3015                                 snprintf(out, out_size, MSG_ARG_INVALID,
3016                                         "svlan");
3017                                 return 0;
3018                         }
3019
3020                         if ((parser_read_uint16(&cvlan, tokens[4]) != 0) ||
3021                                 (cvlan > 0xFFF)) {
3022                                 snprintf(out, out_size, MSG_ARG_INVALID,
3023                                         "cvlan");
3024                                 return 0;
3025                         }
3026
3027                         qinq->svlan = rte_cpu_to_be_16(svlan);
3028                         qinq->cvlan = rte_cpu_to_be_16(cvlan);
3029
3030                         return 5;
3031                 } /* hash qinq */
3032
3033                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
3034                 return 0;
3035         } /* hash */
3036
3037         if (strcmp(tokens[1], "lpm") == 0) {
3038                 if (n_tokens < 5) {
3039                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
3040                         return 0;
3041                 }
3042
3043                 m->match_type = TABLE_LPM;
3044
3045                 if (strcmp(tokens[2], "ipv4") == 0) {
3046                         struct in_addr addr;
3047
3048                         m->match.lpm.ip_version = 1;
3049
3050                         if (parse_ipv4_addr(tokens[3], &addr) != 0) {
3051                                 snprintf(out, out_size, MSG_ARG_INVALID,
3052                                         "addr");
3053                                 return 0;
3054                         }
3055
3056                         m->match.lpm.ipv4 = rte_be_to_cpu_32(addr.s_addr);
3057                 } else if (strcmp(tokens[2], "ipv6") == 0) {
3058                         struct in6_addr addr;
3059
3060                         m->match.lpm.ip_version = 0;
3061
3062                         if (parse_ipv6_addr(tokens[3], &addr) != 0) {
3063                                 snprintf(out, out_size, MSG_ARG_INVALID,
3064                                         "addr");
3065                                 return 0;
3066                         }
3067
3068                         memcpy(m->match.lpm.ipv6, addr.s6_addr, 16);
3069                 } else {
3070                         snprintf(out, out_size, MSG_ARG_MISMATCH,
3071                                 "ipv4 or ipv6");
3072                         return 0;
3073                 }
3074
3075                 if (parser_read_uint8(&m->match.lpm.depth, tokens[4]) != 0) {
3076                         snprintf(out, out_size, MSG_ARG_INVALID, "depth");
3077                         return 0;
3078                 }
3079
3080                 return 5;
3081         } /* lpm */
3082
3083         snprintf(out, out_size, MSG_ARG_MISMATCH,
3084                 "acl or array or hash or lpm");
3085         return 0;
3086 }
3087
3088 /**
3089  * table_action ::=
3090  *
3091  * action
3092  *    fwd
3093  *       drop
3094  *       | port <port_id>
3095  *       | meta
3096  *       | table <table_id>
3097  *    [balance <out0> ... <out7>]
3098  *    [meter
3099  *       tc0 meter <meter_profile_id> policer g <pa> y <pa> r <pa>
3100  *       [tc1 meter <meter_profile_id> policer g <pa> y <pa> r <pa>
3101  *       tc2 meter <meter_profile_id> policer g <pa> y <pa> r <pa>
3102  *       tc3 meter <meter_profile_id> policer g <pa> y <pa> r <pa>]]
3103  *    [tm subport <subport_id> pipe <pipe_id>]
3104  *    [encap
3105  *       ether <da> <sa>
3106  *       | vlan <da> <sa> <pcp> <dei> <vid>
3107  *       | qinq <da> <sa> <pcp> <dei> <vid> <pcp> <dei> <vid>
3108  *       | qinq_pppoe <da> <sa> <pcp> <dei> <vid> <pcp> <dei> <vid> <session_id>
3109  *       | mpls unicast | multicast
3110  *          <da> <sa>
3111  *          label0 <label> <tc> <ttl>
3112  *          [label1 <label> <tc> <ttl>
3113  *          [label2 <label> <tc> <ttl>
3114  *          [label3 <label> <tc> <ttl>]]]
3115  *       | pppoe <da> <sa> <session_id>
3116  *       | vxlan ether <da> <sa>
3117  *          [vlan <pcp> <dei> <vid>]
3118  *          ipv4 <sa> <da> <dscp> <ttl>
3119  *          | ipv6 <sa> <da> <flow_label> <dscp> <hop_limit>
3120  *          udp <sp> <dp>
3121  *          vxlan <vni>]
3122  *    [nat ipv4 | ipv6 <addr> <port>]
3123  *    [ttl dec | keep]
3124  *    [stats]
3125  *    [time]
3126  *    [sym_crypto
3127  *       encrypt | decrypt
3128  *       type
3129  *       | cipher
3130  *          cipher_algo <algo> cipher_key <key> cipher_iv <iv>
3131  *       | cipher_auth
3132  *          cipher_algo <algo> cipher_key <key> cipher_iv <iv>
3133  *          auth_algo <algo> auth_key <key> digest_size <size>
3134  *       | aead
3135  *          aead_algo <algo> aead_key <key> aead_iv <iv> aead_aad <aad>
3136  *          digest_size <size>
3137  *       data_offset <data_offset>]
3138  *    [tag <tag>]
3139  *    [decap <n>]
3140  *
3141  * where:
3142  *    <pa> ::= g | y | r | drop
3143  */
3144 static uint32_t
3145 parse_table_action_fwd(char **tokens,
3146         uint32_t n_tokens,
3147         struct table_rule_action *a)
3148 {
3149         if ((n_tokens == 0) || (strcmp(tokens[0], "fwd") != 0))
3150                 return 0;
3151
3152         tokens++;
3153         n_tokens--;
3154
3155         if (n_tokens && (strcmp(tokens[0], "drop") == 0)) {
3156                 a->fwd.action = RTE_PIPELINE_ACTION_DROP;
3157                 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
3158                 return 1 + 1;
3159         }
3160
3161         if (n_tokens && (strcmp(tokens[0], "port") == 0)) {
3162                 uint32_t id;
3163
3164                 if ((n_tokens < 2) ||
3165                         parser_read_uint32(&id, tokens[1]))
3166                         return 0;
3167
3168                 a->fwd.action = RTE_PIPELINE_ACTION_PORT;
3169                 a->fwd.id = id;
3170                 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
3171                 return 1 + 2;
3172         }
3173
3174         if (n_tokens && (strcmp(tokens[0], "meta") == 0)) {
3175                 a->fwd.action = RTE_PIPELINE_ACTION_PORT_META;
3176                 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
3177                 return 1 + 1;
3178         }
3179
3180         if (n_tokens && (strcmp(tokens[0], "table") == 0)) {
3181                 uint32_t id;
3182
3183                 if ((n_tokens < 2) ||
3184                         parser_read_uint32(&id, tokens[1]))
3185                         return 0;
3186
3187                 a->fwd.action = RTE_PIPELINE_ACTION_TABLE;
3188                 a->fwd.id = id;
3189                 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD;
3190                 return 1 + 2;
3191         }
3192
3193         return 0;
3194 }
3195
3196 static uint32_t
3197 parse_table_action_balance(char **tokens,
3198         uint32_t n_tokens,
3199         struct table_rule_action *a)
3200 {
3201         uint32_t i;
3202
3203         if ((n_tokens == 0) || (strcmp(tokens[0], "balance") != 0))
3204                 return 0;
3205
3206         tokens++;
3207         n_tokens--;
3208
3209         if (n_tokens < RTE_TABLE_ACTION_LB_TABLE_SIZE)
3210                 return 0;
3211
3212         for (i = 0; i < RTE_TABLE_ACTION_LB_TABLE_SIZE; i++)
3213                 if (parser_read_uint32(&a->lb.out[i], tokens[i]) != 0)
3214                         return 0;
3215
3216         a->action_mask |= 1 << RTE_TABLE_ACTION_LB;
3217         return 1 + RTE_TABLE_ACTION_LB_TABLE_SIZE;
3218
3219 }
3220
3221 static int
3222 parse_policer_action(char *token, enum rte_table_action_policer *a)
3223 {
3224         if (strcmp(token, "g") == 0) {
3225                 *a = RTE_TABLE_ACTION_POLICER_COLOR_GREEN;
3226                 return 0;
3227         }
3228
3229         if (strcmp(token, "y") == 0) {
3230                 *a = RTE_TABLE_ACTION_POLICER_COLOR_YELLOW;
3231                 return 0;
3232         }
3233
3234         if (strcmp(token, "r") == 0) {
3235                 *a = RTE_TABLE_ACTION_POLICER_COLOR_RED;
3236                 return 0;
3237         }
3238
3239         if (strcmp(token, "drop") == 0) {
3240                 *a = RTE_TABLE_ACTION_POLICER_DROP;
3241                 return 0;
3242         }
3243
3244         return -1;
3245 }
3246
3247 static uint32_t
3248 parse_table_action_meter_tc(char **tokens,
3249         uint32_t n_tokens,
3250         struct rte_table_action_mtr_tc_params *mtr)
3251 {
3252         if ((n_tokens < 9) ||
3253                 strcmp(tokens[0], "meter") ||
3254                 parser_read_uint32(&mtr->meter_profile_id, tokens[1]) ||
3255                 strcmp(tokens[2], "policer") ||
3256                 strcmp(tokens[3], "g") ||
3257                 parse_policer_action(tokens[4], &mtr->policer[RTE_COLOR_GREEN]) ||
3258                 strcmp(tokens[5], "y") ||
3259                 parse_policer_action(tokens[6], &mtr->policer[RTE_COLOR_YELLOW]) ||
3260                 strcmp(tokens[7], "r") ||
3261                 parse_policer_action(tokens[8], &mtr->policer[RTE_COLOR_RED]))
3262                 return 0;
3263
3264         return 9;
3265 }
3266
3267 static uint32_t
3268 parse_table_action_meter(char **tokens,
3269         uint32_t n_tokens,
3270         struct table_rule_action *a)
3271 {
3272         if ((n_tokens == 0) || strcmp(tokens[0], "meter"))
3273                 return 0;
3274
3275         tokens++;
3276         n_tokens--;
3277
3278         if ((n_tokens < 10) ||
3279                 strcmp(tokens[0], "tc0") ||
3280                 (parse_table_action_meter_tc(tokens + 1,
3281                         n_tokens - 1,
3282                         &a->mtr.mtr[0]) == 0))
3283                 return 0;
3284
3285         tokens += 10;
3286         n_tokens -= 10;
3287
3288         if ((n_tokens == 0) || strcmp(tokens[0], "tc1")) {
3289                 a->mtr.tc_mask = 1;
3290                 a->action_mask |= 1 << RTE_TABLE_ACTION_MTR;
3291                 return 1 + 10;
3292         }
3293
3294         if ((n_tokens < 30) ||
3295                 (parse_table_action_meter_tc(tokens + 1,
3296                         n_tokens - 1, &a->mtr.mtr[1]) == 0) ||
3297                 strcmp(tokens[10], "tc2") ||
3298                 (parse_table_action_meter_tc(tokens + 11,
3299                         n_tokens - 11, &a->mtr.mtr[2]) == 0) ||
3300                 strcmp(tokens[20], "tc3") ||
3301                 (parse_table_action_meter_tc(tokens + 21,
3302                         n_tokens - 21, &a->mtr.mtr[3]) == 0))
3303                 return 0;
3304
3305         a->mtr.tc_mask = 0xF;
3306         a->action_mask |= 1 << RTE_TABLE_ACTION_MTR;
3307         return 1 + 10 + 3 * 10;
3308 }
3309
3310 static uint32_t
3311 parse_table_action_tm(char **tokens,
3312         uint32_t n_tokens,
3313         struct table_rule_action *a)
3314 {
3315         uint32_t subport_id, pipe_id;
3316
3317         if ((n_tokens < 5) ||
3318                 strcmp(tokens[0], "tm") ||
3319                 strcmp(tokens[1], "subport") ||
3320                 parser_read_uint32(&subport_id, tokens[2]) ||
3321                 strcmp(tokens[3], "pipe") ||
3322                 parser_read_uint32(&pipe_id, tokens[4]))
3323                 return 0;
3324
3325         a->tm.subport_id = subport_id;
3326         a->tm.pipe_id = pipe_id;
3327         a->action_mask |= 1 << RTE_TABLE_ACTION_TM;
3328         return 5;
3329 }
3330
3331 static uint32_t
3332 parse_table_action_encap(char **tokens,
3333         uint32_t n_tokens,
3334         struct table_rule_action *a)
3335 {
3336         if ((n_tokens == 0) || strcmp(tokens[0], "encap"))
3337                 return 0;
3338
3339         tokens++;
3340         n_tokens--;
3341
3342         /* ether */
3343         if (n_tokens && (strcmp(tokens[0], "ether") == 0)) {
3344                 if ((n_tokens < 3) ||
3345                         parse_mac_addr(tokens[1], &a->encap.ether.ether.da) ||
3346                         parse_mac_addr(tokens[2], &a->encap.ether.ether.sa))
3347                         return 0;
3348
3349                 a->encap.type = RTE_TABLE_ACTION_ENCAP_ETHER;
3350                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3351                 return 1 + 3;
3352         }
3353
3354         /* vlan */
3355         if (n_tokens && (strcmp(tokens[0], "vlan") == 0)) {
3356                 uint32_t pcp, dei, vid;
3357
3358                 if ((n_tokens < 6) ||
3359                         parse_mac_addr(tokens[1], &a->encap.vlan.ether.da) ||
3360                         parse_mac_addr(tokens[2], &a->encap.vlan.ether.sa) ||
3361                         parser_read_uint32(&pcp, tokens[3]) ||
3362                         (pcp > 0x7) ||
3363                         parser_read_uint32(&dei, tokens[4]) ||
3364                         (dei > 0x1) ||
3365                         parser_read_uint32(&vid, tokens[5]) ||
3366                         (vid > 0xFFF))
3367                         return 0;
3368
3369                 a->encap.vlan.vlan.pcp = pcp & 0x7;
3370                 a->encap.vlan.vlan.dei = dei & 0x1;
3371                 a->encap.vlan.vlan.vid = vid & 0xFFF;
3372                 a->encap.type = RTE_TABLE_ACTION_ENCAP_VLAN;
3373                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3374                 return 1 + 6;
3375         }
3376
3377         /* qinq */
3378         if (n_tokens && (strcmp(tokens[0], "qinq") == 0)) {
3379                 uint32_t svlan_pcp, svlan_dei, svlan_vid;
3380                 uint32_t cvlan_pcp, cvlan_dei, cvlan_vid;
3381
3382                 if ((n_tokens < 9) ||
3383                         parse_mac_addr(tokens[1], &a->encap.qinq.ether.da) ||
3384                         parse_mac_addr(tokens[2], &a->encap.qinq.ether.sa) ||
3385                         parser_read_uint32(&svlan_pcp, tokens[3]) ||
3386                         (svlan_pcp > 0x7) ||
3387                         parser_read_uint32(&svlan_dei, tokens[4]) ||
3388                         (svlan_dei > 0x1) ||
3389                         parser_read_uint32(&svlan_vid, tokens[5]) ||
3390                         (svlan_vid > 0xFFF) ||
3391                         parser_read_uint32(&cvlan_pcp, tokens[6]) ||
3392                         (cvlan_pcp > 0x7) ||
3393                         parser_read_uint32(&cvlan_dei, tokens[7]) ||
3394                         (cvlan_dei > 0x1) ||
3395                         parser_read_uint32(&cvlan_vid, tokens[8]) ||
3396                         (cvlan_vid > 0xFFF))
3397                         return 0;
3398
3399                 a->encap.qinq.svlan.pcp = svlan_pcp & 0x7;
3400                 a->encap.qinq.svlan.dei = svlan_dei & 0x1;
3401                 a->encap.qinq.svlan.vid = svlan_vid & 0xFFF;
3402                 a->encap.qinq.cvlan.pcp = cvlan_pcp & 0x7;
3403                 a->encap.qinq.cvlan.dei = cvlan_dei & 0x1;
3404                 a->encap.qinq.cvlan.vid = cvlan_vid & 0xFFF;
3405                 a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ;
3406                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3407                 return 1 + 9;
3408         }
3409
3410         /* qinq_pppoe */
3411         if (n_tokens && (strcmp(tokens[0], "qinq_pppoe") == 0)) {
3412                 uint32_t svlan_pcp, svlan_dei, svlan_vid;
3413                 uint32_t cvlan_pcp, cvlan_dei, cvlan_vid;
3414
3415                 if ((n_tokens < 10) ||
3416                         parse_mac_addr(tokens[1],
3417                                 &a->encap.qinq_pppoe.ether.da) ||
3418                         parse_mac_addr(tokens[2],
3419                                 &a->encap.qinq_pppoe.ether.sa) ||
3420                         parser_read_uint32(&svlan_pcp, tokens[3]) ||
3421                         (svlan_pcp > 0x7) ||
3422                         parser_read_uint32(&svlan_dei, tokens[4]) ||
3423                         (svlan_dei > 0x1) ||
3424                         parser_read_uint32(&svlan_vid, tokens[5]) ||
3425                         (svlan_vid > 0xFFF) ||
3426                         parser_read_uint32(&cvlan_pcp, tokens[6]) ||
3427                         (cvlan_pcp > 0x7) ||
3428                         parser_read_uint32(&cvlan_dei, tokens[7]) ||
3429                         (cvlan_dei > 0x1) ||
3430                         parser_read_uint32(&cvlan_vid, tokens[8]) ||
3431                         (cvlan_vid > 0xFFF) ||
3432                         parser_read_uint16(&a->encap.qinq_pppoe.pppoe.session_id,
3433                                 tokens[9]))
3434                         return 0;
3435
3436                 a->encap.qinq_pppoe.svlan.pcp = svlan_pcp & 0x7;
3437                 a->encap.qinq_pppoe.svlan.dei = svlan_dei & 0x1;
3438                 a->encap.qinq_pppoe.svlan.vid = svlan_vid & 0xFFF;
3439                 a->encap.qinq_pppoe.cvlan.pcp = cvlan_pcp & 0x7;
3440                 a->encap.qinq_pppoe.cvlan.dei = cvlan_dei & 0x1;
3441                 a->encap.qinq_pppoe.cvlan.vid = cvlan_vid & 0xFFF;
3442                 a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ_PPPOE;
3443                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3444                 return 1 + 10;
3445
3446         }
3447
3448         /* mpls */
3449         if (n_tokens && (strcmp(tokens[0], "mpls") == 0)) {
3450                 uint32_t label, tc, ttl;
3451
3452                 if (n_tokens < 8)
3453                         return 0;
3454
3455                 if (strcmp(tokens[1], "unicast") == 0)
3456                         a->encap.mpls.unicast = 1;
3457                 else if (strcmp(tokens[1], "multicast") == 0)
3458                         a->encap.mpls.unicast = 0;
3459                 else
3460                         return 0;
3461
3462                 if (parse_mac_addr(tokens[2], &a->encap.mpls.ether.da) ||
3463                         parse_mac_addr(tokens[3], &a->encap.mpls.ether.sa) ||
3464                         strcmp(tokens[4], "label0") ||
3465                         parser_read_uint32(&label, tokens[5]) ||
3466                         (label > 0xFFFFF) ||
3467                         parser_read_uint32(&tc, tokens[6]) ||
3468                         (tc > 0x7) ||
3469                         parser_read_uint32(&ttl, tokens[7]) ||
3470                         (ttl > 0x3F))
3471                         return 0;
3472
3473                 a->encap.mpls.mpls[0].label = label;
3474                 a->encap.mpls.mpls[0].tc = tc;
3475                 a->encap.mpls.mpls[0].ttl = ttl;
3476
3477                 tokens += 8;
3478                 n_tokens -= 8;
3479
3480                 if ((n_tokens == 0) || strcmp(tokens[0], "label1")) {
3481                         a->encap.mpls.mpls_count = 1;
3482                         a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
3483                         a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3484                         return 1 + 8;
3485                 }
3486
3487                 if ((n_tokens < 4) ||
3488                         parser_read_uint32(&label, tokens[1]) ||
3489                         (label > 0xFFFFF) ||
3490                         parser_read_uint32(&tc, tokens[2]) ||
3491                         (tc > 0x7) ||
3492                         parser_read_uint32(&ttl, tokens[3]) ||
3493                         (ttl > 0x3F))
3494                         return 0;
3495
3496                 a->encap.mpls.mpls[1].label = label;
3497                 a->encap.mpls.mpls[1].tc = tc;
3498                 a->encap.mpls.mpls[1].ttl = ttl;
3499
3500                 tokens += 4;
3501                 n_tokens -= 4;
3502
3503                 if ((n_tokens == 0) || strcmp(tokens[0], "label2")) {
3504                         a->encap.mpls.mpls_count = 2;
3505                         a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
3506                         a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3507                         return 1 + 8 + 4;
3508                 }
3509
3510                 if ((n_tokens < 4) ||
3511                         parser_read_uint32(&label, tokens[1]) ||
3512                         (label > 0xFFFFF) ||
3513                         parser_read_uint32(&tc, tokens[2]) ||
3514                         (tc > 0x7) ||
3515                         parser_read_uint32(&ttl, tokens[3]) ||
3516                         (ttl > 0x3F))
3517                         return 0;
3518
3519                 a->encap.mpls.mpls[2].label = label;
3520                 a->encap.mpls.mpls[2].tc = tc;
3521                 a->encap.mpls.mpls[2].ttl = ttl;
3522
3523                 tokens += 4;
3524                 n_tokens -= 4;
3525
3526                 if ((n_tokens == 0) || strcmp(tokens[0], "label3")) {
3527                         a->encap.mpls.mpls_count = 3;
3528                         a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
3529                         a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3530                         return 1 + 8 + 4 + 4;
3531                 }
3532
3533                 if ((n_tokens < 4) ||
3534                         parser_read_uint32(&label, tokens[1]) ||
3535                         (label > 0xFFFFF) ||
3536                         parser_read_uint32(&tc, tokens[2]) ||
3537                         (tc > 0x7) ||
3538                         parser_read_uint32(&ttl, tokens[3]) ||
3539                         (ttl > 0x3F))
3540                         return 0;
3541
3542                 a->encap.mpls.mpls[3].label = label;
3543                 a->encap.mpls.mpls[3].tc = tc;
3544                 a->encap.mpls.mpls[3].ttl = ttl;
3545
3546                 a->encap.mpls.mpls_count = 4;
3547                 a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS;
3548                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3549                 return 1 + 8 + 4 + 4 + 4;
3550         }
3551
3552         /* pppoe */
3553         if (n_tokens && (strcmp(tokens[0], "pppoe") == 0)) {
3554                 if ((n_tokens < 4) ||
3555                         parse_mac_addr(tokens[1], &a->encap.pppoe.ether.da) ||
3556                         parse_mac_addr(tokens[2], &a->encap.pppoe.ether.sa) ||
3557                         parser_read_uint16(&a->encap.pppoe.pppoe.session_id,
3558                                 tokens[3]))
3559                         return 0;
3560
3561                 a->encap.type = RTE_TABLE_ACTION_ENCAP_PPPOE;
3562                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3563                 return 1 + 4;
3564         }
3565
3566         /* vxlan */
3567         if (n_tokens && (strcmp(tokens[0], "vxlan") == 0)) {
3568                 uint32_t n = 0;
3569
3570                 n_tokens--;
3571                 tokens++;
3572                 n++;
3573
3574                 /* ether <da> <sa> */
3575                 if ((n_tokens < 3) ||
3576                         strcmp(tokens[0], "ether") ||
3577                         parse_mac_addr(tokens[1], &a->encap.vxlan.ether.da) ||
3578                         parse_mac_addr(tokens[2], &a->encap.vxlan.ether.sa))
3579                         return 0;
3580
3581                 n_tokens -= 3;
3582                 tokens += 3;
3583                 n += 3;
3584
3585                 /* [vlan <pcp> <dei> <vid>] */
3586                 if (strcmp(tokens[0], "vlan") == 0) {
3587                         uint32_t pcp, dei, vid;
3588
3589                         if ((n_tokens < 4) ||
3590                                 parser_read_uint32(&pcp, tokens[1]) ||
3591                                 (pcp > 7) ||
3592                                 parser_read_uint32(&dei, tokens[2]) ||
3593                                 (dei > 1) ||
3594                                 parser_read_uint32(&vid, tokens[3]) ||
3595                                 (vid > 0xFFF))
3596                                 return 0;
3597
3598                         a->encap.vxlan.vlan.pcp = pcp;
3599                         a->encap.vxlan.vlan.dei = dei;
3600                         a->encap.vxlan.vlan.vid = vid;
3601
3602                         n_tokens -= 4;
3603                         tokens += 4;
3604                         n += 4;
3605                 }
3606
3607                 /* ipv4 <sa> <da> <dscp> <ttl>
3608                    | ipv6 <sa> <da> <flow_label> <dscp> <hop_limit> */
3609                 if (strcmp(tokens[0], "ipv4") == 0) {
3610                         struct in_addr sa, da;
3611                         uint8_t dscp, ttl;
3612
3613                         if ((n_tokens < 5) ||
3614                                 parse_ipv4_addr(tokens[1], &sa) ||
3615                                 parse_ipv4_addr(tokens[2], &da) ||
3616                                 parser_read_uint8(&dscp, tokens[3]) ||
3617                                 (dscp > 64) ||
3618                                 parser_read_uint8(&ttl, tokens[4]))
3619                                 return 0;
3620
3621                         a->encap.vxlan.ipv4.sa = rte_be_to_cpu_32(sa.s_addr);
3622                         a->encap.vxlan.ipv4.da = rte_be_to_cpu_32(da.s_addr);
3623                         a->encap.vxlan.ipv4.dscp = dscp;
3624                         a->encap.vxlan.ipv4.ttl = ttl;
3625
3626                         n_tokens -= 5;
3627                         tokens += 5;
3628                         n += 5;
3629                 } else if (strcmp(tokens[0], "ipv6") == 0) {
3630                         struct in6_addr sa, da;
3631                         uint32_t flow_label;
3632                         uint8_t dscp, hop_limit;
3633
3634                         if ((n_tokens < 6) ||
3635                                 parse_ipv6_addr(tokens[1], &sa) ||
3636                                 parse_ipv6_addr(tokens[2], &da) ||
3637                                 parser_read_uint32(&flow_label, tokens[3]) ||
3638                                 parser_read_uint8(&dscp, tokens[4]) ||
3639                                 (dscp > 64) ||
3640                                 parser_read_uint8(&hop_limit, tokens[5]))
3641                                 return 0;
3642
3643                         memcpy(a->encap.vxlan.ipv6.sa, sa.s6_addr, 16);
3644                         memcpy(a->encap.vxlan.ipv6.da, da.s6_addr, 16);
3645                         a->encap.vxlan.ipv6.flow_label = flow_label;
3646                         a->encap.vxlan.ipv6.dscp = dscp;
3647                         a->encap.vxlan.ipv6.hop_limit = hop_limit;
3648
3649                         n_tokens -= 6;
3650                         tokens += 6;
3651                         n += 6;
3652                 } else
3653                         return 0;
3654
3655                 /* udp <sp> <dp> */
3656                 if ((n_tokens < 3) ||
3657                         strcmp(tokens[0], "udp") ||
3658                         parser_read_uint16(&a->encap.vxlan.udp.sp, tokens[1]) ||
3659                         parser_read_uint16(&a->encap.vxlan.udp.dp, tokens[2]))
3660                         return 0;
3661
3662                 n_tokens -= 3;
3663                 tokens += 3;
3664                 n += 3;
3665
3666                 /* vxlan <vni> */
3667                 if ((n_tokens < 2) ||
3668                         strcmp(tokens[0], "vxlan") ||
3669                         parser_read_uint32(&a->encap.vxlan.vxlan.vni, tokens[1]) ||
3670                         (a->encap.vxlan.vxlan.vni > 0xFFFFFF))
3671                         return 0;
3672
3673                 n_tokens -= 2;
3674                 tokens += 2;
3675                 n += 2;
3676
3677                 a->encap.type = RTE_TABLE_ACTION_ENCAP_VXLAN;
3678                 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP;
3679                 return 1 + n;
3680         }
3681
3682         return 0;
3683 }
3684
3685 static uint32_t
3686 parse_table_action_nat(char **tokens,
3687         uint32_t n_tokens,
3688         struct table_rule_action *a)
3689 {
3690         if ((n_tokens < 4) ||
3691                 strcmp(tokens[0], "nat"))
3692                 return 0;
3693
3694         if (strcmp(tokens[1], "ipv4") == 0) {
3695                 struct in_addr addr;
3696                 uint16_t port;
3697
3698                 if (parse_ipv4_addr(tokens[2], &addr) ||
3699                         parser_read_uint16(&port, tokens[3]))
3700                         return 0;
3701
3702                 a->nat.ip_version = 1;
3703                 a->nat.addr.ipv4 = rte_be_to_cpu_32(addr.s_addr);
3704                 a->nat.port = port;
3705                 a->action_mask |= 1 << RTE_TABLE_ACTION_NAT;
3706                 return 4;
3707         }
3708
3709         if (strcmp(tokens[1], "ipv6") == 0) {
3710                 struct in6_addr addr;
3711                 uint16_t port;
3712
3713                 if (parse_ipv6_addr(tokens[2], &addr) ||
3714                         parser_read_uint16(&port, tokens[3]))
3715                         return 0;
3716
3717                 a->nat.ip_version = 0;
3718                 memcpy(a->nat.addr.ipv6, addr.s6_addr, 16);
3719                 a->nat.port = port;
3720                 a->action_mask |= 1 << RTE_TABLE_ACTION_NAT;
3721                 return 4;
3722         }
3723
3724         return 0;
3725 }
3726
3727 static uint32_t
3728 parse_table_action_ttl(char **tokens,
3729         uint32_t n_tokens,
3730         struct table_rule_action *a)
3731 {
3732         if ((n_tokens < 2) ||
3733                 strcmp(tokens[0], "ttl"))
3734                 return 0;
3735
3736         if (strcmp(tokens[1], "dec") == 0)
3737                 a->ttl.decrement = 1;
3738         else if (strcmp(tokens[1], "keep") == 0)
3739                 a->ttl.decrement = 0;
3740         else
3741                 return 0;
3742
3743         a->action_mask |= 1 << RTE_TABLE_ACTION_TTL;
3744         return 2;
3745 }
3746
3747 static uint32_t
3748 parse_table_action_stats(char **tokens,
3749         uint32_t n_tokens,
3750         struct table_rule_action *a)
3751 {
3752         if ((n_tokens < 1) ||
3753                 strcmp(tokens[0], "stats"))
3754                 return 0;
3755
3756         a->stats.n_packets = 0;
3757         a->stats.n_bytes = 0;
3758         a->action_mask |= 1 << RTE_TABLE_ACTION_STATS;
3759         return 1;
3760 }
3761
3762 static uint32_t
3763 parse_table_action_time(char **tokens,
3764         uint32_t n_tokens,
3765         struct table_rule_action *a)
3766 {
3767         if ((n_tokens < 1) ||
3768                 strcmp(tokens[0], "time"))
3769                 return 0;
3770
3771         a->time.time = rte_rdtsc();
3772         a->action_mask |= 1 << RTE_TABLE_ACTION_TIME;
3773         return 1;
3774 }
3775
3776 static void
3777 parse_free_sym_crypto_param_data(struct rte_table_action_sym_crypto_params *p)
3778 {
3779         struct rte_crypto_sym_xform *xform[2] = {NULL};
3780         uint32_t i;
3781
3782         xform[0] = p->xform;
3783         if (xform[0])
3784                 xform[1] = xform[0]->next;
3785
3786         for (i = 0; i < 2; i++) {
3787                 if (xform[i] == NULL)
3788                         continue;
3789
3790                 switch (xform[i]->type) {
3791                 case RTE_CRYPTO_SYM_XFORM_CIPHER:
3792                         if (p->cipher_auth.cipher_iv.val)
3793                                 free(p->cipher_auth.cipher_iv.val);
3794                         if (p->cipher_auth.cipher_iv_update.val)
3795                                 free(p->cipher_auth.cipher_iv_update.val);
3796                         break;
3797                 case RTE_CRYPTO_SYM_XFORM_AUTH:
3798                         if (p->cipher_auth.auth_iv.val)
3799                                 free(p->cipher_auth.cipher_iv.val);
3800                         if (p->cipher_auth.auth_iv_update.val)
3801                                 free(p->cipher_auth.cipher_iv_update.val);
3802                         break;
3803                 case RTE_CRYPTO_SYM_XFORM_AEAD:
3804                         if (p->aead.iv.val)
3805                                 free(p->aead.iv.val);
3806                         if (p->aead.aad.val)
3807                                 free(p->aead.aad.val);
3808                         break;
3809                 default:
3810                         continue;
3811                 }
3812         }
3813
3814 }
3815
3816 static struct rte_crypto_sym_xform *
3817 parse_table_action_cipher(struct rte_table_action_sym_crypto_params *p,
3818                 uint8_t *key, uint32_t max_key_len, char **tokens,
3819                 uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
3820 {
3821         struct rte_crypto_sym_xform *xform_cipher;
3822         int status;
3823         size_t len;
3824
3825         if (n_tokens < 7 || strcmp(tokens[1], "cipher_algo") ||
3826                         strcmp(tokens[3], "cipher_key") ||
3827                         strcmp(tokens[5], "cipher_iv"))
3828                 return NULL;
3829
3830         xform_cipher = calloc(1, sizeof(*xform_cipher));
3831         if (xform_cipher == NULL)
3832                 return NULL;
3833
3834         xform_cipher->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3835         xform_cipher->cipher.op = encrypt ? RTE_CRYPTO_CIPHER_OP_ENCRYPT :
3836                         RTE_CRYPTO_CIPHER_OP_DECRYPT;
3837
3838         /* cipher_algo */
3839         status = rte_cryptodev_get_cipher_algo_enum(
3840                         &xform_cipher->cipher.algo, tokens[2]);
3841         if (status < 0)
3842                 goto error_exit;
3843
3844         /* cipher_key */
3845         len = strlen(tokens[4]);
3846         if (len / 2 > max_key_len) {
3847                 status = -ENOMEM;
3848                 goto error_exit;
3849         }
3850
3851         status = parse_hex_string(tokens[4], key, (uint32_t *)&len);
3852         if (status < 0)
3853                 goto error_exit;
3854
3855         xform_cipher->cipher.key.data = key;
3856         xform_cipher->cipher.key.length = (uint16_t)len;
3857
3858         /* cipher_iv */
3859         len = strlen(tokens[6]);
3860
3861         p->cipher_auth.cipher_iv.val = calloc(1, len / 2 + 1);
3862         if (p->cipher_auth.cipher_iv.val == NULL)
3863                 goto error_exit;
3864
3865         status = parse_hex_string(tokens[6],
3866                         p->cipher_auth.cipher_iv.val,
3867                         (uint32_t *)&len);
3868         if (status < 0)
3869                 goto error_exit;
3870
3871         xform_cipher->cipher.iv.length = (uint16_t)len;
3872         xform_cipher->cipher.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET;
3873         p->cipher_auth.cipher_iv.length = (uint32_t)len;
3874         *used_n_tokens = 7;
3875
3876         return xform_cipher;
3877
3878 error_exit:
3879         if (p->cipher_auth.cipher_iv.val) {
3880                 free(p->cipher_auth.cipher_iv.val);
3881                 p->cipher_auth.cipher_iv.val = NULL;
3882         }
3883
3884         free(xform_cipher);
3885
3886         return NULL;
3887 }
3888
3889 static struct rte_crypto_sym_xform *
3890 parse_table_action_cipher_auth(struct rte_table_action_sym_crypto_params *p,
3891                 uint8_t *key, uint32_t max_key_len, char **tokens,
3892                 uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
3893 {
3894         struct rte_crypto_sym_xform *xform_cipher;
3895         struct rte_crypto_sym_xform *xform_auth;
3896         int status;
3897         size_t len;
3898
3899         if (n_tokens < 13 ||
3900                         strcmp(tokens[7], "auth_algo") ||
3901                         strcmp(tokens[9], "auth_key") ||
3902                         strcmp(tokens[11], "digest_size"))
3903                 return NULL;
3904
3905         xform_auth = calloc(1, sizeof(*xform_auth));
3906         if (xform_auth == NULL)
3907                 return NULL;
3908
3909         xform_auth->type = RTE_CRYPTO_SYM_XFORM_AUTH;
3910         xform_auth->auth.op = encrypt ? RTE_CRYPTO_AUTH_OP_GENERATE :
3911                         RTE_CRYPTO_AUTH_OP_VERIFY;
3912
3913         /* auth_algo */
3914         status = rte_cryptodev_get_auth_algo_enum(&xform_auth->auth.algo,
3915                         tokens[8]);
3916         if (status < 0)
3917                 goto error_exit;
3918
3919         /* auth_key */
3920         len = strlen(tokens[10]);
3921         if (len / 2 > max_key_len) {
3922                 status = -ENOMEM;
3923                 goto error_exit;
3924         }
3925
3926         status = parse_hex_string(tokens[10], key, (uint32_t *)&len);
3927         if (status < 0)
3928                 goto error_exit;
3929
3930         xform_auth->auth.key.data = key;
3931         xform_auth->auth.key.length = (uint16_t)len;
3932
3933         key += xform_auth->auth.key.length;
3934         max_key_len -= xform_auth->auth.key.length;
3935
3936         if (strcmp(tokens[11], "digest_size"))
3937                 goto error_exit;
3938
3939         status = parser_read_uint16(&xform_auth->auth.digest_length,
3940                         tokens[12]);
3941         if (status < 0)
3942                 goto error_exit;
3943
3944         xform_cipher = parse_table_action_cipher(p, key, max_key_len, tokens,
3945                         7, encrypt, used_n_tokens);
3946         if (xform_cipher == NULL)
3947                 goto error_exit;
3948
3949         *used_n_tokens += 6;
3950
3951         if (encrypt) {
3952                 xform_cipher->next = xform_auth;
3953                 return xform_cipher;
3954         } else {
3955                 xform_auth->next = xform_cipher;
3956                 return xform_auth;
3957         }
3958
3959 error_exit:
3960         if (p->cipher_auth.auth_iv.val) {
3961                 free(p->cipher_auth.auth_iv.val);
3962                 p->cipher_auth.auth_iv.val = 0;
3963         }
3964
3965         free(xform_auth);
3966
3967         return NULL;
3968 }
3969
3970 static struct rte_crypto_sym_xform *
3971 parse_table_action_aead(struct rte_table_action_sym_crypto_params *p,
3972                 uint8_t *key, uint32_t max_key_len, char **tokens,
3973                 uint32_t n_tokens, uint32_t encrypt, uint32_t *used_n_tokens)
3974 {
3975         struct rte_crypto_sym_xform *xform_aead;
3976         int status;
3977         size_t len;
3978
3979         if (n_tokens < 11 || strcmp(tokens[1], "aead_algo") ||
3980                         strcmp(tokens[3], "aead_key") ||
3981                         strcmp(tokens[5], "aead_iv") ||
3982                         strcmp(tokens[7], "aead_aad") ||
3983                         strcmp(tokens[9], "digest_size"))
3984                 return NULL;
3985
3986         xform_aead = calloc(1, sizeof(*xform_aead));
3987         if (xform_aead == NULL)
3988                 return NULL;
3989
3990         xform_aead->type = RTE_CRYPTO_SYM_XFORM_AEAD;
3991         xform_aead->aead.op = encrypt ? RTE_CRYPTO_AEAD_OP_ENCRYPT :
3992                         RTE_CRYPTO_AEAD_OP_DECRYPT;
3993
3994         /* aead_algo */
3995         status = rte_cryptodev_get_aead_algo_enum(&xform_aead->aead.algo,
3996                         tokens[2]);
3997         if (status < 0)
3998                 goto error_exit;
3999
4000         /* aead_key */
4001         len = strlen(tokens[4]);
4002         if (len / 2 > max_key_len) {
4003                 status = -ENOMEM;
4004                 goto error_exit;
4005         }
4006
4007         status = parse_hex_string(tokens[4], key, (uint32_t *)&len);
4008         if (status < 0)
4009                 goto error_exit;
4010
4011         xform_aead->aead.key.data = key;
4012         xform_aead->aead.key.length = (uint16_t)len;
4013
4014         /* aead_iv */
4015         len = strlen(tokens[6]);
4016         p->aead.iv.val = calloc(1, len / 2 + 1);
4017         if (p->aead.iv.val == NULL)
4018                 goto error_exit;
4019
4020         status = parse_hex_string(tokens[6], p->aead.iv.val,
4021                         (uint32_t *)&len);
4022         if (status < 0)
4023                 goto error_exit;
4024
4025         xform_aead->aead.iv.length = (uint16_t)len;
4026         xform_aead->aead.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET;
4027         p->aead.iv.length = (uint32_t)len;
4028
4029         /* aead_aad */
4030         len = strlen(tokens[8]);
4031         p->aead.aad.val = calloc(1, len / 2 + 1);
4032         if (p->aead.aad.val == NULL)
4033                 goto error_exit;
4034
4035         status = parse_hex_string(tokens[8], p->aead.aad.val, (uint32_t *)&len);
4036         if (status < 0)
4037                 goto error_exit;
4038
4039         xform_aead->aead.aad_length = (uint16_t)len;
4040         p->aead.aad.length = (uint32_t)len;
4041
4042         /* digest_size */
4043         status = parser_read_uint16(&xform_aead->aead.digest_length,
4044                         tokens[10]);
4045         if (status < 0)
4046                 goto error_exit;
4047
4048         *used_n_tokens = 11;
4049
4050         return xform_aead;
4051
4052 error_exit:
4053         if (p->aead.iv.val) {
4054                 free(p->aead.iv.val);
4055                 p->aead.iv.val = NULL;
4056         }
4057         if (p->aead.aad.val) {
4058                 free(p->aead.aad.val);
4059                 p->aead.aad.val = NULL;
4060         }
4061
4062         free(xform_aead);
4063
4064         return NULL;
4065 }
4066
4067
4068 static uint32_t
4069 parse_table_action_sym_crypto(char **tokens,
4070         uint32_t n_tokens,
4071         struct table_rule_action *a)
4072 {
4073         struct rte_table_action_sym_crypto_params *p = &a->sym_crypto;
4074         struct rte_crypto_sym_xform *xform = NULL;
4075         uint8_t *key = a->sym_crypto_key;
4076         uint32_t max_key_len = SYM_CRYPTO_MAX_KEY_SIZE;
4077         uint32_t used_n_tokens;
4078         uint32_t encrypt;
4079         int status;
4080
4081         if ((n_tokens < 12) ||
4082                 strcmp(tokens[0], "sym_crypto") ||
4083                 strcmp(tokens[2], "type"))
4084                 return 0;
4085
4086         memset(p, 0, sizeof(*p));
4087
4088         if (strcmp(tokens[1], "encrypt") == 0)
4089                 encrypt = 1;
4090         else
4091                 encrypt = 0;
4092
4093         status = parser_read_uint32(&p->data_offset, tokens[n_tokens - 1]);
4094         if (status < 0)
4095                 return 0;
4096
4097         if (strcmp(tokens[3], "cipher") == 0) {
4098                 tokens += 3;
4099                 n_tokens -= 3;
4100
4101                 xform = parse_table_action_cipher(p, key, max_key_len, tokens,
4102                                 n_tokens, encrypt, &used_n_tokens);
4103         } else if (strcmp(tokens[3], "cipher_auth") == 0) {
4104                 tokens += 3;
4105                 n_tokens -= 3;
4106
4107                 xform = parse_table_action_cipher_auth(p, key, max_key_len,
4108                                 tokens, n_tokens, encrypt, &used_n_tokens);
4109         } else if (strcmp(tokens[3], "aead") == 0) {
4110                 tokens += 3;
4111                 n_tokens -= 3;
4112
4113                 xform = parse_table_action_aead(p, key, max_key_len, tokens,
4114                                 n_tokens, encrypt, &used_n_tokens);
4115         }
4116
4117         if (xform == NULL)
4118                 return 0;
4119
4120         p->xform = xform;
4121
4122         if (strcmp(tokens[used_n_tokens], "data_offset")) {
4123                 parse_free_sym_crypto_param_data(p);
4124                 return 0;
4125         }
4126
4127         a->action_mask |= 1 << RTE_TABLE_ACTION_SYM_CRYPTO;
4128
4129         return used_n_tokens + 5;
4130 }
4131
4132 static uint32_t
4133 parse_table_action_tag(char **tokens,
4134         uint32_t n_tokens,
4135         struct table_rule_action *a)
4136 {
4137         if ((n_tokens < 2) ||
4138                 strcmp(tokens[0], "tag"))
4139                 return 0;
4140
4141         if (parser_read_uint32(&a->tag.tag, tokens[1]))
4142                 return 0;
4143
4144         a->action_mask |= 1 << RTE_TABLE_ACTION_TAG;
4145         return 2;
4146 }
4147
4148 static uint32_t
4149 parse_table_action_decap(char **tokens,
4150         uint32_t n_tokens,
4151         struct table_rule_action *a)
4152 {
4153         if ((n_tokens < 2) ||
4154                 strcmp(tokens[0], "decap"))
4155                 return 0;
4156
4157         if (parser_read_uint16(&a->decap.n, tokens[1]))
4158                 return 0;
4159
4160         a->action_mask |= 1 << RTE_TABLE_ACTION_DECAP;
4161         return 2;
4162 }
4163
4164 static uint32_t
4165 parse_table_action(char **tokens,
4166         uint32_t n_tokens,
4167         char *out,
4168         size_t out_size,
4169         struct table_rule_action *a)
4170 {
4171         uint32_t n_tokens0 = n_tokens;
4172
4173         memset(a, 0, sizeof(*a));
4174
4175         if ((n_tokens < 2) ||
4176                 strcmp(tokens[0], "action"))
4177                 return 0;
4178
4179         tokens++;
4180         n_tokens--;
4181
4182         if (n_tokens && (strcmp(tokens[0], "fwd") == 0)) {
4183                 uint32_t n;
4184
4185                 n = parse_table_action_fwd(tokens, n_tokens, a);
4186                 if (n == 0) {
4187                         snprintf(out, out_size, MSG_ARG_INVALID,
4188                                 "action fwd");
4189                         return 0;
4190                 }
4191
4192                 tokens += n;
4193                 n_tokens -= n;
4194         }
4195
4196         if (n_tokens && (strcmp(tokens[0], "balance") == 0)) {
4197                 uint32_t n;
4198
4199                 n = parse_table_action_balance(tokens, n_tokens, a);
4200                 if (n == 0) {
4201                         snprintf(out, out_size, MSG_ARG_INVALID,
4202                                 "action balance");
4203                         return 0;
4204                 }
4205
4206                 tokens += n;
4207                 n_tokens -= n;
4208         }
4209
4210         if (n_tokens && (strcmp(tokens[0], "meter") == 0)) {
4211                 uint32_t n;
4212
4213                 n = parse_table_action_meter(tokens, n_tokens, a);
4214                 if (n == 0) {
4215                         snprintf(out, out_size, MSG_ARG_INVALID,
4216                                 "action meter");
4217                         return 0;
4218                 }
4219
4220                 tokens += n;
4221                 n_tokens -= n;
4222         }
4223
4224         if (n_tokens && (strcmp(tokens[0], "tm") == 0)) {
4225                 uint32_t n;
4226
4227                 n = parse_table_action_tm(tokens, n_tokens, a);
4228                 if (n == 0) {
4229                         snprintf(out, out_size, MSG_ARG_INVALID,
4230                                 "action tm");
4231                         return 0;
4232                 }
4233
4234                 tokens += n;
4235                 n_tokens -= n;
4236         }
4237
4238         if (n_tokens && (strcmp(tokens[0], "encap") == 0)) {
4239                 uint32_t n;
4240
4241                 n = parse_table_action_encap(tokens, n_tokens, a);
4242                 if (n == 0) {
4243                         snprintf(out, out_size, MSG_ARG_INVALID,
4244                                 "action encap");
4245                         return 0;
4246                 }
4247
4248                 tokens += n;
4249                 n_tokens -= n;
4250         }
4251
4252         if (n_tokens && (strcmp(tokens[0], "nat") == 0)) {
4253                 uint32_t n;
4254
4255                 n = parse_table_action_nat(tokens, n_tokens, a);
4256                 if (n == 0) {
4257                         snprintf(out, out_size, MSG_ARG_INVALID,
4258                                 "action nat");
4259                         return 0;
4260                 }
4261
4262                 tokens += n;
4263                 n_tokens -= n;
4264         }
4265
4266         if (n_tokens && (strcmp(tokens[0], "ttl") == 0)) {
4267                 uint32_t n;
4268
4269                 n = parse_table_action_ttl(tokens, n_tokens, a);
4270                 if (n == 0) {
4271                         snprintf(out, out_size, MSG_ARG_INVALID,
4272                                 "action ttl");
4273                         return 0;
4274                 }
4275
4276                 tokens += n;
4277                 n_tokens -= n;
4278         }
4279
4280         if (n_tokens && (strcmp(tokens[0], "stats") == 0)) {
4281                 uint32_t n;
4282
4283                 n = parse_table_action_stats(tokens, n_tokens, a);
4284                 if (n == 0) {
4285                         snprintf(out, out_size, MSG_ARG_INVALID,
4286                                 "action stats");
4287                         return 0;
4288                 }
4289
4290                 tokens += n;
4291                 n_tokens -= n;
4292         }
4293
4294         if (n_tokens && (strcmp(tokens[0], "time") == 0)) {
4295                 uint32_t n;
4296
4297                 n = parse_table_action_time(tokens, n_tokens, a);
4298                 if (n == 0) {
4299                         snprintf(out, out_size, MSG_ARG_INVALID,
4300                                 "action time");
4301                         return 0;
4302                 }
4303
4304                 tokens += n;
4305                 n_tokens -= n;
4306         }
4307
4308         if (n_tokens && (strcmp(tokens[0], "sym_crypto") == 0)) {
4309                 uint32_t n;
4310
4311                 n = parse_table_action_sym_crypto(tokens, n_tokens, a);
4312                 if (n == 0) {
4313                         snprintf(out, out_size, MSG_ARG_INVALID,
4314                                 "action sym_crypto");
4315                 }
4316
4317                 tokens += n;
4318                 n_tokens -= n;
4319         }
4320
4321         if (n_tokens && (strcmp(tokens[0], "tag") == 0)) {
4322                 uint32_t n;
4323
4324                 n = parse_table_action_tag(tokens, n_tokens, a);
4325                 if (n == 0) {
4326                         snprintf(out, out_size, MSG_ARG_INVALID,
4327                                 "action tag");
4328                         return 0;
4329                 }
4330
4331                 tokens += n;
4332                 n_tokens -= n;
4333         }
4334
4335         if (n_tokens && (strcmp(tokens[0], "decap") == 0)) {
4336                 uint32_t n;
4337
4338                 n = parse_table_action_decap(tokens, n_tokens, a);
4339                 if (n == 0) {
4340                         snprintf(out, out_size, MSG_ARG_INVALID,
4341                                 "action decap");
4342                         return 0;
4343                 }
4344
4345                 tokens += n;
4346                 n_tokens -= n;
4347         }
4348
4349         if (n_tokens0 - n_tokens == 1) {
4350                 snprintf(out, out_size, MSG_ARG_INVALID, "action");
4351                 return 0;
4352         }
4353
4354         return n_tokens0 - n_tokens;
4355 }
4356
4357
4358 static const char cmd_pipeline_table_rule_add_help[] =
4359 "pipeline <pipeline_name> table <table_id> rule add\n"
4360 "     match <match>\n"
4361 "     action <table_action>\n";
4362
4363 static void
4364 cmd_pipeline_table_rule_add(char **tokens,
4365         uint32_t n_tokens,
4366         char *out,
4367         size_t out_size)
4368 {
4369         struct table_rule_match m;
4370         struct table_rule_action a;
4371         char *pipeline_name;
4372         uint32_t table_id, t0, n_tokens_parsed;
4373         int status;
4374
4375         if (n_tokens < 8) {
4376                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4377                 return;
4378         }
4379
4380         pipeline_name = tokens[1];
4381
4382         if (strcmp(tokens[2], "table") != 0) {
4383                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
4384                 return;
4385         }
4386
4387         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
4388                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4389                 return;
4390         }
4391
4392         if (strcmp(tokens[4], "rule") != 0) {
4393                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
4394                 return;
4395         }
4396
4397         if (strcmp(tokens[5], "add") != 0) {
4398                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
4399                 return;
4400         }
4401
4402         t0 = 6;
4403
4404         /* match */
4405         n_tokens_parsed = parse_match(tokens + t0,
4406                 n_tokens - t0,
4407                 out,
4408                 out_size,
4409                 &m);
4410         if (n_tokens_parsed == 0)
4411                 return;
4412         t0 += n_tokens_parsed;
4413
4414         /* action */
4415         n_tokens_parsed = parse_table_action(tokens + t0,
4416                 n_tokens - t0,
4417                 out,
4418                 out_size,
4419                 &a);
4420         if (n_tokens_parsed == 0)
4421                 return;
4422         t0 += n_tokens_parsed;
4423
4424         if (t0 != n_tokens) {
4425                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
4426                 return;
4427         }
4428
4429         status = pipeline_table_rule_add(pipeline_name, table_id, &m, &a);
4430         if (status) {
4431                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
4432                 return;
4433         }
4434
4435         if (a.action_mask & 1 << RTE_TABLE_ACTION_SYM_CRYPTO)
4436                 parse_free_sym_crypto_param_data(&a.sym_crypto);
4437 }
4438
4439
4440 static const char cmd_pipeline_table_rule_add_default_help[] =
4441 "pipeline <pipeline_name> table <table_id> rule add\n"
4442 "     match\n"
4443 "        default\n"
4444 "     action\n"
4445 "        fwd\n"
4446 "           drop\n"
4447 "           | port <port_id>\n"
4448 "           | meta\n"
4449 "           | table <table_id>\n";
4450
4451 static void
4452 cmd_pipeline_table_rule_add_default(char **tokens,
4453         uint32_t n_tokens,
4454         char *out,
4455         size_t out_size)
4456 {
4457         struct table_rule_action action;
4458         char *pipeline_name;
4459         uint32_t table_id;
4460         int status;
4461
4462         if ((n_tokens != 11) && (n_tokens != 12)) {
4463                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4464                 return;
4465         }
4466
4467         pipeline_name = tokens[1];
4468
4469         if (strcmp(tokens[2], "table") != 0) {
4470                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
4471                 return;
4472         }
4473
4474         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
4475                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4476                 return;
4477         }
4478
4479         if (strcmp(tokens[4], "rule") != 0) {
4480                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
4481                 return;
4482         }
4483
4484         if (strcmp(tokens[5], "add") != 0) {
4485                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
4486                 return;
4487         }
4488
4489         if (strcmp(tokens[6], "match") != 0) {
4490                 snprintf(out, out_size, MSG_ARG_INVALID, "match");
4491                 return;
4492         }
4493
4494         if (strcmp(tokens[7], "default") != 0) {
4495                 snprintf(out, out_size, MSG_ARG_INVALID, "default");
4496                 return;
4497         }
4498
4499         if (strcmp(tokens[8], "action") != 0) {
4500                 snprintf(out, out_size, MSG_ARG_INVALID, "action");
4501                 return;
4502         }
4503
4504         if (strcmp(tokens[9], "fwd") != 0) {
4505                 snprintf(out, out_size, MSG_ARG_INVALID, "fwd");
4506                 return;
4507         }
4508
4509         action.action_mask = 1 << RTE_TABLE_ACTION_FWD;
4510
4511         if (strcmp(tokens[10], "drop") == 0) {
4512                 if (n_tokens != 11) {
4513                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4514                         return;
4515                 }
4516
4517                 action.fwd.action = RTE_PIPELINE_ACTION_DROP;
4518         } else if (strcmp(tokens[10], "port") == 0) {
4519                 uint32_t id;
4520
4521                 if (n_tokens != 12) {
4522                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4523                         return;
4524                 }
4525
4526                 if (parser_read_uint32(&id, tokens[11]) != 0) {
4527                         snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
4528                         return;
4529                 }
4530
4531                 action.fwd.action = RTE_PIPELINE_ACTION_PORT;
4532                 action.fwd.id = id;
4533         } else if (strcmp(tokens[10], "meta") == 0) {
4534                 if (n_tokens != 11) {
4535                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4536                         return;
4537                 }
4538
4539                 action.fwd.action = RTE_PIPELINE_ACTION_PORT_META;
4540         } else if (strcmp(tokens[10], "table") == 0) {
4541                 uint32_t id;
4542
4543                 if (n_tokens != 12) {
4544                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4545                         return;
4546                 }
4547
4548                 if (parser_read_uint32(&id, tokens[11]) != 0) {
4549                         snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4550                         return;
4551                 }
4552
4553                 action.fwd.action = RTE_PIPELINE_ACTION_TABLE;
4554                 action.fwd.id = id;
4555         } else {
4556                 snprintf(out, out_size, MSG_ARG_INVALID,
4557                         "drop or port or meta or table");
4558                 return;
4559         }
4560
4561         status = pipeline_table_rule_add_default(pipeline_name,
4562                 table_id,
4563                 &action);
4564         if (status) {
4565                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
4566                 return;
4567         }
4568 }
4569
4570
4571 static const char cmd_pipeline_table_rule_add_bulk_help[] =
4572 "pipeline <pipeline_name> table <table_id> rule add bulk <file_name>\n"
4573 "\n"
4574 "  File <file_name>:\n"
4575 "  - line format: match <match> action <action>\n";
4576
4577 static int
4578 cli_rule_file_process(const char *file_name,
4579         size_t line_len_max,
4580         struct table_rule_list **rule_list,
4581         uint32_t *n_rules,
4582         uint32_t *line_number,
4583         char *out,
4584         size_t out_size);
4585
4586 static void
4587 cmd_pipeline_table_rule_add_bulk(char **tokens,
4588         uint32_t n_tokens,
4589         char *out,
4590         size_t out_size)
4591 {
4592         struct table_rule_list *list = NULL;
4593         char *pipeline_name, *file_name;
4594         uint32_t table_id, n_rules, n_rules_added, n_rules_not_added, line_number;
4595         int status;
4596
4597         if (n_tokens != 8) {
4598                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4599                 return;
4600         }
4601
4602         pipeline_name = tokens[1];
4603
4604         if (strcmp(tokens[2], "table") != 0) {
4605                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
4606                 return;
4607         }
4608
4609         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
4610                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4611                 return;
4612         }
4613
4614         if (strcmp(tokens[4], "rule") != 0) {
4615                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
4616                 return;
4617         }
4618
4619         if (strcmp(tokens[5], "add") != 0) {
4620                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
4621                 return;
4622         }
4623
4624         if (strcmp(tokens[6], "bulk") != 0) {
4625                 snprintf(out, out_size, MSG_ARG_INVALID, "bulk");
4626                 return;
4627         }
4628
4629         file_name = tokens[7];
4630
4631         /* Load rules from file. */
4632         status = cli_rule_file_process(file_name,
4633                 1024,
4634                 &list,
4635                 &n_rules,
4636                 &line_number,
4637                 out,
4638                 out_size);
4639         if (status) {
4640                 snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number);
4641                 return;
4642         }
4643
4644         /* Rule bulk add */
4645         status = pipeline_table_rule_add_bulk(pipeline_name,
4646                 table_id,
4647                 list,
4648                 &n_rules_added,
4649                 &n_rules_not_added);
4650         if (status) {
4651                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
4652                 return;
4653         }
4654
4655         snprintf(out, out_size, "Added %u rules out of %u.\n",
4656                 n_rules_added,
4657                 n_rules);
4658 }
4659
4660
4661 static const char cmd_pipeline_table_rule_delete_help[] =
4662 "pipeline <pipeline_name> table <table_id> rule delete\n"
4663 "     match <match>\n";
4664
4665 static void
4666 cmd_pipeline_table_rule_delete(char **tokens,
4667         uint32_t n_tokens,
4668         char *out,
4669         size_t out_size)
4670 {
4671         struct table_rule_match m;
4672         char *pipeline_name;
4673         uint32_t table_id, n_tokens_parsed, t0;
4674         int status;
4675
4676         if (n_tokens < 8) {
4677                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4678                 return;
4679         }
4680
4681         pipeline_name = tokens[1];
4682
4683         if (strcmp(tokens[2], "table") != 0) {
4684                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
4685                 return;
4686         }
4687
4688         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
4689                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4690                 return;
4691         }
4692
4693         if (strcmp(tokens[4], "rule") != 0) {
4694                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
4695                 return;
4696         }
4697
4698         if (strcmp(tokens[5], "delete") != 0) {
4699                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
4700                 return;
4701         }
4702
4703         t0 = 6;
4704
4705         /* match */
4706         n_tokens_parsed = parse_match(tokens + t0,
4707                 n_tokens - t0,
4708                 out,
4709                 out_size,
4710                 &m);
4711         if (n_tokens_parsed == 0)
4712                 return;
4713         t0 += n_tokens_parsed;
4714
4715         if (n_tokens != t0) {
4716                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4717                 return;
4718         }
4719
4720         status = pipeline_table_rule_delete(pipeline_name,
4721                 table_id,
4722                 &m);
4723         if (status) {
4724                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
4725                 return;
4726         }
4727 }
4728
4729
4730 static const char cmd_pipeline_table_rule_delete_default_help[] =
4731 "pipeline <pipeline_name> table <table_id> rule delete\n"
4732 "     match\n"
4733 "        default\n";
4734
4735 static void
4736 cmd_pipeline_table_rule_delete_default(char **tokens,
4737         uint32_t n_tokens,
4738         char *out,
4739         size_t out_size)
4740 {
4741         char *pipeline_name;
4742         uint32_t table_id;
4743         int status;
4744
4745         if (n_tokens != 8) {
4746                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
4747                 return;
4748         }
4749
4750         pipeline_name = tokens[1];
4751
4752         if (strcmp(tokens[2], "table") != 0) {
4753                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
4754                 return;
4755         }
4756
4757         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
4758                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
4759                 return;
4760         }
4761
4762         if (strcmp(tokens[4], "rule") != 0) {
4763                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
4764                 return;
4765         }
4766
4767         if (strcmp(tokens[5], "delete") != 0) {
4768                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
4769                 return;
4770         }
4771
4772         if (strcmp(tokens[6], "match") != 0) {
4773                 snprintf(out, out_size, MSG_ARG_INVALID, "match");
4774                 return;
4775         }
4776
4777         if (strcmp(tokens[7], "default") != 0) {
4778                 snprintf(out, out_size, MSG_ARG_INVALID, "default");
4779                 return;
4780         }
4781
4782         status = pipeline_table_rule_delete_default(pipeline_name,
4783                 table_id);
4784         if (status) {
4785                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
4786                 return;
4787         }
4788 }
4789
4790 static void
4791 ether_addr_show(FILE *f, struct rte_ether_addr *addr)
4792 {
4793         fprintf(f, "%02x:%02x:%02x:%02x:%02x:%02x",
4794                 (uint32_t)addr->addr_bytes[0], (uint32_t)addr->addr_bytes[1],
4795                 (uint32_t)addr->addr_bytes[2], (uint32_t)addr->addr_bytes[3],
4796                 (uint32_t)addr->addr_bytes[4], (uint32_t)addr->addr_bytes[5]);
4797 }
4798
4799 static void
4800 ipv4_addr_show(FILE *f, uint32_t addr)
4801 {
4802         fprintf(f, "%u.%u.%u.%u",
4803                 addr >> 24,
4804                 (addr >> 16) & 0xFF,
4805                 (addr >> 8) & 0xFF,
4806                 addr & 0xFF);
4807 }
4808
4809 static void
4810 ipv6_addr_show(FILE *f, uint8_t *addr)
4811 {
4812         fprintf(f, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:"
4813                 "%02x%02x:%02x%02x:%02x%02x:%02x%02x:",
4814                 (uint32_t)addr[0], (uint32_t)addr[1],
4815                 (uint32_t)addr[2], (uint32_t)addr[3],
4816                 (uint32_t)addr[4], (uint32_t)addr[5],
4817                 (uint32_t)addr[6], (uint32_t)addr[7],
4818                 (uint32_t)addr[8], (uint32_t)addr[9],
4819                 (uint32_t)addr[10], (uint32_t)addr[11],
4820                 (uint32_t)addr[12], (uint32_t)addr[13],
4821                 (uint32_t)addr[14], (uint32_t)addr[15]);
4822 }
4823
4824 static const char *
4825 policer_action_string(enum rte_table_action_policer action) {
4826         switch (action) {
4827                 case RTE_TABLE_ACTION_POLICER_COLOR_GREEN: return "G";
4828                 case RTE_TABLE_ACTION_POLICER_COLOR_YELLOW: return "Y";
4829                 case RTE_TABLE_ACTION_POLICER_COLOR_RED: return "R";
4830                 case RTE_TABLE_ACTION_POLICER_DROP: return "D";
4831                 default: return "?";
4832         }
4833 }
4834
4835 static int
4836 table_rule_show(const char *pipeline_name,
4837         uint32_t table_id,
4838         const char *file_name)
4839 {
4840         struct pipeline *p;
4841         struct table *table;
4842         struct table_rule *rule;
4843         FILE *f = NULL;
4844         uint32_t i;
4845
4846         /* Check input params. */
4847         if ((pipeline_name == NULL) ||
4848                 (file_name == NULL))
4849                 return -1;
4850
4851         p = pipeline_find(pipeline_name);
4852         if ((p == NULL) ||
4853                 (table_id >= p->n_tables))
4854                 return -1;
4855
4856         table = &p->table[table_id];
4857
4858         /* Open file. */
4859         f = fopen(file_name, "w");
4860         if (f == NULL)
4861                 return -1;
4862
4863         /* Write table rules to file. */
4864         TAILQ_FOREACH(rule, &table->rules, node) {
4865                 struct table_rule_match *m = &rule->match;
4866                 struct table_rule_action *a = &rule->action;
4867
4868                 fprintf(f, "match ");
4869                 switch (m->match_type) {
4870                 case TABLE_ACL:
4871                         fprintf(f, "acl priority %u ",
4872                                 m->match.acl.priority);
4873
4874                         fprintf(f, m->match.acl.ip_version ? "ipv4 " : "ipv6 ");
4875
4876                         if (m->match.acl.ip_version)
4877                                 ipv4_addr_show(f, m->match.acl.ipv4.sa);
4878                         else
4879                                 ipv6_addr_show(f, m->match.acl.ipv6.sa);
4880
4881                         fprintf(f, "%u",        m->match.acl.sa_depth);
4882
4883                         if (m->match.acl.ip_version)
4884                                 ipv4_addr_show(f, m->match.acl.ipv4.da);
4885                         else
4886                                 ipv6_addr_show(f, m->match.acl.ipv6.da);
4887
4888                         fprintf(f, "%u",        m->match.acl.da_depth);
4889
4890                         fprintf(f, "%u %u %u %u %u ",
4891                                 (uint32_t)m->match.acl.sp0,
4892                                 (uint32_t)m->match.acl.sp1,
4893                                 (uint32_t)m->match.acl.dp0,
4894                                 (uint32_t)m->match.acl.dp1,
4895                                 (uint32_t)m->match.acl.proto);
4896                         break;
4897
4898                 case TABLE_ARRAY:
4899                         fprintf(f, "array %u ",
4900                                 m->match.array.pos);
4901                         break;
4902
4903                 case TABLE_HASH:
4904                         fprintf(f, "hash raw ");
4905                         for (i = 0; i < table->params.match.hash.key_size; i++)
4906                                 fprintf(f, "%02x", m->match.hash.key[i]);
4907                         fprintf(f, " ");
4908                         break;
4909
4910                 case TABLE_LPM:
4911                         fprintf(f, "lpm ");
4912
4913                         fprintf(f, m->match.lpm.ip_version ? "ipv4 " : "ipv6 ");
4914
4915                         if (m->match.acl.ip_version)
4916                                 ipv4_addr_show(f, m->match.lpm.ipv4);
4917                         else
4918                                 ipv6_addr_show(f, m->match.lpm.ipv6);
4919
4920                         fprintf(f, "%u ",
4921                                 (uint32_t)m->match.lpm.depth);
4922                         break;
4923
4924                 default:
4925                         fprintf(f, "unknown ");
4926                 }
4927
4928                 fprintf(f, "action ");
4929                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) {
4930                         fprintf(f, "fwd ");
4931                         switch (a->fwd.action) {
4932                         case RTE_PIPELINE_ACTION_DROP:
4933                                 fprintf(f, "drop ");
4934                                 break;
4935
4936                         case RTE_PIPELINE_ACTION_PORT:
4937                                 fprintf(f, "port %u ", a->fwd.id);
4938                                 break;
4939
4940                         case RTE_PIPELINE_ACTION_PORT_META:
4941                                 fprintf(f, "meta ");
4942                                 break;
4943
4944                         case RTE_PIPELINE_ACTION_TABLE:
4945                         default:
4946                                 fprintf(f, "table %u ", a->fwd.id);
4947                         }
4948                 }
4949
4950                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_LB)) {
4951                         fprintf(f, "balance ");
4952                         for (i = 0; i < RTE_DIM(a->lb.out); i++)
4953                                 fprintf(f, "%u ", a->lb.out[i]);
4954                 }
4955
4956                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) {
4957                         fprintf(f, "mtr ");
4958                         for (i = 0; i < RTE_TABLE_ACTION_TC_MAX; i++)
4959                                 if (a->mtr.tc_mask & (1 << i)) {
4960                                         struct rte_table_action_mtr_tc_params *p =
4961                                                 &a->mtr.mtr[i];
4962                                         enum rte_table_action_policer ga =
4963                                                 p->policer[RTE_COLOR_GREEN];
4964                                         enum rte_table_action_policer ya =
4965                                                 p->policer[RTE_COLOR_YELLOW];
4966                                         enum rte_table_action_policer ra =
4967                                                 p->policer[RTE_COLOR_RED];
4968
4969                                         fprintf(f, "tc%u meter %u policer g %s y %s r %s ",
4970                                                 i,
4971                                                 a->mtr.mtr[i].meter_profile_id,
4972                                                 policer_action_string(ga),
4973                                                 policer_action_string(ya),
4974                                                 policer_action_string(ra));
4975                                 }
4976                 }
4977
4978                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TM))
4979                         fprintf(f, "tm subport %u pipe %u ",
4980                                 a->tm.subport_id,
4981                                 a->tm.pipe_id);
4982
4983                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) {
4984                         fprintf(f, "encap ");
4985                         switch (a->encap.type) {
4986                         case RTE_TABLE_ACTION_ENCAP_ETHER:
4987                                 fprintf(f, "ether ");
4988                                 ether_addr_show(f, &a->encap.ether.ether.da);
4989                                 fprintf(f, " ");
4990                                 ether_addr_show(f, &a->encap.ether.ether.sa);
4991                                 fprintf(f, " ");
4992                                 break;
4993
4994                         case RTE_TABLE_ACTION_ENCAP_VLAN:
4995                                 fprintf(f, "vlan ");
4996                                 ether_addr_show(f, &a->encap.vlan.ether.da);
4997                                 fprintf(f, " ");
4998                                 ether_addr_show(f, &a->encap.vlan.ether.sa);
4999                                 fprintf(f, " pcp %u dei %u vid %u ",
5000                                         a->encap.vlan.vlan.pcp,
5001                                         a->encap.vlan.vlan.dei,
5002                                         a->encap.vlan.vlan.vid);
5003                                 break;
5004
5005                         case RTE_TABLE_ACTION_ENCAP_QINQ:
5006                                 fprintf(f, "qinq ");
5007                                 ether_addr_show(f, &a->encap.qinq.ether.da);
5008                                 fprintf(f, " ");
5009                                 ether_addr_show(f, &a->encap.qinq.ether.sa);
5010                                 fprintf(f, " pcp %u dei %u vid %u pcp %u dei %u vid %u ",
5011                                         a->encap.qinq.svlan.pcp,
5012                                         a->encap.qinq.svlan.dei,
5013                                         a->encap.qinq.svlan.vid,
5014                                         a->encap.qinq.cvlan.pcp,
5015                                         a->encap.qinq.cvlan.dei,
5016                                         a->encap.qinq.cvlan.vid);
5017                                 break;
5018
5019                         case RTE_TABLE_ACTION_ENCAP_MPLS:
5020                                 fprintf(f, "mpls %s ", (a->encap.mpls.unicast) ?
5021                                         "unicast " : "multicast ");
5022                                 ether_addr_show(f, &a->encap.mpls.ether.da);
5023                                 fprintf(f, " ");
5024                                 ether_addr_show(f, &a->encap.mpls.ether.sa);
5025                                 fprintf(f, " ");
5026                                 for (i = 0; i < a->encap.mpls.mpls_count; i++) {
5027                                         struct rte_table_action_mpls_hdr *l =
5028                                                 &a->encap.mpls.mpls[i];
5029
5030                                         fprintf(f, "label%u %u %u %u ",
5031                                                 i,
5032                                                 l->label,
5033                                                 l->tc,
5034                                                 l->ttl);
5035                                 }
5036                                 break;
5037
5038                         case RTE_TABLE_ACTION_ENCAP_PPPOE:
5039                                 fprintf(f, "pppoe ");
5040                                 ether_addr_show(f, &a->encap.pppoe.ether.da);
5041                                 fprintf(f, " ");
5042                                 ether_addr_show(f, &a->encap.pppoe.ether.sa);
5043                                 fprintf(f, " %u ", a->encap.pppoe.pppoe.session_id);
5044                                 break;
5045
5046                         case RTE_TABLE_ACTION_ENCAP_VXLAN:
5047                                 fprintf(f, "vxlan ether ");
5048                                 ether_addr_show(f, &a->encap.vxlan.ether.da);
5049                                 fprintf(f, " ");
5050                                 ether_addr_show(f, &a->encap.vxlan.ether.sa);
5051                                 if (table->ap->params.encap.vxlan.vlan)
5052                                         fprintf(f, " vlan pcp %u dei %u vid %u ",
5053                                                 a->encap.vxlan.vlan.pcp,
5054                                                 a->encap.vxlan.vlan.dei,
5055                                                 a->encap.vxlan.vlan.vid);
5056                                 if (table->ap->params.encap.vxlan.ip_version) {
5057                                         fprintf(f, " ipv4 ");
5058                                         ipv4_addr_show(f, a->encap.vxlan.ipv4.sa);
5059                                         fprintf(f, " ");
5060                                         ipv4_addr_show(f, a->encap.vxlan.ipv4.da);
5061                                         fprintf(f, " %u %u ",
5062                                                 (uint32_t)a->encap.vxlan.ipv4.dscp,
5063                                                 (uint32_t)a->encap.vxlan.ipv4.ttl);
5064                                 } else {
5065                                         fprintf(f, " ipv6 ");
5066                                         ipv6_addr_show(f, a->encap.vxlan.ipv6.sa);
5067                                         fprintf(f, " ");
5068                                         ipv6_addr_show(f, a->encap.vxlan.ipv6.da);
5069                                         fprintf(f, " %u %u %u ",
5070                                                 a->encap.vxlan.ipv6.flow_label,
5071                                                 (uint32_t)a->encap.vxlan.ipv6.dscp,
5072                                                 (uint32_t)a->encap.vxlan.ipv6.hop_limit);
5073                                         fprintf(f, " udp %u %u vxlan %u ",
5074                                                 a->encap.vxlan.udp.sp,
5075                                                 a->encap.vxlan.udp.dp,
5076                                                 a->encap.vxlan.vxlan.vni);
5077                                 }
5078                                 break;
5079
5080                         default:
5081                                 fprintf(f, "unknown ");
5082                         }
5083                 }
5084
5085                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) {
5086                         fprintf(f, "nat %s ", (a->nat.ip_version) ? "ipv4 " : "ipv6 ");
5087                         if (a->nat.ip_version)
5088                                 ipv4_addr_show(f, a->nat.addr.ipv4);
5089                         else
5090                                 ipv6_addr_show(f, a->nat.addr.ipv6);
5091                         fprintf(f, " %u ", (uint32_t)(a->nat.port));
5092                 }
5093
5094                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TTL))
5095                         fprintf(f, "ttl %s ", (a->ttl.decrement) ? "dec" : "keep");
5096
5097                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_STATS))
5098                         fprintf(f, "stats ");
5099
5100                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TIME))
5101                         fprintf(f, "time ");
5102
5103                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_SYM_CRYPTO))
5104                         fprintf(f, "sym_crypto ");
5105
5106                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TAG))
5107                         fprintf(f, "tag %u ", a->tag.tag);
5108
5109                 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_DECAP))
5110                         fprintf(f, "decap %u ", a->decap.n);
5111
5112                 /* end */
5113                 fprintf(f, "\n");
5114         }
5115
5116         /* Write table default rule to file. */
5117         if (table->rule_default) {
5118                 struct table_rule_action *a = &table->rule_default->action;
5119
5120                 fprintf(f, "# match default action fwd ");
5121
5122                 switch (a->fwd.action) {
5123                 case RTE_PIPELINE_ACTION_DROP:
5124                         fprintf(f, "drop ");
5125                         break;
5126
5127                 case RTE_PIPELINE_ACTION_PORT:
5128                         fprintf(f, "port %u ", a->fwd.id);
5129                         break;
5130
5131                 case RTE_PIPELINE_ACTION_PORT_META:
5132                         fprintf(f, "meta ");
5133                         break;
5134
5135                 case RTE_PIPELINE_ACTION_TABLE:
5136                 default:
5137                         fprintf(f, "table %u ", a->fwd.id);
5138                 }
5139         } else
5140                 fprintf(f, "# match default action fwd drop ");
5141
5142         fprintf(f, "\n");
5143
5144         /* Close file. */
5145         fclose(f);
5146
5147         return 0;
5148 }
5149
5150 static const char cmd_pipeline_table_rule_show_help[] =
5151 "pipeline <pipeline_name> table <table_id> rule show\n"
5152 "     file <file_name>\n";
5153
5154 static void
5155 cmd_pipeline_table_rule_show(char **tokens,
5156         uint32_t n_tokens,
5157         char *out,
5158         size_t out_size)
5159 {
5160         char *file_name = NULL, *pipeline_name;
5161         uint32_t table_id;
5162         int status;
5163
5164         if (n_tokens != 8) {
5165                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5166                 return;
5167         }
5168
5169         pipeline_name = tokens[1];
5170
5171         if (strcmp(tokens[2], "table") != 0) {
5172                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
5173                 return;
5174         }
5175
5176         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5177                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5178                 return;
5179         }
5180
5181         if (strcmp(tokens[4], "rule") != 0) {
5182                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
5183                 return;
5184         }
5185
5186         if (strcmp(tokens[5], "show") != 0) {
5187                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "show");
5188                 return;
5189         }
5190
5191         if (strcmp(tokens[6], "file") != 0) {
5192                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "file");
5193                 return;
5194         }
5195
5196         file_name = tokens[7];
5197
5198         status = table_rule_show(pipeline_name, table_id, file_name);
5199         if (status) {
5200                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5201                 return;
5202         }
5203 }
5204
5205 static const char cmd_pipeline_table_rule_stats_read_help[] =
5206 "pipeline <pipeline_name> table <table_id> rule read stats [clear]\n"
5207 "     match <match>\n";
5208
5209 static void
5210 cmd_pipeline_table_rule_stats_read(char **tokens,
5211         uint32_t n_tokens,
5212         char *out,
5213         size_t out_size)
5214 {
5215         struct table_rule_match m;
5216         struct rte_table_action_stats_counters stats;
5217         char *pipeline_name;
5218         uint32_t table_id, n_tokens_parsed;
5219         int clear = 0, status;
5220
5221         if (n_tokens < 7) {
5222                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5223                 return;
5224         }
5225
5226         pipeline_name = tokens[1];
5227
5228         if (strcmp(tokens[2], "table") != 0) {
5229                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
5230                 return;
5231         }
5232
5233         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5234                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5235                 return;
5236         }
5237
5238         if (strcmp(tokens[4], "rule") != 0) {
5239                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
5240                 return;
5241         }
5242
5243         if (strcmp(tokens[5], "read") != 0) {
5244                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
5245                 return;
5246         }
5247
5248         if (strcmp(tokens[6], "stats") != 0) {
5249                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
5250                 return;
5251         }
5252
5253         n_tokens -= 7;
5254         tokens += 7;
5255
5256         /* clear */
5257         if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
5258                 clear = 1;
5259
5260                 n_tokens--;
5261                 tokens++;
5262         }
5263
5264         /* match */
5265         if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
5266                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
5267                 return;
5268         }
5269
5270         n_tokens_parsed = parse_match(tokens,
5271                 n_tokens,
5272                 out,
5273                 out_size,
5274                 &m);
5275         if (n_tokens_parsed == 0)
5276                 return;
5277         n_tokens -= n_tokens_parsed;
5278         tokens += n_tokens_parsed;
5279
5280         /* end */
5281         if (n_tokens) {
5282                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
5283                 return;
5284         }
5285
5286         /* Read table rule stats. */
5287         status = pipeline_table_rule_stats_read(pipeline_name,
5288                 table_id,
5289                 &m,
5290                 &stats,
5291                 clear);
5292         if (status) {
5293                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5294                 return;
5295         }
5296
5297         /* Print stats. */
5298         if (stats.n_packets_valid && stats.n_bytes_valid)
5299                 snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: %" PRIu64 "\n",
5300                         stats.n_packets,
5301                         stats.n_bytes);
5302
5303         if (stats.n_packets_valid && !stats.n_bytes_valid)
5304                 snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: N/A\n",
5305                         stats.n_packets);
5306
5307         if (!stats.n_packets_valid && stats.n_bytes_valid)
5308                 snprintf(out, out_size, "Packets: N/A; Bytes: %" PRIu64 "\n",
5309                         stats.n_bytes);
5310
5311         if (!stats.n_packets_valid && !stats.n_bytes_valid)
5312                 snprintf(out, out_size, "Packets: N/A ; Bytes: N/A\n");
5313 }
5314
5315 static const char cmd_pipeline_table_meter_profile_add_help[] =
5316 "pipeline <pipeline_name> table <table_id> meter profile <meter_profile_id>\n"
5317 "   add srtcm cir <cir> cbs <cbs> ebs <ebs>\n"
5318 "   | trtcm cir <cir> pir <pir> cbs <cbs> pbs <pbs>\n";
5319
5320 static void
5321 cmd_pipeline_table_meter_profile_add(char **tokens,
5322         uint32_t n_tokens,
5323         char *out,
5324         size_t out_size)
5325 {
5326         struct rte_table_action_meter_profile p;
5327         char *pipeline_name;
5328         uint32_t table_id, meter_profile_id;
5329         int status;
5330
5331         if (n_tokens < 9) {
5332                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5333                 return;
5334         }
5335
5336         pipeline_name = tokens[1];
5337
5338         if (strcmp(tokens[2], "table") != 0) {
5339                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
5340                 return;
5341         }
5342
5343         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5344                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5345                 return;
5346         }
5347
5348         if (strcmp(tokens[4], "meter") != 0) {
5349                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
5350                 return;
5351         }
5352
5353         if (strcmp(tokens[5], "profile") != 0) {
5354                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
5355                 return;
5356         }
5357
5358         if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) {
5359                 snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id");
5360                 return;
5361         }
5362
5363         if (strcmp(tokens[7], "add") != 0) {
5364                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add");
5365                 return;
5366         }
5367
5368         if (strcmp(tokens[8], "srtcm") == 0) {
5369                 if (n_tokens != 15) {
5370                         snprintf(out, out_size, MSG_ARG_MISMATCH,
5371                                 tokens[0]);
5372                         return;
5373                 }
5374
5375                 p.alg = RTE_TABLE_ACTION_METER_SRTCM;
5376
5377                 if (strcmp(tokens[9], "cir") != 0) {
5378                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir");
5379                         return;
5380                 }
5381
5382                 if (parser_read_uint64(&p.srtcm.cir, tokens[10]) != 0) {
5383                         snprintf(out, out_size, MSG_ARG_INVALID, "cir");
5384                         return;
5385                 }
5386
5387                 if (strcmp(tokens[11], "cbs") != 0) {
5388                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs");
5389                         return;
5390                 }
5391
5392                 if (parser_read_uint64(&p.srtcm.cbs, tokens[12]) != 0) {
5393                         snprintf(out, out_size, MSG_ARG_INVALID, "cbs");
5394                         return;
5395                 }
5396
5397                 if (strcmp(tokens[13], "ebs") != 0) {
5398                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ebs");
5399                         return;
5400                 }
5401
5402                 if (parser_read_uint64(&p.srtcm.ebs, tokens[14]) != 0) {
5403                         snprintf(out, out_size, MSG_ARG_INVALID, "ebs");
5404                         return;
5405                 }
5406         } else if (strcmp(tokens[8], "trtcm") == 0) {
5407                 if (n_tokens != 17) {
5408                         snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5409                         return;
5410                 }
5411
5412                 p.alg = RTE_TABLE_ACTION_METER_TRTCM;
5413
5414                 if (strcmp(tokens[9], "cir") != 0) {
5415                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir");
5416                         return;
5417                 }
5418
5419                 if (parser_read_uint64(&p.trtcm.cir, tokens[10]) != 0) {
5420                         snprintf(out, out_size, MSG_ARG_INVALID, "cir");
5421                         return;
5422                 }
5423
5424                 if (strcmp(tokens[11], "pir") != 0) {
5425                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pir");
5426                         return;
5427                 }
5428
5429                 if (parser_read_uint64(&p.trtcm.pir, tokens[12]) != 0) {
5430                         snprintf(out, out_size, MSG_ARG_INVALID, "pir");
5431                         return;
5432                 }
5433                 if (strcmp(tokens[13], "cbs") != 0) {
5434                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs");
5435                         return;
5436                 }
5437
5438                 if (parser_read_uint64(&p.trtcm.cbs, tokens[14]) != 0) {
5439                         snprintf(out, out_size, MSG_ARG_INVALID, "cbs");
5440                         return;
5441                 }
5442
5443                 if (strcmp(tokens[15], "pbs") != 0) {
5444                         snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pbs");
5445                         return;
5446                 }
5447
5448                 if (parser_read_uint64(&p.trtcm.pbs, tokens[16]) != 0) {
5449                         snprintf(out, out_size, MSG_ARG_INVALID, "pbs");
5450                         return;
5451                 }
5452         } else {
5453                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5454                 return;
5455         }
5456
5457         status = pipeline_table_mtr_profile_add(pipeline_name,
5458                 table_id,
5459                 meter_profile_id,
5460                 &p);
5461         if (status) {
5462                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5463                 return;
5464         }
5465 }
5466
5467
5468 static const char cmd_pipeline_table_meter_profile_delete_help[] =
5469 "pipeline <pipeline_name> table <table_id>\n"
5470 "   meter profile <meter_profile_id> delete\n";
5471
5472 static void
5473 cmd_pipeline_table_meter_profile_delete(char **tokens,
5474         uint32_t n_tokens,
5475         char *out,
5476         size_t out_size)
5477 {
5478         char *pipeline_name;
5479         uint32_t table_id, meter_profile_id;
5480         int status;
5481
5482         if (n_tokens != 8) {
5483                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5484                 return;
5485         }
5486
5487         pipeline_name = tokens[1];
5488
5489         if (strcmp(tokens[2], "table") != 0) {
5490                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
5491                 return;
5492         }
5493
5494         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5495                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5496                 return;
5497         }
5498
5499         if (strcmp(tokens[4], "meter") != 0) {
5500                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
5501                 return;
5502         }
5503
5504         if (strcmp(tokens[5], "profile") != 0) {
5505                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile");
5506                 return;
5507         }
5508
5509         if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) {
5510                 snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id");
5511                 return;
5512         }
5513
5514         if (strcmp(tokens[7], "delete") != 0) {
5515                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete");
5516                 return;
5517         }
5518
5519         status = pipeline_table_mtr_profile_delete(pipeline_name,
5520                 table_id,
5521                 meter_profile_id);
5522         if (status) {
5523                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5524                 return;
5525         }
5526 }
5527
5528
5529 static const char cmd_pipeline_table_rule_meter_read_help[] =
5530 "pipeline <pipeline_name> table <table_id> rule read meter [clear]\n"
5531 "     match <match>\n";
5532
5533 static void
5534 cmd_pipeline_table_rule_meter_read(char **tokens,
5535         uint32_t n_tokens,
5536         char *out,
5537         size_t out_size)
5538 {
5539         struct table_rule_match m;
5540         struct rte_table_action_mtr_counters stats;
5541         char *pipeline_name;
5542         uint32_t table_id, n_tokens_parsed;
5543         int clear = 0, status;
5544
5545         if (n_tokens < 7) {
5546                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5547                 return;
5548         }
5549
5550         pipeline_name = tokens[1];
5551
5552         if (strcmp(tokens[2], "table") != 0) {
5553                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
5554                 return;
5555         }
5556
5557         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5558                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5559                 return;
5560         }
5561
5562         if (strcmp(tokens[4], "rule") != 0) {
5563                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
5564                 return;
5565         }
5566
5567         if (strcmp(tokens[5], "read") != 0) {
5568                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
5569                 return;
5570         }
5571
5572         if (strcmp(tokens[6], "meter") != 0) {
5573                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter");
5574                 return;
5575         }
5576
5577         n_tokens -= 7;
5578         tokens += 7;
5579
5580         /* clear */
5581         if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
5582                 clear = 1;
5583
5584                 n_tokens--;
5585                 tokens++;
5586         }
5587
5588         /* match */
5589         if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
5590                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
5591                 return;
5592         }
5593
5594         n_tokens_parsed = parse_match(tokens,
5595                 n_tokens,
5596                 out,
5597                 out_size,
5598                 &m);
5599         if (n_tokens_parsed == 0)
5600                 return;
5601         n_tokens -= n_tokens_parsed;
5602         tokens += n_tokens_parsed;
5603
5604         /* end */
5605         if (n_tokens) {
5606                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
5607                 return;
5608         }
5609
5610         /* Read table rule meter stats. */
5611         status = pipeline_table_rule_mtr_read(pipeline_name,
5612                 table_id,
5613                 &m,
5614                 &stats,
5615                 clear);
5616         if (status) {
5617                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5618                 return;
5619         }
5620
5621         /* Print stats. */
5622 }
5623
5624
5625 static const char cmd_pipeline_table_dscp_help[] =
5626 "pipeline <pipeline_name> table <table_id> dscp <file_name>\n"
5627 "\n"
5628 " File <file_name>:\n"
5629 "   - exactly 64 lines\n"
5630 "   - line format: <tc_id> <tc_queue_id> <color>, with <color> as: g | y | r\n";
5631
5632 static int
5633 load_dscp_table(struct rte_table_action_dscp_table *dscp_table,
5634         const char *file_name,
5635         uint32_t *line_number)
5636 {
5637         FILE *f = NULL;
5638         uint32_t dscp, l;
5639
5640         /* Check input arguments */
5641         if ((dscp_table == NULL) ||
5642                 (file_name == NULL) ||
5643                 (line_number == NULL)) {
5644                 if (line_number)
5645                         *line_number = 0;
5646                 return -EINVAL;
5647         }
5648
5649         /* Open input file */
5650         f = fopen(file_name, "r");
5651         if (f == NULL) {
5652                 *line_number = 0;
5653                 return -EINVAL;
5654         }
5655
5656         /* Read file */
5657         for (dscp = 0, l = 1; ; l++) {
5658                 char line[64];
5659                 char *tokens[3];
5660                 enum rte_color color;
5661                 uint32_t tc_id, tc_queue_id, n_tokens = RTE_DIM(tokens);
5662
5663                 if (fgets(line, sizeof(line), f) == NULL)
5664                         break;
5665
5666                 if (is_comment(line))
5667                         continue;
5668
5669                 if (parse_tokenize_string(line, tokens, &n_tokens)) {
5670                         *line_number = l;
5671                         fclose(f);
5672                         return -EINVAL;
5673                 }
5674
5675                 if (n_tokens == 0)
5676                         continue;
5677
5678                 if ((dscp >= RTE_DIM(dscp_table->entry)) ||
5679                         (n_tokens != RTE_DIM(tokens)) ||
5680                         parser_read_uint32(&tc_id, tokens[0]) ||
5681                         (tc_id >= RTE_TABLE_ACTION_TC_MAX) ||
5682                         parser_read_uint32(&tc_queue_id, tokens[1]) ||
5683                         (tc_queue_id >= RTE_TABLE_ACTION_TC_QUEUE_MAX) ||
5684                         (strlen(tokens[2]) != 1)) {
5685                         *line_number = l;
5686                         fclose(f);
5687                         return -EINVAL;
5688                 }
5689
5690                 switch (tokens[2][0]) {
5691                 case 'g':
5692                 case 'G':
5693                         color = RTE_COLOR_GREEN;
5694                         break;
5695
5696                 case 'y':
5697                 case 'Y':
5698                         color = RTE_COLOR_YELLOW;
5699                         break;
5700
5701                 case 'r':
5702                 case 'R':
5703                         color = RTE_COLOR_RED;
5704                         break;
5705
5706                 default:
5707                         *line_number = l;
5708                         fclose(f);
5709                         return -EINVAL;
5710                 }
5711
5712                 dscp_table->entry[dscp].tc_id = tc_id;
5713                 dscp_table->entry[dscp].tc_queue_id = tc_queue_id;
5714                 dscp_table->entry[dscp].color = color;
5715                 dscp++;
5716         }
5717
5718         /* Close file */
5719         fclose(f);
5720         return 0;
5721 }
5722
5723 static void
5724 cmd_pipeline_table_dscp(char **tokens,
5725         uint32_t n_tokens,
5726         char *out,
5727         size_t out_size)
5728 {
5729         struct rte_table_action_dscp_table dscp_table;
5730         char *pipeline_name, *file_name;
5731         uint32_t table_id, line_number;
5732         int status;
5733
5734         if (n_tokens != 6) {
5735                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5736                 return;
5737         }
5738
5739         pipeline_name = tokens[1];
5740
5741         if (strcmp(tokens[2], "table") != 0) {
5742                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
5743                 return;
5744         }
5745
5746         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5747                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5748                 return;
5749         }
5750
5751         if (strcmp(tokens[4], "dscp") != 0) {
5752                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dscp");
5753                 return;
5754         }
5755
5756         file_name = tokens[5];
5757
5758         status = load_dscp_table(&dscp_table, file_name, &line_number);
5759         if (status) {
5760                 snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number);
5761                 return;
5762         }
5763
5764         status = pipeline_table_dscp_table_update(pipeline_name,
5765                 table_id,
5766                 UINT64_MAX,
5767                 &dscp_table);
5768         if (status) {
5769                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5770                 return;
5771         }
5772 }
5773
5774
5775 static const char cmd_pipeline_table_rule_ttl_read_help[] =
5776 "pipeline <pipeline_name> table <table_id> rule read ttl [clear]\n"
5777 "     match <match>\n";
5778
5779 static void
5780 cmd_pipeline_table_rule_ttl_read(char **tokens,
5781         uint32_t n_tokens,
5782         char *out,
5783         size_t out_size)
5784 {
5785         struct table_rule_match m;
5786         struct rte_table_action_ttl_counters stats;
5787         char *pipeline_name;
5788         uint32_t table_id, n_tokens_parsed;
5789         int clear = 0, status;
5790
5791         if (n_tokens < 7) {
5792                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5793                 return;
5794         }
5795
5796         pipeline_name = tokens[1];
5797
5798         if (strcmp(tokens[2], "table") != 0) {
5799                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
5800                 return;
5801         }
5802
5803         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5804                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5805                 return;
5806         }
5807
5808         if (strcmp(tokens[4], "rule") != 0) {
5809                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
5810                 return;
5811         }
5812
5813         if (strcmp(tokens[5], "read") != 0) {
5814                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
5815                 return;
5816         }
5817
5818         if (strcmp(tokens[6], "ttl") != 0) {
5819                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ttl");
5820                 return;
5821         }
5822
5823         n_tokens -= 7;
5824         tokens += 7;
5825
5826         /* clear */
5827         if (n_tokens && (strcmp(tokens[0], "clear") == 0)) {
5828                 clear = 1;
5829
5830                 n_tokens--;
5831                 tokens++;
5832         }
5833
5834         /* match */
5835         if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
5836                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
5837                 return;
5838         }
5839
5840         n_tokens_parsed = parse_match(tokens,
5841                 n_tokens,
5842                 out,
5843                 out_size,
5844                 &m);
5845         if (n_tokens_parsed == 0)
5846                 return;
5847         n_tokens -= n_tokens_parsed;
5848         tokens += n_tokens_parsed;
5849
5850         /* end */
5851         if (n_tokens) {
5852                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
5853                 return;
5854         }
5855
5856         /* Read table rule TTL stats. */
5857         status = pipeline_table_rule_ttl_read(pipeline_name,
5858                 table_id,
5859                 &m,
5860                 &stats,
5861                 clear);
5862         if (status) {
5863                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5864                 return;
5865         }
5866
5867         /* Print stats. */
5868         snprintf(out, out_size, "Packets: %" PRIu64 "\n",
5869                 stats.n_packets);
5870 }
5871
5872 static const char cmd_pipeline_table_rule_time_read_help[] =
5873 "pipeline <pipeline_name> table <table_id> rule read time\n"
5874 "     match <match>\n";
5875
5876 static void
5877 cmd_pipeline_table_rule_time_read(char **tokens,
5878         uint32_t n_tokens,
5879         char *out,
5880         size_t out_size)
5881 {
5882         struct table_rule_match m;
5883         char *pipeline_name;
5884         uint64_t timestamp;
5885         uint32_t table_id, n_tokens_parsed;
5886         int status;
5887
5888         if (n_tokens < 7) {
5889                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5890                 return;
5891         }
5892
5893         pipeline_name = tokens[1];
5894
5895         if (strcmp(tokens[2], "table") != 0) {
5896                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
5897                 return;
5898         }
5899
5900         if (parser_read_uint32(&table_id, tokens[3]) != 0) {
5901                 snprintf(out, out_size, MSG_ARG_INVALID, "table_id");
5902                 return;
5903         }
5904
5905         if (strcmp(tokens[4], "rule") != 0) {
5906                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule");
5907                 return;
5908         }
5909
5910         if (strcmp(tokens[5], "read") != 0) {
5911                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read");
5912                 return;
5913         }
5914
5915         if (strcmp(tokens[6], "time") != 0) {
5916                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "time");
5917                 return;
5918         }
5919
5920         n_tokens -= 7;
5921         tokens += 7;
5922
5923         /* match */
5924         if ((n_tokens == 0) || strcmp(tokens[0], "match")) {
5925                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match");
5926                 return;
5927         }
5928
5929         n_tokens_parsed = parse_match(tokens,
5930                 n_tokens,
5931                 out,
5932                 out_size,
5933                 &m);
5934         if (n_tokens_parsed == 0)
5935                 return;
5936         n_tokens -= n_tokens_parsed;
5937         tokens += n_tokens_parsed;
5938
5939         /* end */
5940         if (n_tokens) {
5941                 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
5942                 return;
5943         }
5944
5945         /* Read table rule timestamp. */
5946         status = pipeline_table_rule_time_read(pipeline_name,
5947                 table_id,
5948                 &m,
5949                 &timestamp);
5950         if (status) {
5951                 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
5952                 return;
5953         }
5954
5955         /* Print stats. */
5956         snprintf(out, out_size, "Packets: %" PRIu64 "\n", timestamp);
5957 }
5958
5959 static const char cmd_thread_pipeline_enable_help[] =
5960 "thread <thread_id> pipeline <pipeline_name> enable\n";
5961
5962 static void
5963 cmd_thread_pipeline_enable(char **tokens,
5964         uint32_t n_tokens,
5965         char *out,
5966         size_t out_size)
5967 {
5968         char *pipeline_name;
5969         uint32_t thread_id;
5970         int status;
5971
5972         if (n_tokens != 5) {
5973                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
5974                 return;
5975         }
5976
5977         if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
5978                 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
5979                 return;
5980         }
5981
5982         if (strcmp(tokens[2], "pipeline") != 0) {
5983                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
5984                 return;
5985         }
5986
5987         pipeline_name = tokens[3];
5988
5989         if (strcmp(tokens[4], "enable") != 0) {
5990                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable");
5991                 return;
5992         }
5993
5994         status = thread_pipeline_enable(thread_id, pipeline_name);
5995         if (status) {
5996                 snprintf(out, out_size, MSG_CMD_FAIL, "thread pipeline enable");
5997                 return;
5998         }
5999 }
6000
6001
6002 static const char cmd_thread_pipeline_disable_help[] =
6003 "thread <thread_id> pipeline <pipeline_name> disable\n";
6004
6005 static void
6006 cmd_thread_pipeline_disable(char **tokens,
6007         uint32_t n_tokens,
6008         char *out,
6009         size_t out_size)
6010 {
6011         char *pipeline_name;
6012         uint32_t thread_id;
6013         int status;
6014
6015         if (n_tokens != 5) {
6016                 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
6017                 return;
6018         }
6019
6020         if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
6021                 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
6022                 return;
6023         }
6024
6025         if (strcmp(tokens[2], "pipeline") != 0) {
6026                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
6027                 return;
6028         }
6029
6030         pipeline_name = tokens[3];
6031
6032         if (strcmp(tokens[4], "disable") != 0) {
6033                 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable");
6034                 return;
6035         }
6036
6037         status = thread_pipeline_disable(thread_id, pipeline_name);
6038         if (status) {
6039                 snprintf(out, out_size, MSG_CMD_FAIL,
6040                         "thread pipeline disable");
6041                 return;
6042         }
6043 }
6044
6045 static void
6046 cmd_help(char **tokens, uint32_t n_tokens, char *out, size_t out_size)
6047 {
6048         tokens++;
6049         n_tokens--;
6050
6051         if (n_tokens == 0) {
6052                 snprintf(out, out_size,
6053                         "Type 'help <command>' for details on each command.\n\n"
6054                         "List of commands:\n"
6055                         "\tmempool\n"
6056                         "\tlink\n"
6057                         "\tswq\n"
6058                         "\ttmgr subport profile\n"
6059                         "\ttmgr pipe profile\n"
6060                         "\ttmgr\n"
6061                         "\ttmgr subport\n"
6062                         "\ttmgr subport pipe\n"
6063                         "\ttap\n"
6064                         "\tkni\n"
6065                         "\tport in action profile\n"
6066                         "\ttable action profile\n"
6067                         "\tpipeline\n"
6068                         "\tpipeline port in\n"
6069                         "\tpipeline port out\n"
6070                         "\tpipeline table\n"
6071                         "\tpipeline port in table\n"
6072                         "\tpipeline port in stats\n"
6073                         "\tpipeline port in enable\n"
6074                         "\tpipeline port in disable\n"
6075                         "\tpipeline port out stats\n"
6076                         "\tpipeline table stats\n"
6077                         "\tpipeline table rule add\n"
6078                         "\tpipeline table rule add default\n"
6079                         "\tpipeline table rule add bulk\n"
6080                         "\tpipeline table rule delete\n"
6081                         "\tpipeline table rule delete default\n"
6082                         "\tpipeline table rule show\n"
6083                         "\tpipeline table rule stats read\n"
6084                         "\tpipeline table meter profile add\n"
6085                         "\tpipeline table meter profile delete\n"
6086                         "\tpipeline table rule meter read\n"
6087                         "\tpipeline table dscp\n"
6088                         "\tpipeline table rule ttl read\n"
6089                         "\tpipeline table rule time read\n"
6090                         "\tthread pipeline enable\n"
6091                         "\tthread pipeline disable\n\n");
6092                 return;
6093         }
6094
6095         if (strcmp(tokens[0], "mempool") == 0) {
6096                 snprintf(out, out_size, "\n%s\n", cmd_mempool_help);
6097                 return;
6098         }
6099
6100         if (strcmp(tokens[0], "link") == 0) {
6101                 snprintf(out, out_size, "\n%s\n", cmd_link_help);
6102                 return;
6103         }
6104
6105         if (strcmp(tokens[0], "swq") == 0) {
6106                 snprintf(out, out_size, "\n%s\n", cmd_swq_help);
6107                 return;
6108         }
6109
6110         if (strcmp(tokens[0], "tmgr") == 0) {
6111                 if (n_tokens == 1) {
6112                         snprintf(out, out_size, "\n%s\n", cmd_tmgr_help);
6113                         return;
6114                 }
6115
6116                 if ((n_tokens == 2) &&
6117                         (strcmp(tokens[1], "subport")) == 0) {
6118                         snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_help);
6119                         return;
6120                 }
6121
6122                 if ((n_tokens == 3) &&
6123                         (strcmp(tokens[1], "subport") == 0) &&
6124                         (strcmp(tokens[2], "profile") == 0)) {
6125                         snprintf(out, out_size, "\n%s\n",
6126                                 cmd_tmgr_subport_profile_help);
6127                         return;
6128                 }
6129
6130                 if ((n_tokens == 3) &&
6131                         (strcmp(tokens[1], "subport") == 0) &&
6132                         (strcmp(tokens[2], "pipe") == 0)) {
6133                         snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_pipe_help);
6134                         return;
6135                 }
6136
6137                 if ((n_tokens == 3) &&
6138                         (strcmp(tokens[1], "pipe") == 0) &&
6139                         (strcmp(tokens[2], "profile") == 0)) {
6140                         snprintf(out, out_size, "\n%s\n", cmd_tmgr_pipe_profile_help);
6141                         return;
6142                 }
6143         }
6144
6145         if (strcmp(tokens[0], "tap") == 0) {
6146                 snprintf(out, out_size, "\n%s\n", cmd_tap_help);
6147                 return;
6148         }
6149
6150         if (strcmp(tokens[0], "kni") == 0) {
6151                 snprintf(out, out_size, "\n%s\n", cmd_kni_help);
6152                 return;
6153         }
6154
6155         if (strcmp(tokens[0], "cryptodev") == 0) {
6156                 snprintf(out, out_size, "\n%s\n", cmd_cryptodev_help);
6157                 return;
6158         }
6159
6160         if ((n_tokens == 4) &&
6161                 (strcmp(tokens[0], "port") == 0) &&
6162                 (strcmp(tokens[1], "in") == 0) &&
6163                 (strcmp(tokens[2], "action") == 0) &&
6164                 (strcmp(tokens[3], "profile") == 0)) {
6165                 snprintf(out, out_size, "\n%s\n", cmd_port_in_action_profile_help);
6166                 return;
6167         }
6168
6169         if ((n_tokens == 3) &&
6170                 (strcmp(tokens[0], "table") == 0) &&
6171                 (strcmp(tokens[1], "action") == 0) &&
6172                 (strcmp(tokens[2], "profile") == 0)) {
6173                 snprintf(out, out_size, "\n%s\n", cmd_table_action_profile_help);
6174                 return;
6175         }
6176
6177         if ((strcmp(tokens[0], "pipeline") == 0) && (n_tokens == 1)) {
6178                 snprintf(out, out_size, "\n%s\n", cmd_pipeline_help);
6179                 return;
6180         }
6181
6182         if ((strcmp(tokens[0], "pipeline") == 0) &&
6183                 (strcmp(tokens[1], "port") == 0)) {
6184                 if ((n_tokens == 3) && (strcmp(tokens[2], "in")) == 0) {
6185                         snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_in_help);
6186                         return;
6187                 }
6188
6189                 if ((n_tokens == 3) && (strcmp(tokens[2], "out")) == 0) {
6190                         snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_out_help);
6191                         return;
6192                 }
6193
6194                 if ((n_tokens == 4) &&
6195                         (strcmp(tokens[2], "in") == 0) &&
6196                         (strcmp(tokens[3], "table") == 0)) {
6197                         snprintf(out, out_size, "\n%s\n",
6198                                 cmd_pipeline_port_in_table_help);
6199                         return;
6200                 }
6201
6202                 if ((n_tokens == 4) &&
6203                         (strcmp(tokens[2], "in") == 0) &&
6204                         (strcmp(tokens[3], "stats") == 0)) {
6205                         snprintf(out, out_size, "\n%s\n",
6206                                 cmd_pipeline_port_in_stats_help);
6207                         return;
6208                 }
6209
6210                 if ((n_tokens == 4) &&
6211                         (strcmp(tokens[2], "in") == 0) &&
6212                         (strcmp(tokens[3], "enable") == 0)) {
6213                         snprintf(out, out_size, "\n%s\n",
6214                                 cmd_pipeline_port_in_enable_help);
6215                         return;
6216                 }
6217
6218                 if ((n_tokens == 4) &&
6219                         (strcmp(tokens[2], "in") == 0) &&
6220                         (strcmp(tokens[3], "disable") == 0)) {
6221                         snprintf(out, out_size, "\n%s\n",
6222                                 cmd_pipeline_port_in_disable_help);
6223                         return;
6224                 }
6225
6226                 if ((n_tokens == 4) &&
6227                         (strcmp(tokens[2], "out") == 0) &&
6228                         (strcmp(tokens[3], "stats") == 0)) {
6229                         snprintf(out, out_size, "\n%s\n",
6230                                 cmd_pipeline_port_out_stats_help);
6231                         return;
6232                 }
6233         }
6234
6235         if ((strcmp(tokens[0], "pipeline") == 0) &&
6236                 (strcmp(tokens[1], "table") == 0)) {
6237                 if (n_tokens == 2) {
6238                         snprintf(out, out_size, "\n%s\n", cmd_pipeline_table_help);
6239                         return;
6240                 }
6241
6242                 if ((n_tokens == 3) && strcmp(tokens[2], "stats") == 0) {
6243                         snprintf(out, out_size, "\n%s\n",
6244                                 cmd_pipeline_table_stats_help);
6245                         return;
6246                 }
6247
6248                 if ((n_tokens == 3) && strcmp(tokens[2], "dscp") == 0) {
6249                         snprintf(out, out_size, "\n%s\n",
6250                                 cmd_pipeline_table_dscp_help);
6251                         return;
6252                 }
6253
6254                 if ((n_tokens == 4) &&
6255                         (strcmp(tokens[2], "rule") == 0) &&
6256                         (strcmp(tokens[3], "add") == 0)) {
6257                         snprintf(out, out_size, "\n%s\n",
6258                                 cmd_pipeline_table_rule_add_help);
6259                         return;
6260                 }
6261
6262                 if ((n_tokens == 5) &&
6263                         (strcmp(tokens[2], "rule") == 0) &&
6264                         (strcmp(tokens[3], "add") == 0) &&
6265                         (strcmp(tokens[4], "default") == 0)) {
6266                         snprintf(out, out_size, "\n%s\n",
6267                                 cmd_pipeline_table_rule_add_default_help);
6268                         return;
6269                 }
6270
6271                 if ((n_tokens == 5) &&
6272                         (strcmp(tokens[2], "rule") == 0) &&
6273                         (strcmp(tokens[3], "add") == 0) &&
6274                         (strcmp(tokens[4], "bulk") == 0)) {
6275                         snprintf(out, out_size, "\n%s\n",
6276                                 cmd_pipeline_table_rule_add_bulk_help);
6277                         return;
6278                 }
6279
6280                 if ((n_tokens == 4) &&
6281                         (strcmp(tokens[2], "rule") == 0) &&
6282                         (strcmp(tokens[3], "delete") == 0)) {
6283                         snprintf(out, out_size, "\n%s\n",
6284                                 cmd_pipeline_table_rule_delete_help);
6285                         return;
6286                 }
6287
6288                 if ((n_tokens == 5) &&
6289                         (strcmp(tokens[2], "rule") == 0) &&
6290                         (strcmp(tokens[3], "delete") == 0) &&
6291                         (strcmp(tokens[4], "default") == 0)) {
6292                         snprintf(out, out_size, "\n%s\n",
6293                                 cmd_pipeline_table_rule_delete_default_help);
6294                         return;
6295                 }
6296
6297                 if ((n_tokens == 4) &&
6298                         (strcmp(tokens[2], "rule") == 0) &&
6299                         (strcmp(tokens[3], "show") == 0)) {
6300                         snprintf(out, out_size, "\n%s\n",
6301                                 cmd_pipeline_table_rule_show_help);
6302                         return;
6303                 }
6304
6305                 if ((n_tokens == 5) &&
6306                         (strcmp(tokens[2], "rule") == 0) &&
6307                         (strcmp(tokens[3], "stats") == 0) &&
6308                         (strcmp(tokens[4], "read") == 0)) {
6309                         snprintf(out, out_size, "\n%s\n",
6310                                 cmd_pipeline_table_rule_stats_read_help);
6311                         return;
6312                 }
6313
6314                 if ((n_tokens == 5) &&
6315                         (strcmp(tokens[2], "meter") == 0) &&
6316                         (strcmp(tokens[3], "profile") == 0) &&
6317                         (strcmp(tokens[4], "add") == 0)) {
6318                         snprintf(out, out_size, "\n%s\n",
6319                                 cmd_pipeline_table_meter_profile_add_help);
6320                         return;
6321                 }
6322
6323                 if ((n_tokens == 5) &&
6324                         (strcmp(tokens[2], "meter") == 0) &&
6325                         (strcmp(tokens[3], "profile") == 0) &&
6326                         (strcmp(tokens[4], "delete") == 0)) {
6327                         snprintf(out, out_size, "\n%s\n",
6328                                 cmd_pipeline_table_meter_profile_delete_help);
6329                         return;
6330                 }
6331
6332                 if ((n_tokens == 5) &&
6333                         (strcmp(tokens[2], "rule") == 0) &&
6334                         (strcmp(tokens[3], "meter") == 0) &&
6335                         (strcmp(tokens[4], "read") == 0)) {
6336                         snprintf(out, out_size, "\n%s\n",
6337                                 cmd_pipeline_table_rule_meter_read_help);
6338                         return;
6339                 }
6340
6341                 if ((n_tokens == 5) &&
6342                         (strcmp(tokens[2], "rule") == 0) &&
6343                         (strcmp(tokens[3], "ttl") == 0) &&
6344                         (strcmp(tokens[4], "read") == 0)) {
6345                         snprintf(out, out_size, "\n%s\n",
6346                                 cmd_pipeline_table_rule_ttl_read_help);
6347                         return;
6348                 }
6349
6350                 if ((n_tokens == 5) &&
6351                         (strcmp(tokens[2], "rule") == 0) &&
6352                         (strcmp(tokens[3], "time") == 0) &&
6353                         (strcmp(tokens[4], "read") == 0)) {
6354                         snprintf(out, out_size, "\n%s\n",
6355                                 cmd_pipeline_table_rule_time_read_help);
6356                         return;
6357                 }
6358         }
6359
6360         if ((n_tokens == 3) &&
6361                 (strcmp(tokens[0], "thread") == 0) &&
6362                 (strcmp(tokens[1], "pipeline") == 0)) {
6363                 if (strcmp(tokens[2], "enable") == 0) {
6364                         snprintf(out, out_size, "\n%s\n",
6365                                 cmd_thread_pipeline_enable_help);
6366                         return;
6367                 }
6368
6369                 if (strcmp(tokens[2], "disable") == 0) {
6370                         snprintf(out, out_size, "\n%s\n",
6371                                 cmd_thread_pipeline_disable_help);
6372                         return;
6373                 }
6374         }
6375
6376         snprintf(out, out_size, "Invalid command\n");
6377 }
6378
6379 void
6380 cli_process(char *in, char *out, size_t out_size)
6381 {
6382         char *tokens[CMD_MAX_TOKENS];
6383         uint32_t n_tokens = RTE_DIM(tokens);
6384         int status;
6385
6386         if (is_comment(in))
6387                 return;
6388
6389         status = parse_tokenize_string(in, tokens, &n_tokens);
6390         if (status) {
6391                 snprintf(out, out_size, MSG_ARG_TOO_MANY, "");
6392                 return;
6393         }
6394
6395         if (n_tokens == 0)
6396                 return;
6397
6398         if (strcmp(tokens[0], "help") == 0) {
6399                 cmd_help(tokens, n_tokens, out, out_size);
6400                 return;
6401         }
6402
6403         if (strcmp(tokens[0], "mempool") == 0) {
6404                 cmd_mempool(tokens, n_tokens, out, out_size);
6405                 return;
6406         }
6407
6408         if (strcmp(tokens[0], "link") == 0) {
6409                 if (strcmp(tokens[1], "show") == 0) {
6410                         cmd_link_show(tokens, n_tokens, out, out_size);
6411                         return;
6412                 }
6413
6414                 cmd_link(tokens, n_tokens, out, out_size);
6415                 return;
6416         }
6417
6418         if (strcmp(tokens[0], "swq") == 0) {
6419                 cmd_swq(tokens, n_tokens, out, out_size);
6420                 return;
6421         }
6422
6423         if (strcmp(tokens[0], "tmgr") == 0) {
6424                 if ((n_tokens >= 3) &&
6425                         (strcmp(tokens[1], "subport") == 0) &&
6426                         (strcmp(tokens[2], "profile") == 0)) {
6427                         cmd_tmgr_subport_profile(tokens, n_tokens,
6428                                 out, out_size);
6429                         return;
6430                 }
6431
6432                 if ((n_tokens >= 3) &&
6433                         (strcmp(tokens[1], "pipe") == 0) &&
6434                         (strcmp(tokens[2], "profile") == 0)) {
6435                         cmd_tmgr_pipe_profile(tokens, n_tokens, out, out_size);
6436                         return;
6437                 }
6438
6439                 if ((n_tokens >= 5) &&
6440                         (strcmp(tokens[2], "subport") == 0) &&
6441                         (strcmp(tokens[4], "profile") == 0)) {
6442                         cmd_tmgr_subport(tokens, n_tokens, out, out_size);
6443                         return;
6444                 }
6445
6446                 if ((n_tokens >= 5) &&
6447                         (strcmp(tokens[2], "subport") == 0) &&
6448                         (strcmp(tokens[4], "pipe") == 0)) {
6449                         cmd_tmgr_subport_pipe(tokens, n_tokens, out, out_size);
6450                         return;
6451                 }
6452
6453                 cmd_tmgr(tokens, n_tokens, out, out_size);
6454                 return;
6455         }
6456
6457         if (strcmp(tokens[0], "tap") == 0) {
6458                 cmd_tap(tokens, n_tokens, out, out_size);
6459                 return;
6460         }
6461
6462         if (strcmp(tokens[0], "kni") == 0) {
6463                 cmd_kni(tokens, n_tokens, out, out_size);
6464                 return;
6465         }
6466
6467         if (strcmp(tokens[0], "cryptodev") == 0) {
6468                 cmd_cryptodev(tokens, n_tokens, out, out_size);
6469                 return;
6470         }
6471
6472         if (strcmp(tokens[0], "port") == 0) {
6473                 cmd_port_in_action_profile(tokens, n_tokens, out, out_size);
6474                 return;
6475         }
6476
6477         if (strcmp(tokens[0], "table") == 0) {
6478                 cmd_table_action_profile(tokens, n_tokens, out, out_size);
6479                 return;
6480         }
6481
6482         if (strcmp(tokens[0], "pipeline") == 0) {
6483                 if ((n_tokens >= 3) &&
6484                         (strcmp(tokens[2], "period") == 0)) {
6485                         cmd_pipeline(tokens, n_tokens, out, out_size);
6486                         return;
6487                 }
6488
6489                 if ((n_tokens >= 5) &&
6490                         (strcmp(tokens[2], "port") == 0) &&
6491                         (strcmp(tokens[3], "in") == 0) &&
6492                         (strcmp(tokens[4], "bsz") == 0)) {
6493                         cmd_pipeline_port_in(tokens, n_tokens, out, out_size);
6494                         return;
6495                 }
6496
6497                 if ((n_tokens >= 5) &&
6498                         (strcmp(tokens[2], "port") == 0) &&
6499                         (strcmp(tokens[3], "out") == 0) &&
6500                         (strcmp(tokens[4], "bsz") == 0)) {
6501                         cmd_pipeline_port_out(tokens, n_tokens, out, out_size);
6502                         return;
6503                 }
6504
6505                 if ((n_tokens >= 4) &&
6506                         (strcmp(tokens[2], "table") == 0) &&
6507                         (strcmp(tokens[3], "match") == 0)) {
6508                         cmd_pipeline_table(tokens, n_tokens, out, out_size);
6509                         return;
6510                 }
6511
6512                 if ((n_tokens >= 6) &&
6513                         (strcmp(tokens[2], "port") == 0) &&
6514                         (strcmp(tokens[3], "in") == 0) &&
6515                         (strcmp(tokens[5], "table") == 0)) {
6516                         cmd_pipeline_port_in_table(tokens, n_tokens,
6517                                 out, out_size);
6518                         return;
6519                 }
6520
6521                 if ((n_tokens >= 6) &&
6522                         (strcmp(tokens[2], "port") == 0) &&
6523                         (strcmp(tokens[3], "in") == 0) &&
6524                         (strcmp(tokens[5], "stats") == 0)) {
6525                         cmd_pipeline_port_in_stats(tokens, n_tokens,
6526                                 out, out_size);
6527                         return;
6528                 }
6529
6530                 if ((n_tokens >= 6) &&
6531                         (strcmp(tokens[2], "port") == 0) &&
6532                         (strcmp(tokens[3], "in") == 0) &&
6533                         (strcmp(tokens[5], "enable") == 0)) {
6534                         cmd_pipeline_port_in_enable(tokens, n_tokens,
6535                                 out, out_size);
6536                         return;
6537                 }
6538
6539                 if ((n_tokens >= 6) &&
6540                         (strcmp(tokens[2], "port") == 0) &&
6541                         (strcmp(tokens[3], "in") == 0) &&
6542                         (strcmp(tokens[5], "disable") == 0)) {
6543                         cmd_pipeline_port_in_disable(tokens, n_tokens,
6544                                 out, out_size);
6545                         return;
6546                 }
6547
6548                 if ((n_tokens >= 6) &&
6549                         (strcmp(tokens[2], "port") == 0) &&
6550                         (strcmp(tokens[3], "out") == 0) &&
6551                         (strcmp(tokens[5], "stats") == 0)) {
6552                         cmd_pipeline_port_out_stats(tokens, n_tokens,
6553                                 out, out_size);
6554                         return;
6555                 }
6556
6557                 if ((n_tokens >= 5) &&
6558                         (strcmp(tokens[2], "table") == 0) &&
6559                         (strcmp(tokens[4], "stats") == 0)) {
6560                         cmd_pipeline_table_stats(tokens, n_tokens,
6561                                 out, out_size);
6562                         return;
6563                 }
6564
6565                 if ((n_tokens >= 7) &&
6566                         (strcmp(tokens[2], "table") == 0) &&
6567                         (strcmp(tokens[4], "rule") == 0) &&
6568                         (strcmp(tokens[5], "add") == 0) &&
6569                         (strcmp(tokens[6], "match") == 0)) {
6570                         if ((n_tokens >= 8) &&
6571                                 (strcmp(tokens[7], "default") == 0)) {
6572                                 cmd_pipeline_table_rule_add_default(tokens,
6573                                         n_tokens, out, out_size);
6574                                 return;
6575                         }
6576
6577                         cmd_pipeline_table_rule_add(tokens, n_tokens,
6578                                 out, out_size);
6579                         return;
6580                 }
6581
6582                 if ((n_tokens >= 7) &&
6583                         (strcmp(tokens[2], "table") == 0) &&
6584                         (strcmp(tokens[4], "rule") == 0) &&
6585                         (strcmp(tokens[5], "add") == 0) &&
6586                         (strcmp(tokens[6], "bulk") == 0)) {
6587                         cmd_pipeline_table_rule_add_bulk(tokens,
6588                                 n_tokens, out, out_size);
6589                         return;
6590                 }
6591
6592                 if ((n_tokens >= 7) &&
6593                         (strcmp(tokens[2], "table") == 0) &&
6594                         (strcmp(tokens[4], "rule") == 0) &&
6595                         (strcmp(tokens[5], "delete") == 0) &&
6596                         (strcmp(tokens[6], "match") == 0)) {
6597                         if ((n_tokens >= 8) &&
6598                                 (strcmp(tokens[7], "default") == 0)) {
6599                                 cmd_pipeline_table_rule_delete_default(tokens,
6600                                         n_tokens, out, out_size);
6601                                 return;
6602                                 }
6603
6604                         cmd_pipeline_table_rule_delete(tokens, n_tokens,
6605                                 out, out_size);
6606                         return;
6607                 }
6608
6609                 if ((n_tokens >= 6) &&
6610                         (strcmp(tokens[2], "table") == 0) &&
6611                         (strcmp(tokens[4], "rule") == 0) &&
6612                         (strcmp(tokens[5], "show") == 0)) {
6613                         cmd_pipeline_table_rule_show(tokens, n_tokens,
6614                                 out, out_size);
6615                         return;
6616                 }
6617
6618                 if ((n_tokens >= 7) &&
6619                         (strcmp(tokens[2], "table") == 0) &&
6620                         (strcmp(tokens[4], "rule") == 0) &&
6621                         (strcmp(tokens[5], "read") == 0) &&
6622                         (strcmp(tokens[6], "stats") == 0)) {
6623                         cmd_pipeline_table_rule_stats_read(tokens, n_tokens,
6624                                 out, out_size);
6625                         return;
6626                 }
6627
6628                 if ((n_tokens >= 8) &&
6629                         (strcmp(tokens[2], "table") == 0) &&
6630                         (strcmp(tokens[4], "meter") == 0) &&
6631                         (strcmp(tokens[5], "profile") == 0) &&
6632                         (strcmp(tokens[7], "add") == 0)) {
6633                         cmd_pipeline_table_meter_profile_add(tokens, n_tokens,
6634                                 out, out_size);
6635                         return;
6636                 }
6637
6638                 if ((n_tokens >= 8) &&
6639                         (strcmp(tokens[2], "table") == 0) &&
6640                         (strcmp(tokens[4], "meter") == 0) &&
6641                         (strcmp(tokens[5], "profile") == 0) &&
6642                         (strcmp(tokens[7], "delete") == 0)) {
6643                         cmd_pipeline_table_meter_profile_delete(tokens,
6644                                 n_tokens, out, out_size);
6645                         return;
6646                 }
6647
6648                 if ((n_tokens >= 7) &&
6649                         (strcmp(tokens[2], "table") == 0) &&
6650                         (strcmp(tokens[4], "rule") == 0) &&
6651                         (strcmp(tokens[5], "read") == 0) &&
6652                         (strcmp(tokens[6], "meter") == 0)) {
6653                         cmd_pipeline_table_rule_meter_read(tokens, n_tokens,
6654                                 out, out_size);
6655                         return;
6656                 }
6657
6658                 if ((n_tokens >= 5) &&
6659                         (strcmp(tokens[2], "table") == 0) &&
6660                         (strcmp(tokens[4], "dscp") == 0)) {
6661                         cmd_pipeline_table_dscp(tokens, n_tokens,
6662                                 out, out_size);
6663                         return;
6664                 }
6665
6666                 if ((n_tokens >= 7) &&
6667                         (strcmp(tokens[2], "table") == 0) &&
6668                         (strcmp(tokens[4], "rule") == 0) &&
6669                         (strcmp(tokens[5], "read") == 0) &&
6670                         (strcmp(tokens[6], "ttl") == 0)) {
6671                         cmd_pipeline_table_rule_ttl_read(tokens, n_tokens,
6672                                 out, out_size);
6673                         return;
6674                 }
6675
6676                 if ((n_tokens >= 7) &&
6677                         (strcmp(tokens[2], "table") == 0) &&
6678                         (strcmp(tokens[4], "rule") == 0) &&
6679                         (strcmp(tokens[5], "read") == 0) &&
6680                         (strcmp(tokens[6], "time") == 0)) {
6681                         cmd_pipeline_table_rule_time_read(tokens, n_tokens,
6682                                 out, out_size);
6683                         return;
6684                 }
6685         }
6686
6687         if (strcmp(tokens[0], "thread") == 0) {
6688                 if ((n_tokens >= 5) &&
6689                         (strcmp(tokens[4], "enable") == 0)) {
6690                         cmd_thread_pipeline_enable(tokens, n_tokens,
6691                                 out, out_size);
6692                         return;
6693                 }
6694
6695                 if ((n_tokens >= 5) &&
6696                         (strcmp(tokens[4], "disable") == 0)) {
6697                         cmd_thread_pipeline_disable(tokens, n_tokens,
6698                                 out, out_size);
6699                         return;
6700                 }
6701         }
6702
6703         snprintf(out, out_size, MSG_CMD_UNKNOWN, tokens[0]);
6704 }
6705
6706 int
6707 cli_script_process(const char *file_name,
6708         size_t msg_in_len_max,
6709         size_t msg_out_len_max)
6710 {
6711         char *msg_in = NULL, *msg_out = NULL;
6712         FILE *f = NULL;
6713
6714         /* Check input arguments */
6715         if ((file_name == NULL) ||
6716                 (strlen(file_name) == 0) ||
6717                 (msg_in_len_max == 0) ||
6718                 (msg_out_len_max == 0))
6719                 return -EINVAL;
6720
6721         msg_in = malloc(msg_in_len_max + 1);
6722         msg_out = malloc(msg_out_len_max + 1);
6723         if ((msg_in == NULL) ||
6724                 (msg_out == NULL)) {
6725                 free(msg_out);
6726                 free(msg_in);
6727                 return -ENOMEM;
6728         }
6729
6730         /* Open input file */
6731         f = fopen(file_name, "r");
6732         if (f == NULL) {
6733                 free(msg_out);
6734                 free(msg_in);
6735                 return -EIO;
6736         }
6737
6738         /* Read file */
6739         for ( ; ; ) {
6740                 if (fgets(msg_in, msg_in_len_max + 1, f) == NULL)
6741                         break;
6742
6743                 printf("%s", msg_in);
6744                 msg_out[0] = 0;
6745
6746                 cli_process(msg_in,
6747                         msg_out,
6748                         msg_out_len_max);
6749
6750                 if (strlen(msg_out))
6751                         printf("%s", msg_out);
6752         }
6753
6754         /* Close file */
6755         fclose(f);
6756         free(msg_out);
6757         free(msg_in);
6758         return 0;
6759 }
6760
6761 static int
6762 cli_rule_file_process(const char *file_name,
6763         size_t line_len_max,
6764         struct table_rule_list **rule_list,
6765         uint32_t *n_rules,
6766         uint32_t *line_number,
6767         char *out,
6768         size_t out_size)
6769 {
6770         struct table_rule_list *list = NULL;
6771         char *line = NULL;
6772         FILE *f = NULL;
6773         uint32_t rule_id = 0, line_id = 0;
6774         int status = 0;
6775
6776         /* Check input arguments */
6777         if ((file_name == NULL) ||
6778                 (strlen(file_name) == 0) ||
6779                 (line_len_max == 0) ||
6780                 (rule_list == NULL) ||
6781                 (n_rules == NULL) ||
6782                 (line_number == NULL) ||
6783                 (out == NULL)) {
6784                 status = -EINVAL;
6785                 goto cli_rule_file_process_free;
6786         }
6787
6788         /* Memory allocation */
6789         list = malloc(sizeof(struct table_rule_list));
6790         if (list == NULL) {
6791                 status = -ENOMEM;
6792                 goto cli_rule_file_process_free;
6793         }
6794
6795         TAILQ_INIT(list);
6796
6797         line = malloc(line_len_max + 1);
6798         if (line == NULL) {
6799                 status = -ENOMEM;
6800                 goto cli_rule_file_process_free;
6801         }
6802
6803         /* Open file */
6804         f = fopen(file_name, "r");
6805         if (f == NULL) {
6806                 status = -EIO;
6807                 goto cli_rule_file_process_free;
6808         }
6809
6810         /* Read file */
6811         for (line_id = 1, rule_id = 0; ; line_id++) {
6812                 char *tokens[CMD_MAX_TOKENS];
6813                 struct table_rule *rule = NULL;
6814                 uint32_t n_tokens, n_tokens_parsed, t0;
6815
6816                 /* Read next line from file. */
6817                 if (fgets(line, line_len_max + 1, f) == NULL)
6818                         break;
6819
6820                 /* Comment. */
6821                 if (is_comment(line))
6822                         continue;
6823
6824                 /* Parse line. */
6825                 n_tokens = RTE_DIM(tokens);
6826                 status = parse_tokenize_string(line, tokens, &n_tokens);
6827                 if (status) {
6828                         status = -EINVAL;
6829                         goto cli_rule_file_process_free;
6830                 }
6831
6832                 /* Empty line. */
6833                 if (n_tokens == 0)
6834                         continue;
6835                 t0 = 0;
6836
6837                 /* Rule alloc and insert. */
6838                 rule = calloc(1, sizeof(struct table_rule));
6839                 if (rule == NULL) {
6840                         status = -ENOMEM;
6841                         goto cli_rule_file_process_free;
6842                 }
6843
6844                 TAILQ_INSERT_TAIL(list, rule, node);
6845
6846                 /* Rule match. */
6847                 n_tokens_parsed = parse_match(tokens + t0,
6848                         n_tokens - t0,
6849                         out,
6850                         out_size,
6851                         &rule->match);
6852                 if (n_tokens_parsed == 0) {
6853                         status = -EINVAL;
6854                         goto cli_rule_file_process_free;
6855                 }
6856                 t0 += n_tokens_parsed;
6857
6858                 /* Rule action. */
6859                 n_tokens_parsed = parse_table_action(tokens + t0,
6860                         n_tokens - t0,
6861                         out,
6862                         out_size,
6863                         &rule->action);
6864                 if (n_tokens_parsed == 0) {
6865                         status = -EINVAL;
6866                         goto cli_rule_file_process_free;
6867                 }
6868                 t0 += n_tokens_parsed;
6869
6870                 /* Line completed. */
6871                 if (t0 < n_tokens) {
6872                         status = -EINVAL;
6873                         goto cli_rule_file_process_free;
6874                 }
6875
6876                 /* Increment rule count */
6877                 rule_id++;
6878         }
6879
6880         /* Close file */
6881         fclose(f);
6882
6883         /* Memory free */
6884         free(line);
6885
6886         *rule_list = list;
6887         *n_rules = rule_id;
6888         *line_number = line_id;
6889         return 0;
6890
6891 cli_rule_file_process_free:
6892         if (rule_list != NULL)
6893                 *rule_list = NULL;
6894
6895         if (n_rules != NULL)
6896                 *n_rules = rule_id;
6897
6898         if (line_number != NULL)
6899                 *line_number = line_id;
6900
6901         if (list != NULL)
6902                 for ( ; ; ) {
6903                         struct table_rule *rule;
6904
6905                         rule = TAILQ_FIRST(list);
6906                         if (rule == NULL)
6907                                 break;
6908
6909                         TAILQ_REMOVE(list, rule, node);
6910                         free(rule);
6911                 }
6912
6913         if (f)
6914                 fclose(f);
6915         free(line);
6916         free(list);
6917
6918         return status;
6919 }