examples/ip_pipeline/pipeline/pipeline_routing.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2016 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
  38 #include "app.h"
  39 #include "pipeline_common_fe.h"
  40 #include "pipeline_routing.h"
  41 #include "parser.h"
  42
  43 struct app_pipeline_routing_route {
  44         struct pipeline_routing_route_key key;
  45         struct pipeline_routing_route_data data;
  46         void *entry_ptr;
  47
  48         TAILQ_ENTRY(app_pipeline_routing_route) node;
  49 };
  50
  51 struct app_pipeline_routing_arp_entry {
  52         struct pipeline_routing_arp_key key;
  53         struct ether_addr macaddr;
  54         void *entry_ptr;
  55
  56         TAILQ_ENTRY(app_pipeline_routing_arp_entry) node;
  57 };
  58
  59 struct pipeline_routing {
  60         /* Parameters */
  61         struct app_params *app;
  62         uint32_t pipeline_id;
  63         uint32_t n_ports_in;
  64         uint32_t n_ports_out;
  65         struct pipeline_routing_params rp;
  66
  67         /* Routes */
  68         TAILQ_HEAD(, app_pipeline_routing_route) routes;
  69         uint32_t n_routes;
  70
  71         uint32_t default_route_present;
  72         uint32_t default_route_port_id;
  73         void *default_route_entry_ptr;
  74
  75         /* ARP entries */
  76         TAILQ_HEAD(, app_pipeline_routing_arp_entry) arp_entries;
  77         uint32_t n_arp_entries;
  78
  79         uint32_t default_arp_entry_present;
  80         uint32_t default_arp_entry_port_id;
  81         void *default_arp_entry_ptr;
  82 };
  83
  84 static void *
  85 app_pipeline_routing_init(struct pipeline_params *params,
  86         void *arg)
  87 {
  88         struct app_params *app = (struct app_params *) arg;
  89         struct pipeline_routing *p;
  90         uint32_t pipeline_id, size;
  91         int status;
  92
  93         /* Check input arguments */
  94         if ((params == NULL) ||
  95                 (params->n_ports_in == 0) ||
  96                 (params->n_ports_out == 0))
  97                 return NULL;
  98
  99         APP_PARAM_GET_ID(params, "PIPELINE", pipeline_id);
 100
 101         /* Memory allocation */
 102         size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct pipeline_routing));
 103         p = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
 104         if (p == NULL)
 105                 return NULL;
 106
 107         /* Initialization */
 108         p->app = app;
 109         p->pipeline_id = pipeline_id;
 110         p->n_ports_in = params->n_ports_in;
 111         p->n_ports_out = params->n_ports_out;
 112
 113         status = pipeline_routing_parse_args(&p->rp, params);
 114         if (status) {
 115                 rte_free(p);
 116                 return NULL;
 117         }
 118         TAILQ_INIT(&p->routes);
 119         p->n_routes = 0;
 120
 121         TAILQ_INIT(&p->arp_entries);
 122         p->n_arp_entries = 0;
 123
 124         return p;
 125 }
 126
 127 static int
 128 app_pipeline_routing_post_init(void *pipeline)
 129 {
 130         struct pipeline_routing *p = pipeline;
 131
 132         /* Check input arguments */
 133         if (p == NULL)
 134                 return -1;
 135
 136         return app_pipeline_routing_set_macaddr(p->app, p->pipeline_id);
 137 }
 138
 139 static int
 140 app_pipeline_routing_free(void *pipeline)
 141 {
 142         struct pipeline_routing *p = pipeline;
 143
 144         /* Check input arguments */
 145         if (p == NULL)
 146                 return -1;
 147
 148         /* Free resources */
 149         while (!TAILQ_EMPTY(&p->routes)) {
 150                 struct app_pipeline_routing_route *route;
 151
 152                 route = TAILQ_FIRST(&p->routes);
 153                 TAILQ_REMOVE(&p->routes, route, node);
 154                 rte_free(route);
 155         }
 156
 157         while (!TAILQ_EMPTY(&p->arp_entries)) {
 158                 struct app_pipeline_routing_arp_entry *arp_entry;
 159
 160                 arp_entry = TAILQ_FIRST(&p->arp_entries);
 161                 TAILQ_REMOVE(&p->arp_entries, arp_entry, node);
 162                 rte_free(arp_entry);
 163         }
 164
 165         rte_free(p);
 166         return 0;
 167 }
 168
 169 static struct app_pipeline_routing_route *
 170 app_pipeline_routing_find_route(struct pipeline_routing *p,
 171                 const struct pipeline_routing_route_key *key)
 172 {
 173         struct app_pipeline_routing_route *it, *found;
 174
 175         found = NULL;
 176         TAILQ_FOREACH(it, &p->routes, node) {
 177                 if ((key->type == it->key.type) &&
 178                         (key->key.ipv4.ip == it->key.key.ipv4.ip) &&
 179                         (key->key.ipv4.depth == it->key.key.ipv4.depth)) {
 180                         found = it;
 181                         break;
 182                 }
 183         }
 184
 185         return found;
 186 }
 187
 188 static struct app_pipeline_routing_arp_entry *
 189 app_pipeline_routing_find_arp_entry(struct pipeline_routing *p,
 190                 const struct pipeline_routing_arp_key *key)
 191 {
 192         struct app_pipeline_routing_arp_entry *it, *found;
 193
 194         found = NULL;
 195         TAILQ_FOREACH(it, &p->arp_entries, node) {
 196                 if ((key->type == it->key.type) &&
 197                         (key->key.ipv4.port_id == it->key.key.ipv4.port_id) &&
 198                         (key->key.ipv4.ip == it->key.key.ipv4.ip)) {
 199                         found = it;
 200                         break;
 201                 }
 202         }
 203
 204         return found;
 205 }
 206
 207 static void
 208 print_route(const struct app_pipeline_routing_route *route)
 209 {
 210         if (route->key.type == PIPELINE_ROUTING_ROUTE_IPV4) {
 211                 const struct pipeline_routing_route_key_ipv4 *key =
 212                                 &route->key.key.ipv4;
 213
 214                 printf("IP Prefix = %" PRIu32 ".%" PRIu32
 215                         ".%" PRIu32 ".%" PRIu32 "/%" PRIu32
 216                         " => (Port = %" PRIu32,
 217
 218                         (key->ip >> 24) & 0xFF,
 219                         (key->ip >> 16) & 0xFF,
 220                         (key->ip >> 8) & 0xFF,
 221                         key->ip & 0xFF,
 222
 223                         key->depth,
 224                         route->data.port_id);
 225
 226                 if (route->data.flags & PIPELINE_ROUTING_ROUTE_ARP)
 227                         printf(
 228                                 ", Next Hop IP = %" PRIu32 ".%" PRIu32
 229                                 ".%" PRIu32 ".%" PRIu32,
 230
 231                                 (route->data.ethernet.ip >> 24) & 0xFF,
 232                                 (route->data.ethernet.ip >> 16) & 0xFF,
 233                                 (route->data.ethernet.ip >> 8) & 0xFF,
 234                                 route->data.ethernet.ip & 0xFF);
 235                 else
 236                         printf(
 237                                 ", Next Hop HWaddress = %02" PRIx32
 238                                 ":%02" PRIx32 ":%02" PRIx32
 239                                 ":%02" PRIx32 ":%02" PRIx32
 240                                 ":%02" PRIx32,
 241
 242                                 route->data.ethernet.macaddr.addr_bytes[0],
 243                                 route->data.ethernet.macaddr.addr_bytes[1],
 244                                 route->data.ethernet.macaddr.addr_bytes[2],
 245                                 route->data.ethernet.macaddr.addr_bytes[3],
 246                                 route->data.ethernet.macaddr.addr_bytes[4],
 247                                 route->data.ethernet.macaddr.addr_bytes[5]);
 248
 249                 if (route->data.flags & PIPELINE_ROUTING_ROUTE_QINQ)
 250                         printf(", QinQ SVLAN = %" PRIu32 " CVLAN = %" PRIu32,
 251                                 route->data.l2.qinq.svlan,
 252                                 route->data.l2.qinq.cvlan);
 253
 254                 if (route->data.flags & PIPELINE_ROUTING_ROUTE_MPLS) {
 255                         uint32_t i;
 256
 257                         printf(", MPLS labels");
 258                         for (i = 0; i < route->data.l2.mpls.n_labels; i++)
 259                                 printf(" %" PRIu32,
 260                                         route->data.l2.mpls.labels[i]);
 261                 }
 262
 263                 printf(")\n");
 264         }
 265 }
 266
 267 static void
 268 print_arp_entry(const struct app_pipeline_routing_arp_entry *entry)
 269 {
 270         printf("(Port = %" PRIu32 ", IP = %" PRIu32 ".%" PRIu32
 271                 ".%" PRIu32 ".%" PRIu32
 272                 ") => HWaddress = %02" PRIx32 ":%02" PRIx32 ":%02" PRIx32
 273                 ":%02" PRIx32 ":%02" PRIx32 ":%02" PRIx32 "\n",
 274
 275                 entry->key.key.ipv4.port_id,
 276                 (entry->key.key.ipv4.ip >> 24) & 0xFF,
 277                 (entry->key.key.ipv4.ip >> 16) & 0xFF,
 278                 (entry->key.key.ipv4.ip >> 8) & 0xFF,
 279                 entry->key.key.ipv4.ip & 0xFF,
 280
 281                 entry->macaddr.addr_bytes[0],
 282                 entry->macaddr.addr_bytes[1],
 283                 entry->macaddr.addr_bytes[2],
 284                 entry->macaddr.addr_bytes[3],
 285                 entry->macaddr.addr_bytes[4],
 286                 entry->macaddr.addr_bytes[5]);
 287 }
 288
 289 static int
 290 app_pipeline_routing_route_ls(struct app_params *app, uint32_t pipeline_id)
 291 {
 292         struct pipeline_routing *p;
 293         struct app_pipeline_routing_route *it;
 294
 295         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 296         if (p == NULL)
 297                 return -EINVAL;
 298
 299         TAILQ_FOREACH(it, &p->routes, node)
 300                 print_route(it);
 301
 302         if (p->default_route_present)
 303                 printf("Default route: port %" PRIu32 " (entry ptr = %p)\n",
 304                                 p->default_route_port_id,
 305                                 p->default_route_entry_ptr);
 306         else
 307                 printf("Default: DROP\n");
 308
 309         return 0;
 310 }
 311
 312 int
 313 app_pipeline_routing_add_route(struct app_params *app,
 314         uint32_t pipeline_id,
 315         struct pipeline_routing_route_key *key,
 316         struct pipeline_routing_route_data *data)
 317 {
 318         struct pipeline_routing *p;
 319
 320         struct pipeline_routing_route_add_msg_req *req;
 321         struct pipeline_routing_route_add_msg_rsp *rsp;
 322
 323         struct app_pipeline_routing_route *entry;
 324
 325         int new_entry;
 326
 327         /* Check input arguments */
 328         if ((app == NULL) ||
 329                 (key == NULL) ||
 330                 (data == NULL))
 331                 return -1;
 332
 333         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 334         if (p == NULL)
 335                 return -1;
 336
 337         switch (key->type) {
 338         case PIPELINE_ROUTING_ROUTE_IPV4:
 339         {
 340                 uint32_t depth = key->key.ipv4.depth;
 341                 uint32_t netmask;
 342
 343                 /* key */
 344                 if ((depth == 0) || (depth > 32))
 345                         return -1;
 346
 347                 netmask = (~0U) << (32 - depth);
 348                 key->key.ipv4.ip &= netmask;
 349
 350                 /* data */
 351                 if (data->port_id >= p->n_ports_out)
 352                         return -1;
 353         }
 354         break;
 355
 356         default:
 357                 return -1;
 358         }
 359
 360         /* Find existing rule or allocate new rule */
 361         entry = app_pipeline_routing_find_route(p, key);
 362         new_entry = (entry == NULL);
 363         if (entry == NULL) {
 364                 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
 365
 366                 if (entry == NULL)
 367                         return -1;
 368         }
 369
 370         /* Allocate and write request */
 371         req = app_msg_alloc(app);
 372         if (req == NULL) {
 373                 if (new_entry)
 374                         rte_free(entry);
 375                 return -1;
 376         }
 377
 378         req->type = PIPELINE_MSG_REQ_CUSTOM;
 379         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD;
 380         memcpy(&req->key, key, sizeof(*key));
 381         memcpy(&req->data, data, sizeof(*data));
 382
 383         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 384         if (rsp == NULL) {
 385                 if (new_entry)
 386                         rte_free(entry);
 387                 return -1;
 388         }
 389
 390         /* Read response and write entry */
 391         if (rsp->status ||
 392                 (rsp->entry_ptr == NULL) ||
 393                 ((new_entry == 0) && (rsp->key_found == 0)) ||
 394                 ((new_entry == 1) && (rsp->key_found == 1))) {
 395                 app_msg_free(app, rsp);
 396                 if (new_entry)
 397                         rte_free(entry);
 398                 return -1;
 399         }
 400
 401         memcpy(&entry->key, key, sizeof(*key));
 402         memcpy(&entry->data, data, sizeof(*data));
 403         entry->entry_ptr = rsp->entry_ptr;
 404
 405         /* Commit entry */
 406         if (new_entry) {
 407                 TAILQ_INSERT_TAIL(&p->routes, entry, node);
 408                 p->n_routes++;
 409         }
 410
 411         /* Message buffer free */
 412         app_msg_free(app, rsp);
 413         return 0;
 414 }
 415
 416 int
 417 app_pipeline_routing_delete_route(struct app_params *app,
 418         uint32_t pipeline_id,
 419         struct pipeline_routing_route_key *key)
 420 {
 421         struct pipeline_routing *p;
 422
 423         struct pipeline_routing_route_delete_msg_req *req;
 424         struct pipeline_routing_route_delete_msg_rsp *rsp;
 425
 426         struct app_pipeline_routing_route *entry;
 427
 428         /* Check input arguments */
 429         if ((app == NULL) ||
 430                 (key == NULL))
 431                 return -1;
 432
 433         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 434         if (p == NULL)
 435                 return -1;
 436
 437         switch (key->type) {
 438         case PIPELINE_ROUTING_ROUTE_IPV4:
 439         {
 440                 uint32_t depth = key->key.ipv4.depth;
 441                 uint32_t netmask;
 442
 443                 /* key */
 444                 if ((depth == 0) || (depth > 32))
 445                         return -1;
 446
 447                 netmask = (~0U) << (32 - depth);
 448                 key->key.ipv4.ip &= netmask;
 449         }
 450         break;
 451
 452         default:
 453                 return -1;
 454         }
 455
 456         /* Find rule */
 457         entry = app_pipeline_routing_find_route(p, key);
 458         if (entry == NULL)
 459                 return 0;
 460
 461         /* Allocate and write request */
 462         req = app_msg_alloc(app);
 463         if (req == NULL)
 464                 return -1;
 465
 466         req->type = PIPELINE_MSG_REQ_CUSTOM;
 467         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL;
 468         memcpy(&req->key, key, sizeof(*key));
 469
 470         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 471         if (rsp == NULL)
 472                 return -1;
 473
 474         /* Read response */
 475         if (rsp->status || !rsp->key_found) {
 476                 app_msg_free(app, rsp);
 477                 return -1;
 478         }
 479
 480         /* Remove route */
 481         TAILQ_REMOVE(&p->routes, entry, node);
 482         p->n_routes--;
 483         rte_free(entry);
 484
 485         /* Free response */
 486         app_msg_free(app, rsp);
 487
 488         return 0;
 489 }
 490
 491 int
 492 app_pipeline_routing_add_default_route(struct app_params *app,
 493         uint32_t pipeline_id,
 494         uint32_t port_id)
 495 {
 496         struct pipeline_routing *p;
 497
 498         struct pipeline_routing_route_add_default_msg_req *req;
 499         struct pipeline_routing_route_add_default_msg_rsp *rsp;
 500
 501         /* Check input arguments */
 502         if (app == NULL)
 503                 return -1;
 504
 505         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 506         if (p == NULL)
 507                 return -1;
 508
 509         if (port_id >= p->n_ports_out)
 510                 return -1;
 511
 512         /* Allocate and write request */
 513         req = app_msg_alloc(app);
 514         if (req == NULL)
 515                 return -1;
 516
 517         req->type = PIPELINE_MSG_REQ_CUSTOM;
 518         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD_DEFAULT;
 519         req->port_id = port_id;
 520
 521         /* Send request and wait for response */
 522         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 523         if (rsp == NULL)
 524                 return -1;
 525
 526         /* Read response and write route */
 527         if (rsp->status || (rsp->entry_ptr == NULL)) {
 528                 app_msg_free(app, rsp);
 529                 return -1;
 530         }
 531
 532         p->default_route_port_id = port_id;
 533         p->default_route_entry_ptr = rsp->entry_ptr;
 534
 535         /* Commit route */
 536         p->default_route_present = 1;
 537
 538         /* Free response */
 539         app_msg_free(app, rsp);
 540
 541         return 0;
 542 }
 543
 544 int
 545 app_pipeline_routing_delete_default_route(struct app_params *app,
 546         uint32_t pipeline_id)
 547 {
 548         struct pipeline_routing *p;
 549
 550         struct pipeline_routing_arp_delete_default_msg_req *req;
 551         struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
 552
 553         /* Check input arguments */
 554         if (app == NULL)
 555                 return -1;
 556
 557         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 558         if (p == NULL)
 559                 return -1;
 560
 561         /* Allocate and write request */
 562         req = app_msg_alloc(app);
 563         if (req == NULL)
 564                 return -1;
 565
 566         req->type = PIPELINE_MSG_REQ_CUSTOM;
 567         req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL_DEFAULT;
 568
 569         /* Send request and wait for response */
 570         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 571         if (rsp == NULL)
 572                 return -1;
 573
 574         /* Read response and write route */
 575         if (rsp->status) {
 576                 app_msg_free(app, rsp);
 577                 return -1;
 578         }
 579
 580         /* Commit route */
 581         p->default_route_present = 0;
 582
 583         /* Free response */
 584         app_msg_free(app, rsp);
 585
 586         return 0;
 587 }
 588
 589 static int
 590 app_pipeline_routing_arp_ls(struct app_params *app, uint32_t pipeline_id)
 591 {
 592         struct pipeline_routing *p;
 593         struct app_pipeline_routing_arp_entry *it;
 594
 595         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 596         if (p == NULL)
 597                 return -EINVAL;
 598
 599         TAILQ_FOREACH(it, &p->arp_entries, node)
 600                 print_arp_entry(it);
 601
 602         if (p->default_arp_entry_present)
 603                 printf("Default entry: port %" PRIu32 " (entry ptr = %p)\n",
 604                                 p->default_arp_entry_port_id,
 605                                 p->default_arp_entry_ptr);
 606         else
 607                 printf("Default: DROP\n");
 608
 609         return 0;
 610 }
 611
 612 int
 613 app_pipeline_routing_add_arp_entry(struct app_params *app, uint32_t pipeline_id,
 614                 struct pipeline_routing_arp_key *key,
 615                 struct ether_addr *macaddr)
 616 {
 617         struct pipeline_routing *p;
 618
 619         struct pipeline_routing_arp_add_msg_req *req;
 620         struct pipeline_routing_arp_add_msg_rsp *rsp;
 621
 622         struct app_pipeline_routing_arp_entry *entry;
 623
 624         int new_entry;
 625
 626         /* Check input arguments */
 627         if ((app == NULL) ||
 628                 (key == NULL) ||
 629                 (macaddr == NULL))
 630                 return -1;
 631
 632         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 633         if (p == NULL)
 634                 return -1;
 635
 636         switch (key->type) {
 637         case PIPELINE_ROUTING_ARP_IPV4:
 638         {
 639                 uint32_t port_id = key->key.ipv4.port_id;
 640
 641                 /* key */
 642                 if (port_id >= p->n_ports_out)
 643                         return -1;
 644         }
 645         break;
 646
 647         default:
 648                 return -1;
 649         }
 650
 651         /* Find existing entry or allocate new */
 652         entry = app_pipeline_routing_find_arp_entry(p, key);
 653         new_entry = (entry == NULL);
 654         if (entry == NULL) {
 655                 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
 656
 657                 if (entry == NULL)
 658                         return -1;
 659         }
 660
 661         /* Message buffer allocation */
 662         req = app_msg_alloc(app);
 663         if (req == NULL) {
 664                 if (new_entry)
 665                         rte_free(entry);
 666                 return -1;
 667         }
 668
 669         req->type = PIPELINE_MSG_REQ_CUSTOM;
 670         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD;
 671         memcpy(&req->key, key, sizeof(*key));
 672         ether_addr_copy(macaddr, &req->macaddr);
 673
 674         /* Send request and wait for response */
 675         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 676         if (rsp == NULL) {
 677                 if (new_entry)
 678                         rte_free(entry);
 679                 return -1;
 680         }
 681
 682         /* Read response and write entry */
 683         if (rsp->status ||
 684                 (rsp->entry_ptr == NULL) ||
 685                 ((new_entry == 0) && (rsp->key_found == 0)) ||
 686                 ((new_entry == 1) && (rsp->key_found == 1))) {
 687                 app_msg_free(app, rsp);
 688                 if (new_entry)
 689                         rte_free(entry);
 690                 return -1;
 691         }
 692
 693         memcpy(&entry->key, key, sizeof(*key));
 694         ether_addr_copy(macaddr, &entry->macaddr);
 695         entry->entry_ptr = rsp->entry_ptr;
 696
 697         /* Commit entry */
 698         if (new_entry) {
 699                 TAILQ_INSERT_TAIL(&p->arp_entries, entry, node);
 700                 p->n_arp_entries++;
 701         }
 702
 703         /* Message buffer free */
 704         app_msg_free(app, rsp);
 705         return 0;
 706 }
 707
 708 int
 709 app_pipeline_routing_delete_arp_entry(struct app_params *app,
 710         uint32_t pipeline_id,
 711         struct pipeline_routing_arp_key *key)
 712 {
 713         struct pipeline_routing *p;
 714
 715         struct pipeline_routing_arp_delete_msg_req *req;
 716         struct pipeline_routing_arp_delete_msg_rsp *rsp;
 717
 718         struct app_pipeline_routing_arp_entry *entry;
 719
 720         /* Check input arguments */
 721         if ((app == NULL) ||
 722                 (key == NULL))
 723                 return -1;
 724
 725         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 726         if (p == NULL)
 727                 return -EINVAL;
 728
 729         switch (key->type) {
 730         case PIPELINE_ROUTING_ARP_IPV4:
 731         {
 732                 uint32_t port_id = key->key.ipv4.port_id;
 733
 734                 /* key */
 735                 if (port_id >= p->n_ports_out)
 736                         return -1;
 737         }
 738         break;
 739
 740         default:
 741                 return -1;
 742         }
 743
 744         /* Find rule */
 745         entry = app_pipeline_routing_find_arp_entry(p, key);
 746         if (entry == NULL)
 747                 return 0;
 748
 749         /* Allocate and write request */
 750         req = app_msg_alloc(app);
 751         if (req == NULL)
 752                 return -1;
 753
 754         req->type = PIPELINE_MSG_REQ_CUSTOM;
 755         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL;
 756         memcpy(&req->key, key, sizeof(*key));
 757
 758         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 759         if (rsp == NULL)
 760                 return -1;
 761
 762         /* Read response */
 763         if (rsp->status || !rsp->key_found) {
 764                 app_msg_free(app, rsp);
 765                 return -1;
 766         }
 767
 768         /* Remove entry */
 769         TAILQ_REMOVE(&p->arp_entries, entry, node);
 770         p->n_arp_entries--;
 771         rte_free(entry);
 772
 773         /* Free response */
 774         app_msg_free(app, rsp);
 775
 776         return 0;
 777 }
 778
 779 int
 780 app_pipeline_routing_add_default_arp_entry(struct app_params *app,
 781                 uint32_t pipeline_id,
 782                 uint32_t port_id)
 783 {
 784         struct pipeline_routing *p;
 785
 786         struct pipeline_routing_arp_add_default_msg_req *req;
 787         struct pipeline_routing_arp_add_default_msg_rsp *rsp;
 788
 789         /* Check input arguments */
 790         if (app == NULL)
 791                 return -1;
 792
 793         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 794         if (p == NULL)
 795                 return -1;
 796
 797         if (port_id >= p->n_ports_out)
 798                 return -1;
 799
 800         /* Allocate and write request */
 801         req = app_msg_alloc(app);
 802         if (req == NULL)
 803                 return -1;
 804
 805         req->type = PIPELINE_MSG_REQ_CUSTOM;
 806         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD_DEFAULT;
 807         req->port_id = port_id;
 808
 809         /* Send request and wait for response */
 810         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 811         if (rsp == NULL)
 812                 return -1;
 813
 814         /* Read response and write entry */
 815         if (rsp->status || rsp->entry_ptr == NULL) {
 816                 app_msg_free(app, rsp);
 817                 return -1;
 818         }
 819
 820         p->default_arp_entry_port_id = port_id;
 821         p->default_arp_entry_ptr = rsp->entry_ptr;
 822
 823         /* Commit entry */
 824         p->default_arp_entry_present = 1;
 825
 826         /* Free response */
 827         app_msg_free(app, rsp);
 828
 829         return 0;
 830 }
 831
 832 int
 833 app_pipeline_routing_delete_default_arp_entry(struct app_params *app,
 834         uint32_t pipeline_id)
 835 {
 836         struct pipeline_routing *p;
 837
 838         struct pipeline_routing_arp_delete_default_msg_req *req;
 839         struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
 840
 841         /* Check input arguments */
 842         if (app == NULL)
 843                 return -1;
 844
 845         p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
 846         if (p == NULL)
 847                 return -EINVAL;
 848
 849         /* Allocate and write request */
 850         req = app_msg_alloc(app);
 851         if (req == NULL)
 852                 return -ENOMEM;
 853
 854         req->type = PIPELINE_MSG_REQ_CUSTOM;
 855         req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL_DEFAULT;
 856
 857         /* Send request and wait for response */
 858         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 859         if (rsp == NULL)
 860                 return -ETIMEDOUT;
 861
 862         /* Read response and write entry */
 863         if (rsp->status) {
 864                 app_msg_free(app, rsp);
 865                 return rsp->status;
 866         }
 867
 868         /* Commit entry */
 869         p->default_arp_entry_present = 0;
 870
 871         /* Free response */
 872         app_msg_free(app, rsp);
 873
 874         return 0;
 875 }
 876
 877 int
 878 app_pipeline_routing_set_macaddr(struct app_params *app,
 879         uint32_t pipeline_id)
 880 {
 881         struct app_pipeline_params *p;
 882         struct pipeline_routing_set_macaddr_msg_req *req;
 883         struct pipeline_routing_set_macaddr_msg_rsp *rsp;
 884         uint32_t port_id;
 885
 886         /* Check input arguments */
 887         if (app == NULL)
 888                 return -EINVAL;
 889
 890         APP_PARAM_FIND_BY_ID(app->pipeline_params, "PIPELINE", pipeline_id, p);
 891         if (p == NULL)
 892                 return -EINVAL;
 893
 894         /* Allocate and write request */
 895         req = app_msg_alloc(app);
 896         if (req == NULL)
 897                 return -ENOMEM;
 898
 899         req->type = PIPELINE_MSG_REQ_CUSTOM;
 900         req->subtype = PIPELINE_ROUTING_MSG_REQ_SET_MACADDR;
 901
 902         memset(req->macaddr, 0, sizeof(req->macaddr));
 903         for (port_id = 0; port_id < p->n_pktq_out; port_id++) {
 904                 struct app_link_params *link;
 905
 906                 link = app_pipeline_track_pktq_out_to_link(app,
 907                         pipeline_id,
 908                         port_id);
 909                 if (link)
 910                         req->macaddr[port_id] = link->mac_addr;
 911         }
 912
 913         /* Send request and wait for response */
 914         rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
 915         if (rsp == NULL)
 916                 return -ETIMEDOUT;
 917
 918         /* Read response and write entry */
 919         if (rsp->status) {
 920                 app_msg_free(app, rsp);
 921                 return rsp->status;
 922         }
 923
 924         /* Free response */
 925         app_msg_free(app, rsp);
 926
 927         return 0;
 928 }
 929
 930 /*
 931  * route
 932  *
 933  * route add (ARP = ON/OFF, MPLS = ON/OFF, QINQ = ON/OFF):
 934  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhmacaddr>
 935  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhipaddr>
 936  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhmacaddr> qinq <svlan> <cvlan>
 937  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhipaddr> qinq <svlan> <cvlan>
 938  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhmacaddr> mpls <mpls labels>
 939  *    p <pipelineid> route add <ipaddr> <depth> port <portid> ether <nhipaddr> mpls <mpls labels>
 940  *
 941  * route add default:
 942  *    p <pipelineid> route add default <portid>
 943  *
 944  * route del:
 945  *    p <pipelineid> route del <ipaddr> <depth>
 946  *
 947  * route del default:
 948  *    p <pipelineid> route del default
 949  *
 950  * route ls:
 951  *    p <pipelineid> route ls
 952  */
 953
 954 struct cmd_route_result {
 955         cmdline_fixed_string_t p_string;
 956         uint32_t p;
 957         cmdline_fixed_string_t route_string;
 958         cmdline_multi_string_t multi_string;
 959 };
 960
 961 static void
 962 cmd_route_parsed(
 963         void *parsed_result,
 964         __rte_unused struct cmdline *cl,
 965         void *data)
 966 {
 967         struct cmd_route_result *params = parsed_result;
 968         struct app_params *app = data;
 969
 970         char *tokens[16];
 971         uint32_t n_tokens = RTE_DIM(tokens);
 972         int status;
 973
 974         status = parse_tokenize_string(params->multi_string, tokens, &n_tokens);
 975         if (status != 0) {
 976                 printf(CMD_MSG_TOO_MANY_ARGS, "route");
 977                 return;
 978         }
 979
 980         /* route add */
 981         if ((n_tokens >= 2) &&
 982                 (strcmp(tokens[0], "add") == 0) &&
 983                 strcmp(tokens[1], "default")) {
 984                 struct pipeline_routing_route_key key;
 985                 struct pipeline_routing_route_data route_data;
 986                 struct in_addr ipv4, nh_ipv4;
 987                 struct ether_addr mac_addr;
 988                 uint32_t depth, port_id, svlan, cvlan, i;
 989                 uint32_t mpls_labels[PIPELINE_ROUTING_MPLS_LABELS_MAX];
 990                 uint32_t n_labels = RTE_DIM(mpls_labels);
 991
 992                 memset(&key, 0, sizeof(key));
 993                 memset(&route_data, 0, sizeof(route_data));
 994
 995                 if (n_tokens < 7) {
 996                         printf(CMD_MSG_NOT_ENOUGH_ARGS, "route add");
 997                         return;
 998                 }
 999
1000                 if (parse_ipv4_addr(tokens[1], &ipv4)) {
1001                         printf(CMD_MSG_INVALID_ARG, "ipaddr");
1002                         return;
1003                 }
1004
1005                 if (parser_read_uint32(&depth, tokens[2])) {
1006                         printf(CMD_MSG_INVALID_ARG, "depth");
1007                         return;
1008                 }
1009
1010                 if (strcmp(tokens[3], "port")) {
1011                         printf(CMD_MSG_ARG_NOT_FOUND, "port");
1012                         return;
1013                 }
1014
1015                 if (parser_read_uint32(&port_id, tokens[4])) {
1016                         printf(CMD_MSG_INVALID_ARG, "portid");
1017                         return;
1018                 }
1019
1020                 if (strcmp(tokens[5], "ether")) {
1021                         printf(CMD_MSG_ARG_NOT_FOUND, "ether");
1022                         return;
1023                 }
1024
1025                 if (parse_mac_addr(tokens[6], &mac_addr)) {
1026                         if (parse_ipv4_addr(tokens[6], &nh_ipv4)) {
1027                                 printf(CMD_MSG_INVALID_ARG, "nhmacaddr or nhipaddr");
1028                                 return;
1029                         }
1030
1031                         route_data.flags |= PIPELINE_ROUTING_ROUTE_ARP;
1032                 }
1033
1034                 if (n_tokens > 7) {
1035                         if (strcmp(tokens[7], "mpls") == 0) {
1036                                 if (n_tokens != 9) {
1037                                         printf(CMD_MSG_MISMATCH_ARGS, "route add mpls");
1038                                         return;
1039                                 }
1040
1041                                 if (parse_mpls_labels(tokens[8], mpls_labels, &n_labels)) {
1042                                         printf(CMD_MSG_INVALID_ARG, "mpls labels");
1043                                         return;
1044                                 }
1045
1046                                 route_data.flags |= PIPELINE_ROUTING_ROUTE_MPLS;
1047                         } else if (strcmp(tokens[7], "qinq") == 0) {
1048                                 if (n_tokens != 10) {
1049                                         printf(CMD_MSG_MISMATCH_ARGS, "route add qinq");
1050                                         return;
1051                                 }
1052
1053                                 if (parser_read_uint32(&svlan, tokens[8])) {
1054                                         printf(CMD_MSG_INVALID_ARG, "svlan");
1055                                         return;
1056                                 }
1057                                 if (parser_read_uint32(&cvlan, tokens[9])) {
1058                                         printf(CMD_MSG_INVALID_ARG, "cvlan");
1059                                         return;
1060                                 }
1061
1062                                 route_data.flags |= PIPELINE_ROUTING_ROUTE_QINQ;
1063                         } else {
1064                                 printf(CMD_MSG_ARG_NOT_FOUND, "mpls or qinq");
1065                                 return;
1066                         }
1067                 }
1068
1069                 switch (route_data.flags) {
1070                 case 0:
1071                         route_data.port_id = port_id;
1072                         route_data.ethernet.macaddr = mac_addr;
1073                         break;
1074
1075                 case PIPELINE_ROUTING_ROUTE_ARP:
1076                         route_data.port_id = port_id;
1077                         route_data.ethernet.ip = rte_be_to_cpu_32(nh_ipv4.s_addr);
1078                         break;
1079
1080                 case PIPELINE_ROUTING_ROUTE_MPLS:
1081                         route_data.port_id = port_id;
1082                         route_data.ethernet.macaddr = mac_addr;
1083                         for (i = 0; i < n_labels; i++)
1084                                 route_data.l2.mpls.labels[i] = mpls_labels[i];
1085                         route_data.l2.mpls.n_labels = n_labels;
1086                         break;
1087
1088                 case PIPELINE_ROUTING_ROUTE_MPLS | PIPELINE_ROUTING_ROUTE_ARP:
1089                         route_data.port_id = port_id;
1090                         route_data.ethernet.ip = rte_be_to_cpu_32(nh_ipv4.s_addr);
1091                         for (i = 0; i < n_labels; i++)
1092                                 route_data.l2.mpls.labels[i] = mpls_labels[i];
1093                         route_data.l2.mpls.n_labels = n_labels;
1094                         break;
1095
1096                 case PIPELINE_ROUTING_ROUTE_QINQ:
1097                         route_data.port_id = port_id;
1098                         route_data.ethernet.macaddr = mac_addr;
1099                         route_data.l2.qinq.svlan = svlan;
1100                         route_data.l2.qinq.cvlan = cvlan;
1101                         break;
1102
1103                 case PIPELINE_ROUTING_ROUTE_QINQ | PIPELINE_ROUTING_ROUTE_ARP:
1104                 default:
1105                         route_data.port_id = port_id;
1106                         route_data.ethernet.ip = rte_be_to_cpu_32(nh_ipv4.s_addr);
1107                         route_data.l2.qinq.svlan = svlan;
1108                         route_data.l2.qinq.cvlan = cvlan;
1109                         break;
1110                 }
1111
1112                 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1113                 key.key.ipv4.ip = rte_be_to_cpu_32(ipv4.s_addr);
1114                 key.key.ipv4.depth = depth;
1115
1116                 status = app_pipeline_routing_add_route(app,
1117                         params->p,
1118                         &key,
1119                         &route_data);
1120                 if (status != 0)
1121                         printf(CMD_MSG_FAIL, "route add");
1122
1123                 return;
1124         } /* route add */
1125
1126         /* route add default */
1127         if ((n_tokens >= 2) &&
1128                 (strcmp(tokens[0], "add") == 0) &&
1129                 (strcmp(tokens[1], "default") == 0)) {
1130                 uint32_t port_id;
1131
1132                 if (n_tokens != 3) {
1133                         printf(CMD_MSG_MISMATCH_ARGS, "route add default");
1134                         return;
1135                 }
1136
1137                 if (parser_read_uint32(&port_id, tokens[2])) {
1138                         printf(CMD_MSG_INVALID_ARG, "portid");
1139                         return;
1140                 }
1141
1142                 status = app_pipeline_routing_add_default_route(app,
1143                         params->p,
1144                         port_id);
1145                 if (status != 0)
1146                         printf(CMD_MSG_FAIL, "route add default");
1147
1148                 return;
1149         } /* route add default */
1150
1151         /* route del*/
1152         if ((n_tokens >= 2) &&
1153                 (strcmp(tokens[0], "del") == 0) &&
1154                 strcmp(tokens[1], "default")) {
1155                 struct pipeline_routing_route_key key;
1156                 struct in_addr ipv4;
1157                 uint32_t depth;
1158
1159                 memset(&key, 0, sizeof(key));
1160
1161                 if (n_tokens != 3) {
1162                         printf(CMD_MSG_MISMATCH_ARGS, "route del");
1163                         return;
1164                 }
1165
1166                 if (parse_ipv4_addr(tokens[1], &ipv4)) {
1167                         printf(CMD_MSG_INVALID_ARG, "ipaddr");
1168                         return;
1169                 }
1170
1171                 if (parser_read_uint32(&depth, tokens[2])) {
1172                         printf(CMD_MSG_INVALID_ARG, "depth");
1173                         return;
1174                 }
1175
1176                 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1177                 key.key.ipv4.ip = rte_be_to_cpu_32(ipv4.s_addr);
1178                 key.key.ipv4.depth = depth;
1179
1180                 status = app_pipeline_routing_delete_route(app, params->p, &key);
1181                 if (status != 0)
1182                         printf(CMD_MSG_FAIL, "route del");
1183
1184                 return;
1185         } /* route del */
1186
1187         /* route del default */
1188         if ((n_tokens >= 2) &&
1189                 (strcmp(tokens[0], "del") == 0) &&
1190                 (strcmp(tokens[1], "default") == 0)) {
1191                 if (n_tokens != 2) {
1192                         printf(CMD_MSG_MISMATCH_ARGS, "route del default");
1193                         return;
1194                 }
1195
1196                 status = app_pipeline_routing_delete_default_route(app,
1197                         params->p);
1198                 if (status != 0)
1199                         printf(CMD_MSG_FAIL, "route del default");
1200
1201                 return;
1202         } /* route del default */
1203
1204         /* route ls */
1205         if ((n_tokens >= 1) && (strcmp(tokens[0], "ls") == 0)) {
1206                 if (n_tokens != 1) {
1207                         printf(CMD_MSG_MISMATCH_ARGS, "route ls");
1208                         return;
1209                 }
1210
1211                 status = app_pipeline_routing_route_ls(app, params->p);
1212                 if (status != 0)
1213                         printf(CMD_MSG_FAIL, "route ls");
1214
1215                 return;
1216         } /* route ls */
1217
1218         printf(CMD_MSG_MISMATCH_ARGS, "route");
1219 }
1220
1221 static cmdline_parse_token_string_t cmd_route_p_string =
1222         TOKEN_STRING_INITIALIZER(struct cmd_route_result, p_string, "p");
1223
1224 static cmdline_parse_token_num_t cmd_route_p =
1225         TOKEN_NUM_INITIALIZER(struct cmd_route_result, p, UINT32);
1226
1227 static cmdline_parse_token_string_t cmd_route_route_string =
1228         TOKEN_STRING_INITIALIZER(struct cmd_route_result, route_string, "route");
1229
1230 static cmdline_parse_token_string_t cmd_route_multi_string =
1231         TOKEN_STRING_INITIALIZER(struct cmd_route_result, multi_string,
1232         TOKEN_STRING_MULTI);
1233
1234 static cmdline_parse_inst_t cmd_route = {
1235         .f = cmd_route_parsed,
1236         .data = NULL,
1237         .help_str = "route add / add default / del / del default / ls",
1238         .tokens = {
1239                 (void *)&cmd_route_p_string,
1240                 (void *)&cmd_route_p,
1241                 (void *)&cmd_route_route_string,
1242                 (void *)&cmd_route_multi_string,
1243                 NULL,
1244         },
1245 };
1246
1247 /*
1248  * arp
1249  *
1250  * arp add:
1251  *    p <pipelineid> arp add <portid> <ipaddr> <macaddr>
1252  *
1253  * arp add default:
1254  *    p <pipelineid> arp add default <portid>
1255  *
1256  * arp del:
1257  *    p <pipelineid> arp del <portid> <ipaddr>
1258  *
1259  * arp del default:
1260  *    p <pipelineid> arp del default
1261  *
1262  * arp ls:
1263  *    p <pipelineid> arp ls
1264  */
1265
1266 struct cmd_arp_result {
1267         cmdline_fixed_string_t p_string;
1268         uint32_t p;
1269         cmdline_fixed_string_t arp_string;
1270         cmdline_multi_string_t multi_string;
1271 };
1272
1273 static void
1274 cmd_arp_parsed(
1275         void *parsed_result,
1276         __rte_unused struct cmdline *cl,
1277         void *data)
1278 {
1279         struct cmd_arp_result *params = parsed_result;
1280         struct app_params *app = data;
1281
1282         char *tokens[16];
1283         uint32_t n_tokens = RTE_DIM(tokens);
1284         int status;
1285
1286         status = parse_tokenize_string(params->multi_string, tokens, &n_tokens);
1287         if (status != 0) {
1288                 printf(CMD_MSG_TOO_MANY_ARGS, "arp");
1289                 return;
1290         }
1291
1292         /* arp add */
1293         if ((n_tokens >= 2) &&
1294                 (strcmp(tokens[0], "add") == 0) &&
1295                 strcmp(tokens[1], "default")) {
1296                 struct pipeline_routing_arp_key key;
1297                 struct in_addr ipv4;
1298                 struct ether_addr mac_addr;
1299                 uint32_t port_id;
1300
1301                 memset(&key, 0, sizeof(key));
1302
1303                 if (n_tokens != 4) {
1304                         printf(CMD_MSG_MISMATCH_ARGS, "arp add");
1305                         return;
1306                 }
1307
1308                 if (parser_read_uint32(&port_id, tokens[1])) {
1309                         printf(CMD_MSG_INVALID_ARG, "portid");
1310                         return;
1311                 }
1312
1313                 if (parse_ipv4_addr(tokens[2], &ipv4)) {
1314                         printf(CMD_MSG_INVALID_ARG, "ipaddr");
1315                         return;
1316                 }
1317
1318                 if (parse_mac_addr(tokens[3], &mac_addr)) {
1319                         printf(CMD_MSG_INVALID_ARG, "macaddr");
1320                         return;
1321                 }
1322
1323                 key.type = PIPELINE_ROUTING_ARP_IPV4;
1324                 key.key.ipv4.port_id = port_id;
1325                 key.key.ipv4.ip = rte_be_to_cpu_32(ipv4.s_addr);
1326
1327                 status = app_pipeline_routing_add_arp_entry(app,
1328                         params->p,
1329                         &key,
1330                         &mac_addr);
1331                 if (status != 0)
1332                         printf(CMD_MSG_FAIL, "arp add");
1333
1334                 return;
1335         } /* arp add */
1336
1337         /* arp add default */
1338         if ((n_tokens >= 2) &&
1339                 (strcmp(tokens[0], "add") == 0) &&
1340                 (strcmp(tokens[1], "default") == 0)) {
1341                 uint32_t port_id;
1342
1343                 if (n_tokens != 3) {
1344                         printf(CMD_MSG_MISMATCH_ARGS, "arp add default");
1345                         return;
1346                 }
1347
1348                 if (parser_read_uint32(&port_id, tokens[2])) {
1349                         printf(CMD_MSG_INVALID_ARG, "portid");
1350                         return;
1351                 }
1352
1353                 status = app_pipeline_routing_add_default_arp_entry(app,
1354                         params->p,
1355                         port_id);
1356                 if (status != 0)
1357                         printf(CMD_MSG_FAIL, "arp add default");
1358
1359                 return;
1360         } /* arp add default */
1361
1362         /* arp del*/
1363         if ((n_tokens >= 2) &&
1364                 (strcmp(tokens[0], "del") == 0) &&
1365                 strcmp(tokens[1], "default")) {
1366                 struct pipeline_routing_arp_key key;
1367                 struct in_addr ipv4;
1368                 uint32_t port_id;
1369
1370                 memset(&key, 0, sizeof(key));
1371
1372                 if (n_tokens != 3) {
1373                         printf(CMD_MSG_MISMATCH_ARGS, "arp del");
1374                         return;
1375                 }
1376
1377                 if (parser_read_uint32(&port_id, tokens[1])) {
1378                         printf(CMD_MSG_INVALID_ARG, "portid");
1379                         return;
1380                 }
1381
1382                 if (parse_ipv4_addr(tokens[2], &ipv4)) {
1383                         printf(CMD_MSG_INVALID_ARG, "ipaddr");
1384                         return;
1385                 }
1386
1387                 key.type = PIPELINE_ROUTING_ARP_IPV4;
1388                 key.key.ipv4.ip = rte_be_to_cpu_32(ipv4.s_addr);
1389                 key.key.ipv4.port_id = port_id;
1390
1391                 status = app_pipeline_routing_delete_arp_entry(app,
1392                         params->p,
1393                         &key);
1394                 if (status != 0)
1395                         printf(CMD_MSG_FAIL, "arp del");
1396
1397                 return;
1398         } /* arp del */
1399
1400         /* arp del default */
1401         if ((n_tokens >= 2) &&
1402                 (strcmp(tokens[0], "del") == 0) &&
1403                 (strcmp(tokens[1], "default") == 0)) {
1404                         if (n_tokens != 2) {
1405                                 printf(CMD_MSG_MISMATCH_ARGS, "arp del default");
1406                                 return;
1407                         }
1408
1409                         status = app_pipeline_routing_delete_default_arp_entry(app,
1410                                 params->p);
1411                         if (status != 0)
1412                                 printf(CMD_MSG_FAIL, "arp del default");
1413
1414                         return;
1415         } /* arp del default */
1416
1417         /* arp ls */
1418         if ((n_tokens >= 1) && (strcmp(tokens[0], "ls") == 0)) {
1419                 if (n_tokens != 1) {
1420                         printf(CMD_MSG_MISMATCH_ARGS, "arp ls");
1421                         return;
1422                 }
1423
1424                 status = app_pipeline_routing_arp_ls(app, params->p);
1425                 if (status != 0)
1426                         printf(CMD_MSG_FAIL, "arp ls");
1427
1428                 return;
1429         } /* arp ls */
1430
1431         printf(CMD_MSG_FAIL, "arp");
1432 }
1433
1434 static cmdline_parse_token_string_t cmd_arp_p_string =
1435         TOKEN_STRING_INITIALIZER(struct cmd_arp_result, p_string, "p");
1436
1437 static cmdline_parse_token_num_t cmd_arp_p =
1438         TOKEN_NUM_INITIALIZER(struct cmd_arp_result, p, UINT32);
1439
1440 static cmdline_parse_token_string_t cmd_arp_arp_string =
1441         TOKEN_STRING_INITIALIZER(struct cmd_arp_result, arp_string, "arp");
1442
1443 static cmdline_parse_token_string_t cmd_arp_multi_string =
1444         TOKEN_STRING_INITIALIZER(struct cmd_arp_result, multi_string,
1445         TOKEN_STRING_MULTI);
1446
1447 static cmdline_parse_inst_t cmd_arp = {
1448         .f = cmd_arp_parsed,
1449         .data = NULL,
1450         .help_str = "arp add / add default / del / del default / ls",
1451         .tokens = {
1452                 (void *)&cmd_arp_p_string,
1453                 (void *)&cmd_arp_p,
1454                 (void *)&cmd_arp_arp_string,
1455                 (void *)&cmd_arp_multi_string,
1456                 NULL,
1457         },
1458 };
1459
1460 static cmdline_parse_ctx_t pipeline_cmds[] = {
1461         (cmdline_parse_inst_t *)&cmd_route,
1462         (cmdline_parse_inst_t *)&cmd_arp,
1463         NULL,
1464 };
1465
1466 static struct pipeline_fe_ops pipeline_routing_fe_ops = {
1467         .f_init = app_pipeline_routing_init,
1468         .f_post_init = app_pipeline_routing_post_init,
1469         .f_free = app_pipeline_routing_free,
1470         .f_track = app_pipeline_track_default,
1471         .cmds = pipeline_cmds,
1472 };
1473
1474 struct pipeline_type pipeline_routing = {
1475         .name = "ROUTING",
1476         .be_ops = &pipeline_routing_be_ops,
1477         .fe_ops = &pipeline_routing_fe_ops,
1478 };