examples/ip_pipeline/pipeline/pipeline_routing.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <cmdline_parse.h>
  35 #include <cmdline_parse_num.h>
  36 #include <cmdline_parse_string.h>
  37 #include <cmdline_parse_ipaddr.h>
  38 #include <cmdline_parse_etheraddr.h>
  39
  40 #include "app.h"
  41 #include "pipeline_common_fe.h"
  42 #include "pipeline_routing.h"
  43
  44 struct app_pipeline_routing_route {
  45         struct pipeline_routing_route_key key;
  46         struct app_pipeline_routing_route_params params;
  47         void *entry_ptr;
  48
  49         TAILQ_ENTRY(app_pipeline_routing_route) node;
  50 };
  51
  52 struct app_pipeline_routing_arp_entry {
  53         struct pipeline_routing_arp_key key;
  54         struct ether_addr macaddr;
  55         void *entry_ptr;
  56
  57         TAILQ_ENTRY(app_pipeline_routing_arp_entry) node;
  58 };
  59
  60 struct pipeline_routing {
  61         /* Parameters */
  62         uint32_t n_ports_in;
  63         uint32_t n_ports_out;
  64
  65         /* Routes */
  66         TAILQ_HEAD(, app_pipeline_routing_route) routes;
  67         uint32_t n_routes;
  68
  69         uint32_t default_route_present;
  70         uint32_t default_route_port_id;
  71         void *default_route_entry_ptr;
  72
  73         /* ARP entries */
  74         TAILQ_HEAD(, app_pipeline_routing_arp_entry) arp_entries;
  75         uint32_t n_arp_entries;
  76
  77         uint32_t default_arp_entry_present;
  78         uint32_t default_arp_entry_port_id;
  79         void *default_arp_entry_ptr;
  80 };
  81
  82 static void *
  83 pipeline_routing_init(struct pipeline_params *params,
  84         __rte_unused void *arg)
  85 {
  86         struct pipeline_routing *p;
  87         uint32_t size;
  88
  89         /* Check input arguments */
  90         if ((params == NULL) ||
  91                 (params->n_ports_in == 0) ||
  92                 (params->n_ports_out == 0))
  93                 return NULL;
  94
  95         /* Memory allocation */
  96         size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct pipeline_routing));
  97         p = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
  98         if (p == NULL)
  99                 return NULL;
 100
 101         /* Initialization */
 102         p->n_ports_in = params->n_ports_in;
 103         p->n_ports_out = params->n_ports_out;
 104
 105         TAILQ_INIT(&p->routes);
 106         p->n_routes = 0;
 107
 108         TAILQ_INIT(&p->arp_entries);
 109         p->n_arp_entries = 0;
 110
 111         return p;
 112 }
 113
 114 static int
 115 app_pipeline_routing_free(void *pipeline)
 116 {
 117         struct pipeline_routing *p = pipeline;
 118
 119         /* Check input arguments */
 120         if (p == NULL)
 121                 return -1;
 122
 123         /* Free resources */
 124         while (!TAILQ_EMPTY(&p->routes)) {
 125                 struct app_pipeline_routing_route *route;
 126
 127                 route = TAILQ_FIRST(&p->routes);
 128                 TAILQ_REMOVE(&p->routes, route, node);
 129                 rte_free(route);
 130         }
 131
 132         while (!TAILQ_EMPTY(&p->arp_entries)) {
 133                 struct app_pipeline_routing_arp_entry *arp_entry;
 134
 135                 arp_entry = TAILQ_FIRST(&p->arp_entries);
 136                 TAILQ_REMOVE(&p->arp_entries, arp_entry, node);
 137                 rte_free(arp_entry);
 138         }
 139
 140         rte_free(p);
 141         return 0;
 142 }
 143
 144 static struct app_pipeline_routing_route *
 145 app_pipeline_routing_find_route(struct pipeline_routing *p,
 146                 const struct pipeline_routing_route_key *key)
 147 {
 148         struct app_pipeline_routing_route *it, *found;
 149
 150         found = NULL;
 151         TAILQ_FOREACH(it, &p->routes, node) {
 152                 if ((key->type == it->key.type) &&
 153                         (key->key.ipv4.ip == it->key.key.ipv4.ip) &&
 154                         (key->key.ipv4.depth == it->key.key.ipv4.depth)) {
 155                         found = it;
 156                         break;
 157                 }
 158         }
 159
 160         return found;
 161 }
 162
 163 static struct app_pipeline_routing_arp_entry *
 164 app_pipeline_routing_find_arp_entry(struct pipeline_routing *p,
 165                 const struct pipeline_routing_arp_key *key)
 166 {
 167         struct app_pipeline_routing_arp_entry *it, *found;
 168
 169         found = NULL;
 170         TAILQ_FOREACH(it, &p->arp_entries, node) {
 171                 if ((key->type == it->key.type) &&
 172                         (key->key.ipv4.port_id == it->key.key.ipv4.port_id) &&
 173                         (key->key.ipv4.ip == it->key.key.ipv4.ip)) {
 174                         found = it;
 175                         break;
 176                 }
 177         }
 178
 179         return found;
 180 }
 181
 182 static void
 183 print_route(const struct app_pipeline_routing_route *route)
 184 {
 185         if (route->key.type == PIPELINE_ROUTING_ROUTE_IPV4) {
 186                 const struct pipeline_routing_route_key_ipv4 *key =
 187                                 &route->key.key.ipv4;
 188
 189                 printf("IP Prefix = %" PRIu32 ".%" PRIu32
 190                         ".%" PRIu32 ".%" PRIu32 "/%" PRIu32 " => "
 191                         "(Port = %" PRIu32 ", Next Hop IP = "
 192                         "%" PRIu32 ".%" PRIu32 ".%" PRIu32 ".%" PRIu32 ")\n",
 193                         (key->ip >> 24) & 0xFF,
 194                         (key->ip >> 16) & 0xFF,
 195                         (key->ip >> 8) & 0xFF,
 196                         key->ip & 0xFF,
 197
 198                         key->depth,
 199                         route->params.port_id,
 200
 201                         (route->params.ip >> 24) & 0xFF,
 202                         (route->params.ip >> 16) & 0xFF,
 203                         (route->params.ip >> 8) & 0xFF,
 204                         route->params.ip & 0xFF);
 205         }
 206 }
 207
 208 static void
 209 print_arp_entry(const struct app_pipeline_routing_arp_entry *entry)
 210 {
 211         printf("(Port = %" PRIu32 ", IP = %" PRIu32 ".%" PRIu32
 212                 ".%" PRIu32 ".%" PRIu32 ") => "
 213                 "HWaddress = %02" PRIx32 ":%02" PRIx32 ":%02" PRIx32
 214                 ":%02" PRIx32 ":%02" PRIx32 ":%02" PRIx32 "\n",
 215                 entry->key.key.ipv4.port_id,
 216                 (entry->key.key.ipv4.ip >> 24) & 0xFF,
 217                 (entry->key.key.ipv4.ip >> 16) & 0xFF,
 218                 (entry->key.key.ipv4.ip >> 8) & 0xFF,
 219                 entry->key.key.ipv4.ip & 0xFF,
 220
 221                 entry->macaddr.addr_bytes[0],
 222                 entry->macaddr.addr_bytes[1],
 223                 entry->macaddr.addr_bytes[2],
 224                 entry->macaddr.addr_bytes[3],
 225                 entry->macaddr.addr_bytes[4],
 226                 entry->macaddr.addr_bytes[5]);
 227 }
 228
 229 static int
 230 app_pipeline_routing_route_ls(struct app_params *app, uint32_t pipeline_id)
 231 {
 232         struct pipeline_routing *p;
 233         struct app_pipeline_routing_route *it;
 234
 235         p = app_pipeline_data_fe(app, pipeline_id);
 236         if (p == NULL)
 237                 return -EINVAL;
 238
 239         TAILQ_FOREACH(it, &p->routes, node)
 240                 print_route(it);
 241
 242         if (p->default_route_present)
 243                 printf("Default route: port %" PRIu32 " (entry ptr = %p)\n",
 244                                 p->default_route_port_id,
 245                                 p->default_route_entry_ptr);
 246         else
 247                 printf("Default: DROP\n");
 248
 249         return 0;
 250 }
 251
 252 int
 253 app_pipeline_routing_add_route(struct app_params *app,
 254         uint32_t pipeline_id,
 255         struct pipeline_routing_route_key *key,
 256         struct app_pipeline_routing_route_params *route_params)
 257 {
 258         struct pipeline_routing *p;
 259
 260         struct pipeline_routing_route_add_msg_req *req;
 261         struct pipeline_routing_route_add_msg_rsp *rsp;
 262
 263         struct app_pipeline_routing_route *entry;
 264
 265         int new_entry;
 266
 267         /* Check input arguments */
 268         if ((app == NULL) ||
 269                 (key == NULL) ||
 270                 (route_params == NULL))
 271                 return -1;
 272
 273         p = app_pipeline_data_fe(app, pipeline_id);
 274         if (p == NULL)
 275                 return -1;
 276
 277         switch (key->type) {
 278         case PIPELINE_ROUTING_ROUTE_IPV4:
 279         {
 280                 uint32_t depth = key->key.ipv4.depth;
 281                 uint32_t netmask;
 282
 283                 /* key */
 284                 if ((depth == 0) || (depth > 32))
 285                         return -1;
 286
 287                 netmask = (~0) << (32 - depth);
 288                 key->key.ipv4.ip &= netmask;
 289
 290                 /* route params */
 291                 if (route_params->port_id >= p->n_ports_out)
 292                         return -1;
 293         }
 294         break;
 295
 296         default:
 297                 return -1;
 298         }
 299
 300         /* Find existing rule or allocate new rule */
 301         entry = app_pipeline_routing_find_route(p, key);
 302         new_entry = (entry == NULL);
 303         if (entry == NULL) {
 304                 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
 305
 306                 if (entry == NULL)
 307                         return -1;
 308         }
 309
 310         /* Allocate and write request */
 311         req = app_msg_alloc(app);
 312         if (req == NULL) {
 313                 if (new_entry)
 314                         rte_free(entry);
 315                 return -1;
 316         }
 317
 318         req->type = PIPELINE_MSG_REQ_CUSTOM;
 319         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD;
 320         memcpy(&req->key, key, sizeof(*key));
 321         req->flags = route_params->flags;
 322         req->port_id = route_params->port_id;
 323         req->ip = route_params->ip;
 324
 325         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 326         if (rsp == NULL) {
 327                 if (new_entry)
 328                         rte_free(entry);
 329                 return -1;
 330         }
 331
 332         /* Read response and write entry */
 333         if (rsp->status ||
 334                 (rsp->entry_ptr == NULL) ||
 335                 ((new_entry == 0) && (rsp->key_found == 0)) ||
 336                 ((new_entry == 1) && (rsp->key_found == 1))) {
 337                 app_msg_free(app, rsp);
 338                 if (new_entry)
 339                         rte_free(entry);
 340                 return -1;
 341         }
 342
 343         memcpy(&entry->key, key, sizeof(*key));
 344         memcpy(&entry->params, route_params, sizeof(*route_params));
 345         entry->entry_ptr = rsp->entry_ptr;
 346
 347         /* Commit entry */
 348         if (new_entry) {
 349                 TAILQ_INSERT_TAIL(&p->routes, entry, node);
 350                 p->n_routes++;
 351         }
 352
 353         print_route(entry);
 354
 355         /* Message buffer free */
 356         app_msg_free(app, rsp);
 357         return 0;
 358 }
 359
 360 int
 361 app_pipeline_routing_delete_route(struct app_params *app,
 362         uint32_t pipeline_id,
 363         struct pipeline_routing_route_key *key)
 364 {
 365         struct pipeline_routing *p;
 366
 367         struct pipeline_routing_route_delete_msg_req *req;
 368         struct pipeline_routing_route_delete_msg_rsp *rsp;
 369
 370         struct app_pipeline_routing_route *entry;
 371
 372         /* Check input arguments */
 373         if ((app == NULL) ||
 374                 (key == NULL))
 375                 return -1;
 376
 377         p = app_pipeline_data_fe(app, pipeline_id);
 378         if (p == NULL)
 379                 return -1;
 380
 381         switch (key->type) {
 382         case PIPELINE_ROUTING_ROUTE_IPV4:
 383         {
 384                 uint32_t depth = key->key.ipv4.depth;
 385                 uint32_t netmask;
 386
 387                 /* key */
 388                 if ((depth == 0) || (depth > 32))
 389                         return -1;
 390
 391                 netmask = (~0) << (32 - depth);
 392                 key->key.ipv4.ip &= netmask;
 393         }
 394         break;
 395
 396         default:
 397                 return -1;
 398         }
 399
 400         /* Find rule */
 401         entry = app_pipeline_routing_find_route(p, key);
 402         if (entry == NULL)
 403                 return 0;
 404
 405         /* Allocate and write request */
 406         req = app_msg_alloc(app);
 407         if (req == NULL)
 408                 return -1;
 409
 410         req->type = PIPELINE_MSG_REQ_CUSTOM;
 411         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL;
 412         memcpy(&req->key, key, sizeof(*key));
 413
 414         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 415         if (rsp == NULL)
 416                 return -1;
 417
 418         /* Read response */
 419         if (rsp->status || !rsp->key_found) {
 420                 app_msg_free(app, rsp);
 421                 return -1;
 422         }
 423
 424         /* Remove route */
 425         TAILQ_REMOVE(&p->routes, entry, node);
 426         p->n_routes--;
 427         rte_free(entry);
 428
 429         /* Free response */
 430         app_msg_free(app, rsp);
 431
 432         return 0;
 433 }
 434
 435 int
 436 app_pipeline_routing_add_default_route(struct app_params *app,
 437         uint32_t pipeline_id,
 438         uint32_t port_id)
 439 {
 440         struct pipeline_routing *p;
 441
 442         struct pipeline_routing_route_add_default_msg_req *req;
 443         struct pipeline_routing_route_add_default_msg_rsp *rsp;
 444
 445         /* Check input arguments */
 446         if (app == NULL)
 447                 return -1;
 448
 449         p = app_pipeline_data_fe(app, pipeline_id);
 450         if (p == NULL)
 451                 return -1;
 452
 453         if (port_id >= p->n_ports_out)
 454                 return -1;
 455
 456         /* Allocate and write request */
 457         req = app_msg_alloc(app);
 458         if (req == NULL)
 459                 return -1;
 460
 461         req->type = PIPELINE_MSG_REQ_CUSTOM;
 462         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD_DEFAULT;
 463         req->port_id = port_id;
 464
 465         /* Send request and wait for response */
 466         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 467         if (rsp == NULL)
 468                 return -1;
 469
 470         /* Read response and write route */
 471         if (rsp->status || (rsp->entry_ptr == NULL)) {
 472                 app_msg_free(app, rsp);
 473                 return -1;
 474         }
 475
 476         p->default_route_port_id = port_id;
 477         p->default_route_entry_ptr = rsp->entry_ptr;
 478
 479         /* Commit route */
 480         p->default_route_present = 1;
 481
 482         /* Free response */
 483         app_msg_free(app, rsp);
 484
 485         return 0;
 486 }
 487
 488 int
 489 app_pipeline_routing_delete_default_route(struct app_params *app,
 490         uint32_t pipeline_id)
 491 {
 492         struct pipeline_routing *p;
 493
 494         struct pipeline_routing_arp_delete_default_msg_req *req;
 495         struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
 496
 497         /* Check input arguments */
 498         if (app == NULL)
 499                 return -1;
 500
 501         p = app_pipeline_data_fe(app, pipeline_id);
 502         if (p == NULL)
 503                 return -1;
 504
 505         /* Allocate and write request */
 506         req = app_msg_alloc(app);
 507         if (req == NULL)
 508                 return -1;
 509
 510         req->type = PIPELINE_MSG_REQ_CUSTOM;
 511         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL_DEFAULT;
 512
 513         /* Send request and wait for response */
 514         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 515         if (rsp == NULL)
 516                 return -1;
 517
 518         /* Read response and write route */
 519         if (rsp->status) {
 520                 app_msg_free(app, rsp);
 521                 return -1;
 522         }
 523
 524         /* Commit route */
 525         p->default_route_present = 0;
 526
 527         /* Free response */
 528         app_msg_free(app, rsp);
 529
 530         return 0;
 531 }
 532
 533 static int
 534 app_pipeline_routing_arp_ls(struct app_params *app, uint32_t pipeline_id)
 535 {
 536         struct pipeline_routing *p;
 537         struct app_pipeline_routing_arp_entry *it;
 538
 539         p = app_pipeline_data_fe(app, pipeline_id);
 540         if (p == NULL)
 541                 return -EINVAL;
 542
 543         TAILQ_FOREACH(it, &p->arp_entries, node)
 544                 print_arp_entry(it);
 545
 546         if (p->default_arp_entry_present)
 547                 printf("Default entry: port %" PRIu32 " (entry ptr = %p)\n",
 548                                 p->default_arp_entry_port_id,
 549                                 p->default_arp_entry_ptr);
 550         else
 551                 printf("Default: DROP\n");
 552
 553         return 0;
 554 }
 555
 556 int
 557 app_pipeline_routing_add_arp_entry(struct app_params *app, uint32_t pipeline_id,
 558                 struct pipeline_routing_arp_key *key,
 559                 struct ether_addr *macaddr)
 560 {
 561         struct pipeline_routing *p;
 562
 563         struct pipeline_routing_arp_add_msg_req *req;
 564         struct pipeline_routing_arp_add_msg_rsp *rsp;
 565
 566         struct app_pipeline_routing_arp_entry *entry;
 567
 568         int new_entry;
 569
 570         /* Check input arguments */
 571         if ((app == NULL) ||
 572                 (key == NULL) ||
 573                 (macaddr == NULL))
 574                 return -1;
 575
 576         p = app_pipeline_data_fe(app, pipeline_id);
 577         if (p == NULL)
 578                 return -1;
 579
 580         switch (key->type) {
 581         case PIPELINE_ROUTING_ARP_IPV4:
 582         {
 583                 uint32_t port_id = key->key.ipv4.port_id;
 584
 585                 /* key */
 586                 if (port_id >= p->n_ports_out)
 587                         return -1;
 588         }
 589         break;
 590
 591         default:
 592                 return -1;
 593         }
 594
 595         /* Find existing entry or allocate new */
 596         entry = app_pipeline_routing_find_arp_entry(p, key);
 597         new_entry = (entry == NULL);
 598         if (entry == NULL) {
 599                 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
 600
 601                 if (entry == NULL)
 602                         return -1;
 603         }
 604
 605         /* Message buffer allocation */
 606         req = app_msg_alloc(app);
 607         if (req == NULL) {
 608                 if (new_entry)
 609                         rte_free(entry);
 610                 return -1;
 611         }
 612
 613         req->type = PIPELINE_MSG_REQ_CUSTOM;
 614         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD;
 615         memcpy(&req->key, key, sizeof(*key));
 616         ether_addr_copy(macaddr, &req->macaddr);
 617
 618         /* Send request and wait for response */
 619         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 620         if (rsp == NULL) {
 621                 if (new_entry)
 622                         rte_free(entry);
 623                 return -1;
 624         }
 625
 626         /* Read response and write entry */
 627         if (rsp->status ||
 628                 (rsp->entry_ptr == NULL) ||
 629                 ((new_entry == 0) && (rsp->key_found == 0)) ||
 630                 ((new_entry == 1) && (rsp->key_found == 1))) {
 631                 app_msg_free(app, rsp);
 632                 if (new_entry)
 633                         rte_free(entry);
 634                 return -1;
 635         }
 636
 637         memcpy(&entry->key, key, sizeof(*key));
 638         ether_addr_copy(macaddr, &entry->macaddr);
 639         entry->entry_ptr = rsp->entry_ptr;
 640
 641         /* Commit entry */
 642         if (new_entry) {
 643                 TAILQ_INSERT_TAIL(&p->arp_entries, entry, node);
 644                 p->n_arp_entries++;
 645         }
 646
 647         print_arp_entry(entry);
 648
 649         /* Message buffer free */
 650         app_msg_free(app, rsp);
 651         return 0;
 652 }
 653
 654 int
 655 app_pipeline_routing_delete_arp_entry(struct app_params *app,
 656         uint32_t pipeline_id,
 657         struct pipeline_routing_arp_key *key)
 658 {
 659         struct pipeline_routing *p;
 660
 661         struct pipeline_routing_arp_delete_msg_req *req;
 662         struct pipeline_routing_arp_delete_msg_rsp *rsp;
 663
 664         struct app_pipeline_routing_arp_entry *entry;
 665
 666         /* Check input arguments */
 667         if ((app == NULL) ||
 668                 (key == NULL))
 669                 return -1;
 670
 671         p = app_pipeline_data_fe(app, pipeline_id);
 672         if (p == NULL)
 673                 return -EINVAL;
 674
 675         switch (key->type) {
 676         case PIPELINE_ROUTING_ARP_IPV4:
 677         {
 678                 uint32_t port_id = key->key.ipv4.port_id;
 679
 680                 /* key */
 681                 if (port_id >= p->n_ports_out)
 682                         return -1;
 683         }
 684         break;
 685
 686         default:
 687                 return -1;
 688         }
 689
 690         /* Find rule */
 691         entry = app_pipeline_routing_find_arp_entry(p, key);
 692         if (entry == NULL)
 693                 return 0;
 694
 695         /* Allocate and write request */
 696         req = app_msg_alloc(app);
 697         if (req == NULL)
 698                 return -1;
 699
 700         req->type = PIPELINE_MSG_REQ_CUSTOM;
 701         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL;
 702         memcpy(&req->key, key, sizeof(*key));
 703
 704         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 705         if (rsp == NULL)
 706                 return -1;
 707
 708         /* Read response */
 709         if (rsp->status || !rsp->key_found) {
 710                 app_msg_free(app, rsp);
 711                 return -1;
 712         }
 713
 714         /* Remove entry */
 715         TAILQ_REMOVE(&p->arp_entries, entry, node);
 716         p->n_arp_entries--;
 717         rte_free(entry);
 718
 719         /* Free response */
 720         app_msg_free(app, rsp);
 721
 722         return 0;
 723 }
 724
 725 int
 726 app_pipeline_routing_add_default_arp_entry(struct app_params *app,
 727                 uint32_t pipeline_id,
 728                 uint32_t port_id)
 729 {
 730         struct pipeline_routing *p;
 731
 732         struct pipeline_routing_arp_add_default_msg_req *req;
 733         struct pipeline_routing_arp_add_default_msg_rsp *rsp;
 734
 735         /* Check input arguments */
 736         if (app == NULL)
 737                 return -1;
 738
 739         p = app_pipeline_data_fe(app, pipeline_id);
 740         if (p == NULL)
 741                 return -1;
 742
 743         if (port_id >= p->n_ports_out)
 744                 return -1;
 745
 746         /* Allocate and write request */
 747         req = app_msg_alloc(app);
 748         if (req == NULL)
 749                 return -1;
 750
 751         req->type = PIPELINE_MSG_REQ_CUSTOM;
 752         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD_DEFAULT;
 753         req->port_id = port_id;
 754
 755         /* Send request and wait for response */
 756         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 757         if (rsp == NULL)
 758                 return -1;
 759
 760         /* Read response and write entry */
 761         if (rsp->status || rsp->entry_ptr == NULL) {
 762                 app_msg_free(app, rsp);
 763                 return -1;
 764         }
 765
 766         p->default_arp_entry_port_id = port_id;
 767         p->default_arp_entry_ptr = rsp->entry_ptr;
 768
 769         /* Commit entry */
 770         p->default_arp_entry_present = 1;
 771
 772         /* Free response */
 773         app_msg_free(app, rsp);
 774
 775         return 0;
 776 }
 777
 778 int
 779 app_pipeline_routing_delete_default_arp_entry(struct app_params *app,
 780         uint32_t pipeline_id)
 781 {
 782         struct pipeline_routing *p;
 783
 784         struct pipeline_routing_arp_delete_default_msg_req *req;
 785         struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
 786
 787         /* Check input arguments */
 788         if (app == NULL)
 789                 return -1;
 790
 791         p = app_pipeline_data_fe(app, pipeline_id);
 792         if (p == NULL)
 793                 return -EINVAL;
 794
 795         /* Allocate and write request */
 796         req = app_msg_alloc(app);
 797         if (req == NULL)
 798                 return -ENOMEM;
 799
 800         req->type = PIPELINE_MSG_REQ_CUSTOM;
 801         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL_DEFAULT;
 802
 803         /* Send request and wait for response */
 804         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 805         if (rsp == NULL)
 806                 return -ETIMEDOUT;
 807
 808         /* Read response and write entry */
 809         if (rsp->status) {
 810                 app_msg_free(app, rsp);
 811                 return rsp->status;
 812         }
 813
 814         /* Commit entry */
 815         p->default_arp_entry_present = 0;
 816
 817         /* Free response */
 818         app_msg_free(app, rsp);
 819
 820         return 0;
 821 }
 822
 823 /*
 824  * route add
 825  */
 826
 827 struct cmd_route_add_result {
 828         cmdline_fixed_string_t p_string;
 829         uint32_t p;
 830         cmdline_fixed_string_t route_string;
 831         cmdline_fixed_string_t add_string;
 832         cmdline_ipaddr_t ip;
 833         uint32_t depth;
 834         uint32_t port;
 835         cmdline_ipaddr_t nh_ip;
 836 };
 837
 838 static void
 839 cmd_route_add_parsed(
 840         void *parsed_result,
 841         __rte_unused struct cmdline *cl,
 842         void *data)
 843 {
 844         struct cmd_route_add_result *params = parsed_result;
 845         struct app_params *app = data;
 846         struct pipeline_routing_route_key key;
 847         struct app_pipeline_routing_route_params rt_params;
 848         int status;
 849
 850         /* Create route */
 851         key.type = PIPELINE_ROUTING_ROUTE_IPV4;
 852         key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
 853         key.key.ipv4.depth = params->depth;
 854
 855         rt_params.flags = 0; /* remote route */
 856         rt_params.port_id = params->port;
 857         rt_params.ip = rte_bswap32((uint32_t) params->nh_ip.addr.ipv4.s_addr);
 858
 859         status = app_pipeline_routing_add_route(app,
 860                 params->p,
 861                 &key,
 862                 &rt_params);
 863
 864         if (status != 0) {
 865                 printf("Command failed\n");
 866                 return;
 867         }
 868 }
 869
 870 static cmdline_parse_token_string_t cmd_route_add_p_string =
 871         TOKEN_STRING_INITIALIZER(struct cmd_route_add_result, p_string,
 872         "p");
 873
 874 static cmdline_parse_token_num_t cmd_route_add_p =
 875         TOKEN_NUM_INITIALIZER(struct cmd_route_add_result, p, UINT32);
 876
 877 static cmdline_parse_token_string_t cmd_route_add_route_string =
 878         TOKEN_STRING_INITIALIZER(struct cmd_route_add_result, route_string,
 879         "route");
 880
 881 static cmdline_parse_token_string_t cmd_route_add_add_string =
 882         TOKEN_STRING_INITIALIZER(struct cmd_route_add_result, add_string,
 883         "add");
 884
 885 static cmdline_parse_token_ipaddr_t cmd_route_add_ip =
 886         TOKEN_IPV4_INITIALIZER(struct cmd_route_add_result, ip);
 887
 888 static cmdline_parse_token_num_t cmd_route_add_depth =
 889         TOKEN_NUM_INITIALIZER(struct cmd_route_add_result, depth, UINT32);
 890
 891 static cmdline_parse_token_num_t cmd_route_add_port =
 892         TOKEN_NUM_INITIALIZER(struct cmd_route_add_result, port, UINT32);
 893
 894 static cmdline_parse_token_ipaddr_t cmd_route_add_nh_ip =
 895         TOKEN_IPV4_INITIALIZER(struct cmd_route_add_result, nh_ip);
 896
 897 static cmdline_parse_inst_t cmd_route_add = {
 898         .f = cmd_route_add_parsed,
 899         .data = NULL,
 900         .help_str = "Route add",
 901         .tokens = {
 902                 (void *)&cmd_route_add_p_string,
 903                 (void *)&cmd_route_add_p,
 904                 (void *)&cmd_route_add_route_string,
 905                 (void *)&cmd_route_add_add_string,
 906                 (void *)&cmd_route_add_ip,
 907                 (void *)&cmd_route_add_depth,
 908                 (void *)&cmd_route_add_port,
 909                 (void *)&cmd_route_add_nh_ip,
 910                 NULL,
 911         },
 912 };
 913
 914 /*
 915  * route del
 916  */
 917
 918 struct cmd_route_del_result {
 919         cmdline_fixed_string_t p_string;
 920         uint32_t p;
 921         cmdline_fixed_string_t route_string;
 922         cmdline_fixed_string_t del_string;
 923         cmdline_ipaddr_t ip;
 924         uint32_t depth;
 925 };
 926
 927 static void
 928 cmd_route_del_parsed(
 929         void *parsed_result,
 930         __rte_unused struct cmdline *cl,
 931         void *data)
 932 {
 933         struct cmd_route_del_result *params = parsed_result;
 934         struct app_params *app = data;
 935         struct pipeline_routing_route_key key;
 936
 937         int status;
 938
 939         /* Create route */
 940         key.type = PIPELINE_ROUTING_ROUTE_IPV4;
 941         key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
 942         key.key.ipv4.depth = params->depth;
 943
 944         status = app_pipeline_routing_delete_route(app, params->p, &key);
 945
 946         if (status != 0) {
 947                 printf("Command failed\n");
 948                 return;
 949         }
 950 }
 951
 952 static cmdline_parse_token_string_t cmd_route_del_p_string =
 953         TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, p_string,
 954         "p");
 955
 956 static cmdline_parse_token_num_t cmd_route_del_p =
 957         TOKEN_NUM_INITIALIZER(struct cmd_route_del_result, p, UINT32);
 958
 959 static cmdline_parse_token_string_t cmd_route_del_route_string =
 960         TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, route_string,
 961         "route");
 962
 963 static cmdline_parse_token_string_t cmd_route_del_del_string =
 964         TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, del_string,
 965         "del");
 966
 967 static cmdline_parse_token_ipaddr_t cmd_route_del_ip =
 968         TOKEN_IPV4_INITIALIZER(struct cmd_route_del_result, ip);
 969
 970 static cmdline_parse_token_num_t cmd_route_del_depth =
 971         TOKEN_NUM_INITIALIZER(struct cmd_route_del_result, depth, UINT32);
 972
 973 static cmdline_parse_inst_t cmd_route_del = {
 974         .f = cmd_route_del_parsed,
 975         .data = NULL,
 976         .help_str = "Route delete",
 977         .tokens = {
 978                 (void *)&cmd_route_del_p_string,
 979                 (void *)&cmd_route_del_p,
 980                 (void *)&cmd_route_del_route_string,
 981                 (void *)&cmd_route_del_del_string,
 982                 (void *)&cmd_route_del_ip,
 983                 (void *)&cmd_route_del_depth,
 984                 NULL,
 985         },
 986 };
 987
 988 /*
 989  * route add default
 990  */
 991
 992 struct cmd_route_add_default_result {
 993         cmdline_fixed_string_t p_string;
 994         uint32_t p;
 995         cmdline_fixed_string_t route_string;
 996         cmdline_fixed_string_t add_string;
 997         cmdline_fixed_string_t default_string;
 998         uint32_t port;
 999 };
1000
1001 static void
1002 cmd_route_add_default_parsed(
1003         void *parsed_result,
1004         __attribute__((unused)) struct cmdline *cl,
1005         void *data)
1006 {
1007         struct cmd_route_add_default_result *params = parsed_result;
1008         struct app_params *app = data;
1009         int status;
1010
1011         status = app_pipeline_routing_add_default_route(app, params->p,
1012                         params->port);
1013
1014         if (status != 0) {
1015                 printf("Command failed\n");
1016                 return;
1017         }
1018 }
1019
1020 static cmdline_parse_token_string_t cmd_route_add_default_p_string =
1021         TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result, p_string,
1022         "p");
1023
1024 static cmdline_parse_token_num_t cmd_route_add_default_p =
1025         TOKEN_NUM_INITIALIZER(struct cmd_route_add_default_result, p, UINT32);
1026
1027 cmdline_parse_token_string_t cmd_route_add_default_route_string =
1028         TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1029                 route_string, "route");
1030
1031 cmdline_parse_token_string_t cmd_route_add_default_add_string =
1032         TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1033                 add_string, "add");
1034
1035 cmdline_parse_token_string_t cmd_route_add_default_default_string =
1036         TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1037         default_string, "default");
1038
1039 cmdline_parse_token_num_t cmd_route_add_default_port =
1040         TOKEN_NUM_INITIALIZER(struct cmd_route_add_default_result,
1041                 port, UINT32);
1042
1043 cmdline_parse_inst_t cmd_route_add_default = {
1044         .f = cmd_route_add_default_parsed,
1045         .data = NULL,
1046         .help_str = "Route default set",
1047         .tokens = {
1048                 (void *)&cmd_route_add_default_p_string,
1049                 (void *)&cmd_route_add_default_p,
1050                 (void *)&cmd_route_add_default_route_string,
1051                 (void *)&cmd_route_add_default_add_string,
1052                 (void *)&cmd_route_add_default_default_string,
1053                 (void *)&cmd_route_add_default_port,
1054                 NULL,
1055         },
1056 };
1057
1058 /*
1059  * route del default
1060  */
1061
1062 struct cmd_route_del_default_result {
1063         cmdline_fixed_string_t p_string;
1064         uint32_t p;
1065         cmdline_fixed_string_t route_string;
1066         cmdline_fixed_string_t del_string;
1067         cmdline_fixed_string_t default_string;
1068 };
1069
1070 static void
1071 cmd_route_del_default_parsed(
1072         void *parsed_result,
1073         __rte_unused struct cmdline *cl,
1074          void *data)
1075 {
1076         struct cmd_route_del_default_result *params = parsed_result;
1077         struct app_params *app = data;
1078         int status;
1079
1080         status = app_pipeline_routing_delete_default_route(app, params->p);
1081
1082         if (status != 0) {
1083                 printf("Command failed\n");
1084                 return;
1085         }
1086 }
1087
1088 static cmdline_parse_token_string_t cmd_route_del_default_p_string =
1089         TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result, p_string,
1090         "p");
1091
1092 static cmdline_parse_token_num_t cmd_route_del_default_p =
1093         TOKEN_NUM_INITIALIZER(struct cmd_route_del_default_result, p, UINT32);
1094
1095 static cmdline_parse_token_string_t cmd_route_del_default_route_string =
1096         TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1097                 route_string, "route");
1098
1099 static cmdline_parse_token_string_t cmd_route_del_default_del_string =
1100         TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1101                 del_string, "del");
1102
1103 static cmdline_parse_token_string_t cmd_route_del_default_default_string =
1104         TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1105         default_string, "default");
1106
1107
1108 static cmdline_parse_inst_t cmd_route_del_default = {
1109         .f = cmd_route_del_default_parsed,
1110         .data = NULL,
1111         .help_str = "Route default clear",
1112         .tokens = {
1113                 (void *)&cmd_route_del_default_p_string,
1114                 (void *)&cmd_route_del_default_p,
1115                 (void *)&cmd_route_del_default_route_string,
1116                 (void *)&cmd_route_del_default_del_string,
1117                 (void *)&cmd_route_del_default_default_string,
1118                 NULL,
1119         },
1120 };
1121
1122 /*
1123  * route ls
1124  */
1125
1126 struct cmd_route_ls_result {
1127         cmdline_fixed_string_t p_string;
1128         uint32_t p;
1129         cmdline_fixed_string_t route_string;
1130         cmdline_fixed_string_t ls_string;
1131 };
1132
1133 static void
1134 cmd_route_ls_parsed(
1135         void *parsed_result,
1136         __rte_unused struct cmdline *cl,
1137         void *data)
1138 {
1139         struct cmd_route_ls_result *params = parsed_result;
1140         struct app_params *app = data;
1141         int status;
1142
1143         status = app_pipeline_routing_route_ls(app, params->p);
1144
1145         if (status != 0) {
1146                 printf("Command failed\n");
1147                 return;
1148         }
1149 }
1150
1151 static cmdline_parse_token_string_t cmd_route_ls_p_string =
1152         TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result, p_string, "p");
1153
1154 static cmdline_parse_token_num_t cmd_route_ls_p =
1155         TOKEN_NUM_INITIALIZER(struct cmd_route_ls_result, p, UINT32);
1156
1157 static cmdline_parse_token_string_t cmd_route_ls_route_string =
1158         TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result,
1159         route_string, "route");
1160
1161 static cmdline_parse_token_string_t cmd_route_ls_ls_string =
1162         TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result, ls_string,
1163         "ls");
1164
1165 static cmdline_parse_inst_t cmd_route_ls = {
1166         .f = cmd_route_ls_parsed,
1167         .data = NULL,
1168         .help_str = "Route list",
1169         .tokens = {
1170                 (void *)&cmd_route_ls_p_string,
1171                 (void *)&cmd_route_ls_p,
1172                 (void *)&cmd_route_ls_route_string,
1173                 (void *)&cmd_route_ls_ls_string,
1174                 NULL,
1175         },
1176 };
1177
1178 /*
1179  * arp add
1180  */
1181
1182 struct cmd_arp_add_result {
1183         cmdline_fixed_string_t p_string;
1184         uint32_t p;
1185         cmdline_fixed_string_t arp_string;
1186         cmdline_fixed_string_t add_string;
1187         uint32_t port_id;
1188         cmdline_ipaddr_t ip;
1189         struct ether_addr macaddr;
1190
1191 };
1192
1193 static void
1194 cmd_arp_add_parsed(
1195         void *parsed_result,
1196         __rte_unused struct cmdline *cl,
1197         void *data)
1198 {
1199         struct cmd_arp_add_result *params = parsed_result;
1200         struct app_params *app = data;
1201
1202         struct pipeline_routing_arp_key key;
1203         int status;
1204
1205         key.type = PIPELINE_ROUTING_ARP_IPV4;
1206         key.key.ipv4.port_id = params->port_id;
1207         key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
1208
1209         status = app_pipeline_routing_add_arp_entry(app,
1210                 params->p,
1211                 &key,
1212                 &params->macaddr);
1213
1214         if (status != 0) {
1215                 printf("Command failed\n");
1216                 return;
1217         }
1218 }
1219
1220 static cmdline_parse_token_string_t cmd_arp_add_p_string =
1221         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, p_string,
1222         "p");
1223
1224 static cmdline_parse_token_num_t cmd_arp_add_p =
1225         TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, p, UINT32);
1226
1227 static cmdline_parse_token_string_t cmd_arp_add_arp_string =
1228         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, arp_string, "arp");
1229
1230 static cmdline_parse_token_string_t cmd_arp_add_add_string =
1231         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, add_string, "add");
1232
1233 static cmdline_parse_token_num_t cmd_arp_add_port_id =
1234         TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, port_id, UINT32);
1235
1236 static cmdline_parse_token_ipaddr_t cmd_arp_add_ip =
1237         TOKEN_IPV4_INITIALIZER(struct cmd_arp_add_result, ip);
1238
1239 static cmdline_parse_token_etheraddr_t cmd_arp_add_macaddr =
1240         TOKEN_ETHERADDR_INITIALIZER(struct cmd_arp_add_result, macaddr);
1241
1242 static cmdline_parse_inst_t cmd_arp_add = {
1243         .f = cmd_arp_add_parsed,
1244         .data = NULL,
1245         .help_str = "ARP add",
1246         .tokens = {
1247                 (void *)&cmd_arp_add_p_string,
1248                 (void *)&cmd_arp_add_p,
1249                 (void *)&cmd_arp_add_arp_string,
1250                 (void *)&cmd_arp_add_add_string,
1251                 (void *)&cmd_arp_add_port_id,
1252                 (void *)&cmd_arp_add_ip,
1253                 (void *)&cmd_arp_add_macaddr,
1254                 NULL,
1255         },
1256 };
1257
1258 /*
1259  * arp del
1260  */
1261
1262 struct cmd_arp_del_result {
1263         cmdline_fixed_string_t p_string;
1264         uint32_t p;
1265         cmdline_fixed_string_t arp_string;
1266         cmdline_fixed_string_t del_string;
1267         uint32_t port_id;
1268         cmdline_ipaddr_t ip;
1269 };
1270
1271 static void
1272 cmd_arp_del_parsed(
1273         void *parsed_result,
1274         __rte_unused struct cmdline *cl,
1275         void *data)
1276 {
1277         struct cmd_arp_del_result *params = parsed_result;
1278         struct app_params *app = data;
1279
1280         struct pipeline_routing_arp_key key;
1281         int status;
1282
1283         key.type = PIPELINE_ROUTING_ARP_IPV4;
1284         key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
1285         key.key.ipv4.port_id = params->port_id;
1286
1287         status = app_pipeline_routing_delete_arp_entry(app, params->p, &key);
1288
1289         if (status != 0) {
1290                 printf("Command failed\n");
1291                 return;
1292         }
1293 }
1294
1295 static cmdline_parse_token_string_t cmd_arp_del_p_string =
1296         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, p_string,
1297         "p");
1298
1299 static cmdline_parse_token_num_t cmd_arp_del_p =
1300         TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, p, UINT32);
1301
1302 static cmdline_parse_token_string_t cmd_arp_del_arp_string =
1303         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arp");
1304
1305 static cmdline_parse_token_string_t cmd_arp_del_del_string =
1306         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, del_string, "del");
1307
1308 static cmdline_parse_token_num_t cmd_arp_del_port_id =
1309         TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, port_id, UINT32);
1310
1311 static cmdline_parse_token_ipaddr_t cmd_arp_del_ip =
1312         TOKEN_IPV4_INITIALIZER(struct cmd_arp_del_result, ip);
1313
1314 static cmdline_parse_inst_t cmd_arp_del = {
1315         .f = cmd_arp_del_parsed,
1316         .data = NULL,
1317         .help_str = "ARP delete",
1318         .tokens = {
1319                 (void *)&cmd_arp_del_p_string,
1320                 (void *)&cmd_arp_del_p,
1321                 (void *)&cmd_arp_del_arp_string,
1322                 (void *)&cmd_arp_del_del_string,
1323                 (void *)&cmd_arp_del_port_id,
1324                 (void *)&cmd_arp_del_ip,
1325                 NULL,
1326         },
1327 };
1328
1329 /*
1330  * arp add default
1331  */
1332
1333 struct cmd_arp_add_default_result {
1334         cmdline_fixed_string_t p_string;
1335         uint32_t p;
1336         cmdline_fixed_string_t arp_string;
1337         cmdline_fixed_string_t add_string;
1338         cmdline_fixed_string_t default_string;
1339         uint32_t port_id;
1340 };
1341
1342 static void
1343 cmd_arp_add_default_parsed(
1344         void *parsed_result,
1345         __rte_unused struct cmdline *cl,
1346         void *data)
1347 {
1348         struct cmd_arp_add_default_result *params = parsed_result;
1349         struct app_params *app = data;
1350
1351         int status;
1352
1353         status = app_pipeline_routing_add_default_arp_entry(app,
1354                 params->p,
1355                 params->port_id);
1356
1357         if (status != 0) {
1358                 printf("Command failed\n");
1359                 return;
1360         }
1361 }
1362
1363 static cmdline_parse_token_string_t cmd_arp_add_default_p_string =
1364         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, p_string,
1365         "p");
1366
1367 static cmdline_parse_token_num_t cmd_arp_add_default_p =
1368         TOKEN_NUM_INITIALIZER(struct cmd_arp_add_default_result, p, UINT32);
1369
1370 static cmdline_parse_token_string_t cmd_arp_add_default_arp_string =
1371         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, arp_string,
1372         "arp");
1373
1374 static cmdline_parse_token_string_t cmd_arp_add_default_add_string =
1375         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, add_string,
1376         "add");
1377
1378 static cmdline_parse_token_string_t cmd_arp_add_default_default_string =
1379         TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result,
1380                 default_string, "default");
1381
1382 static cmdline_parse_token_num_t cmd_arp_add_default_port_id =
1383         TOKEN_NUM_INITIALIZER(struct cmd_arp_add_default_result, port_id,
1384         UINT32);
1385
1386 static cmdline_parse_inst_t cmd_arp_add_default = {
1387         .f = cmd_arp_add_default_parsed,
1388         .data = NULL,
1389         .help_str = "ARP add default",
1390         .tokens = {
1391                 (void *)&cmd_arp_add_default_p_string,
1392                 (void *)&cmd_arp_add_default_p,
1393                 (void *)&cmd_arp_add_default_arp_string,
1394                 (void *)&cmd_arp_add_default_add_string,
1395                 (void *)&cmd_arp_add_default_default_string,
1396                 (void *)&cmd_arp_add_default_port_id,
1397                 NULL,
1398         },
1399 };
1400
1401 /*
1402  * arp del default
1403  */
1404
1405 struct cmd_arp_del_default_result {
1406         cmdline_fixed_string_t p_string;
1407         uint32_t p;
1408         cmdline_fixed_string_t arp_string;
1409         cmdline_fixed_string_t del_string;
1410         cmdline_fixed_string_t default_string;
1411 };
1412
1413 static void
1414 cmd_arp_del_default_parsed(
1415         void *parsed_result,
1416         __rte_unused struct cmdline *cl,
1417         void *data)
1418 {
1419         struct cmd_arp_del_default_result *params = parsed_result;
1420         struct app_params *app = data;
1421
1422         int status;
1423
1424         status = app_pipeline_routing_delete_default_arp_entry(app, params->p);
1425
1426         if (status != 0) {
1427                 printf("Command failed\n");
1428                 return;
1429         }
1430 }
1431
1432 static cmdline_parse_token_string_t cmd_arp_del_default_p_string =
1433         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, p_string,
1434         "p");
1435
1436 static cmdline_parse_token_num_t cmd_arp_del_default_p =
1437         TOKEN_NUM_INITIALIZER(struct cmd_arp_del_default_result, p, UINT32);
1438
1439 static cmdline_parse_token_string_t cmd_arp_del_default_arp_string =
1440         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, arp_string,
1441         "arp");
1442
1443 static cmdline_parse_token_string_t cmd_arp_del_default_del_string =
1444         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, del_string,
1445         "del");
1446
1447 static cmdline_parse_token_string_t cmd_arp_del_default_default_string =
1448         TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result,
1449                 default_string, "default");
1450
1451 static cmdline_parse_inst_t cmd_arp_del_default = {
1452         .f = cmd_arp_del_default_parsed,
1453         .data = NULL,
1454         .help_str = "ARP delete default",
1455         .tokens = {
1456                 (void *)&cmd_arp_del_default_p_string,
1457                 (void *)&cmd_arp_del_default_p,
1458                 (void *)&cmd_arp_del_default_arp_string,
1459                 (void *)&cmd_arp_del_default_del_string,
1460                 (void *)&cmd_arp_del_default_default_string,
1461                 NULL,
1462         },
1463 };
1464
1465 /*
1466  * arp ls
1467  */
1468
1469 struct cmd_arp_ls_result {
1470         cmdline_fixed_string_t p_string;
1471         uint32_t p;
1472         cmdline_fixed_string_t arp_string;
1473         cmdline_fixed_string_t ls_string;
1474 };
1475
1476 static void
1477 cmd_arp_ls_parsed(
1478         void *parsed_result,
1479         __rte_unused struct cmdline *cl,
1480         void *data)
1481 {
1482         struct cmd_arp_ls_result *params = parsed_result;
1483         struct app_params *app = data;
1484         struct pipeline_routing *p;
1485
1486         p = app_pipeline_data_fe(app, params->p);
1487         if (p == NULL)
1488                 return;
1489
1490         app_pipeline_routing_arp_ls(app, params->p);
1491 }
1492
1493 static cmdline_parse_token_string_t cmd_arp_ls_p_string =
1494         TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, p_string,
1495         "p");
1496
1497 static cmdline_parse_token_num_t cmd_arp_ls_p =
1498         TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, p, UINT32);
1499
1500 static cmdline_parse_token_string_t cmd_arp_ls_arp_string =
1501         TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
1502         "arp");
1503
1504 static cmdline_parse_token_string_t cmd_arp_ls_ls_string =
1505         TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, ls_string,
1506         "ls");
1507
1508 static cmdline_parse_inst_t cmd_arp_ls = {
1509         .f = cmd_arp_ls_parsed,
1510         .data = NULL,
1511         .help_str = "ARP list",
1512         .tokens = {
1513                 (void *)&cmd_arp_ls_p_string,
1514                 (void *)&cmd_arp_ls_p,
1515                 (void *)&cmd_arp_ls_arp_string,
1516                 (void *)&cmd_arp_ls_ls_string,
1517                 NULL,
1518         },
1519 };
1520
1521 static cmdline_parse_ctx_t pipeline_cmds[] = {
1522         (cmdline_parse_inst_t *)&cmd_route_add,
1523         (cmdline_parse_inst_t *)&cmd_route_del,
1524         (cmdline_parse_inst_t *)&cmd_route_add_default,
1525         (cmdline_parse_inst_t *)&cmd_route_del_default,
1526         (cmdline_parse_inst_t *)&cmd_route_ls,
1527         (cmdline_parse_inst_t *)&cmd_arp_add,
1528         (cmdline_parse_inst_t *)&cmd_arp_del,
1529         (cmdline_parse_inst_t *)&cmd_arp_add_default,
1530         (cmdline_parse_inst_t *)&cmd_arp_del_default,
1531         (cmdline_parse_inst_t *)&cmd_arp_ls,
1532         NULL,
1533 };
1534
1535 static struct pipeline_fe_ops pipeline_routing_fe_ops = {
1536         .f_init = pipeline_routing_init,
1537         .f_free = app_pipeline_routing_free,
1538         .cmds = pipeline_cmds,
1539 };
1540
1541 struct pipeline_type pipeline_routing = {
1542         .name = "ROUTING",
1543         .be_ops = &pipeline_routing_be_ops,
1544         .fe_ops = &pipeline_routing_fe_ops,
1545 };