4 * Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
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>
41 #include "pipeline_common_fe.h"
42 #include "pipeline_routing.h"
44 struct app_pipeline_routing_route {
45 struct pipeline_routing_route_key key;
46 struct pipeline_routing_route_data data;
49 TAILQ_ENTRY(app_pipeline_routing_route) node;
52 struct app_pipeline_routing_arp_entry {
53 struct pipeline_routing_arp_key key;
54 struct ether_addr macaddr;
57 TAILQ_ENTRY(app_pipeline_routing_arp_entry) node;
60 struct pipeline_routing {
66 TAILQ_HEAD(, app_pipeline_routing_route) routes;
69 uint32_t default_route_present;
70 uint32_t default_route_port_id;
71 void *default_route_entry_ptr;
74 TAILQ_HEAD(, app_pipeline_routing_arp_entry) arp_entries;
75 uint32_t n_arp_entries;
77 uint32_t default_arp_entry_present;
78 uint32_t default_arp_entry_port_id;
79 void *default_arp_entry_ptr;
83 pipeline_routing_init(struct pipeline_params *params,
84 __rte_unused void *arg)
86 struct pipeline_routing *p;
89 /* Check input arguments */
90 if ((params == NULL) ||
91 (params->n_ports_in == 0) ||
92 (params->n_ports_out == 0))
95 /* Memory allocation */
96 size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct pipeline_routing));
97 p = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
102 p->n_ports_in = params->n_ports_in;
103 p->n_ports_out = params->n_ports_out;
105 TAILQ_INIT(&p->routes);
108 TAILQ_INIT(&p->arp_entries);
109 p->n_arp_entries = 0;
115 app_pipeline_routing_free(void *pipeline)
117 struct pipeline_routing *p = pipeline;
119 /* Check input arguments */
124 while (!TAILQ_EMPTY(&p->routes)) {
125 struct app_pipeline_routing_route *route;
127 route = TAILQ_FIRST(&p->routes);
128 TAILQ_REMOVE(&p->routes, route, node);
132 while (!TAILQ_EMPTY(&p->arp_entries)) {
133 struct app_pipeline_routing_arp_entry *arp_entry;
135 arp_entry = TAILQ_FIRST(&p->arp_entries);
136 TAILQ_REMOVE(&p->arp_entries, arp_entry, node);
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)
148 struct app_pipeline_routing_route *it, *found;
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)) {
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)
167 struct app_pipeline_routing_arp_entry *it, *found;
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)) {
183 print_route(const struct app_pipeline_routing_route *route)
185 if (route->key.type == PIPELINE_ROUTING_ROUTE_IPV4) {
186 const struct pipeline_routing_route_key_ipv4 *key =
187 &route->key.key.ipv4;
189 printf("IP Prefix = %" PRIu32 ".%" PRIu32
190 ".%" PRIu32 ".%" PRIu32 "/%" PRIu32
191 " => (Port = %" PRIu32,
193 (key->ip >> 24) & 0xFF,
194 (key->ip >> 16) & 0xFF,
195 (key->ip >> 8) & 0xFF,
199 route->data.port_id);
201 if (route->data.flags & PIPELINE_ROUTING_ROUTE_ARP)
203 ", Next Hop IP = %" PRIu32 ".%" PRIu32
204 ".%" PRIu32 ".%" PRIu32,
206 (route->data.ethernet.ip >> 24) & 0xFF,
207 (route->data.ethernet.ip >> 16) & 0xFF,
208 (route->data.ethernet.ip >> 8) & 0xFF,
209 route->data.ethernet.ip & 0xFF);
212 ", Next Hop HWaddress = %02" PRIx32
213 ":%02" PRIx32 ":%02" PRIx32
214 ":%02" PRIx32 ":%02" PRIx32
217 route->data.ethernet.macaddr.addr_bytes[0],
218 route->data.ethernet.macaddr.addr_bytes[1],
219 route->data.ethernet.macaddr.addr_bytes[2],
220 route->data.ethernet.macaddr.addr_bytes[3],
221 route->data.ethernet.macaddr.addr_bytes[4],
222 route->data.ethernet.macaddr.addr_bytes[5]);
224 if (route->data.flags & PIPELINE_ROUTING_ROUTE_QINQ)
225 printf(", QinQ SVLAN = %" PRIu32 " CVLAN = %" PRIu32,
226 route->data.l2.qinq.svlan,
227 route->data.l2.qinq.cvlan);
229 if (route->data.flags & PIPELINE_ROUTING_ROUTE_MPLS) {
232 printf(", MPLS labels");
233 for (i = 0; i < route->data.l2.mpls.n_labels; i++)
235 route->data.l2.mpls.labels[i]);
243 print_arp_entry(const struct app_pipeline_routing_arp_entry *entry)
245 printf("(Port = %" PRIu32 ", IP = %" PRIu32 ".%" PRIu32
246 ".%" PRIu32 ".%" PRIu32
247 ") => HWaddress = %02" PRIx32 ":%02" PRIx32 ":%02" PRIx32
248 ":%02" PRIx32 ":%02" PRIx32 ":%02" PRIx32 "\n",
250 entry->key.key.ipv4.port_id,
251 (entry->key.key.ipv4.ip >> 24) & 0xFF,
252 (entry->key.key.ipv4.ip >> 16) & 0xFF,
253 (entry->key.key.ipv4.ip >> 8) & 0xFF,
254 entry->key.key.ipv4.ip & 0xFF,
256 entry->macaddr.addr_bytes[0],
257 entry->macaddr.addr_bytes[1],
258 entry->macaddr.addr_bytes[2],
259 entry->macaddr.addr_bytes[3],
260 entry->macaddr.addr_bytes[4],
261 entry->macaddr.addr_bytes[5]);
265 app_pipeline_routing_route_ls(struct app_params *app, uint32_t pipeline_id)
267 struct pipeline_routing *p;
268 struct app_pipeline_routing_route *it;
270 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
274 TAILQ_FOREACH(it, &p->routes, node)
277 if (p->default_route_present)
278 printf("Default route: port %" PRIu32 " (entry ptr = %p)\n",
279 p->default_route_port_id,
280 p->default_route_entry_ptr);
282 printf("Default: DROP\n");
288 app_pipeline_routing_add_route(struct app_params *app,
289 uint32_t pipeline_id,
290 struct pipeline_routing_route_key *key,
291 struct pipeline_routing_route_data *data)
293 struct pipeline_routing *p;
295 struct pipeline_routing_route_add_msg_req *req;
296 struct pipeline_routing_route_add_msg_rsp *rsp;
298 struct app_pipeline_routing_route *entry;
302 /* Check input arguments */
308 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
313 case PIPELINE_ROUTING_ROUTE_IPV4:
315 uint32_t depth = key->key.ipv4.depth;
319 if ((depth == 0) || (depth > 32))
322 netmask = (~0U) << (32 - depth);
323 key->key.ipv4.ip &= netmask;
326 if (data->port_id >= p->n_ports_out)
335 /* Find existing rule or allocate new rule */
336 entry = app_pipeline_routing_find_route(p, key);
337 new_entry = (entry == NULL);
339 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
345 /* Allocate and write request */
346 req = app_msg_alloc(app);
353 req->type = PIPELINE_MSG_REQ_CUSTOM;
354 req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD;
355 memcpy(&req->key, key, sizeof(*key));
356 memcpy(&req->data, data, sizeof(*data));
358 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
365 /* Read response and write entry */
367 (rsp->entry_ptr == NULL) ||
368 ((new_entry == 0) && (rsp->key_found == 0)) ||
369 ((new_entry == 1) && (rsp->key_found == 1))) {
370 app_msg_free(app, rsp);
376 memcpy(&entry->key, key, sizeof(*key));
377 memcpy(&entry->data, data, sizeof(*data));
378 entry->entry_ptr = rsp->entry_ptr;
382 TAILQ_INSERT_TAIL(&p->routes, entry, node);
388 /* Message buffer free */
389 app_msg_free(app, rsp);
394 app_pipeline_routing_delete_route(struct app_params *app,
395 uint32_t pipeline_id,
396 struct pipeline_routing_route_key *key)
398 struct pipeline_routing *p;
400 struct pipeline_routing_route_delete_msg_req *req;
401 struct pipeline_routing_route_delete_msg_rsp *rsp;
403 struct app_pipeline_routing_route *entry;
405 /* Check input arguments */
410 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
415 case PIPELINE_ROUTING_ROUTE_IPV4:
417 uint32_t depth = key->key.ipv4.depth;
421 if ((depth == 0) || (depth > 32))
424 netmask = (~0U) << (32 - depth);
425 key->key.ipv4.ip &= netmask;
434 entry = app_pipeline_routing_find_route(p, key);
438 /* Allocate and write request */
439 req = app_msg_alloc(app);
443 req->type = PIPELINE_MSG_REQ_CUSTOM;
444 req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL;
445 memcpy(&req->key, key, sizeof(*key));
447 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
452 if (rsp->status || !rsp->key_found) {
453 app_msg_free(app, rsp);
458 TAILQ_REMOVE(&p->routes, entry, node);
463 app_msg_free(app, rsp);
469 app_pipeline_routing_add_default_route(struct app_params *app,
470 uint32_t pipeline_id,
473 struct pipeline_routing *p;
475 struct pipeline_routing_route_add_default_msg_req *req;
476 struct pipeline_routing_route_add_default_msg_rsp *rsp;
478 /* Check input arguments */
482 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
486 if (port_id >= p->n_ports_out)
489 /* Allocate and write request */
490 req = app_msg_alloc(app);
494 req->type = PIPELINE_MSG_REQ_CUSTOM;
495 req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_ADD_DEFAULT;
496 req->port_id = port_id;
498 /* Send request and wait for response */
499 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
503 /* Read response and write route */
504 if (rsp->status || (rsp->entry_ptr == NULL)) {
505 app_msg_free(app, rsp);
509 p->default_route_port_id = port_id;
510 p->default_route_entry_ptr = rsp->entry_ptr;
513 p->default_route_present = 1;
516 app_msg_free(app, rsp);
522 app_pipeline_routing_delete_default_route(struct app_params *app,
523 uint32_t pipeline_id)
525 struct pipeline_routing *p;
527 struct pipeline_routing_arp_delete_default_msg_req *req;
528 struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
530 /* Check input arguments */
534 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
538 /* Allocate and write request */
539 req = app_msg_alloc(app);
543 req->type = PIPELINE_MSG_REQ_CUSTOM;
544 req->subtype = PIPELINE_ROUTING_MSG_REQ_ROUTE_DEL_DEFAULT;
546 /* Send request and wait for response */
547 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
551 /* Read response and write route */
553 app_msg_free(app, rsp);
558 p->default_route_present = 0;
561 app_msg_free(app, rsp);
567 app_pipeline_routing_arp_ls(struct app_params *app, uint32_t pipeline_id)
569 struct pipeline_routing *p;
570 struct app_pipeline_routing_arp_entry *it;
572 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
576 TAILQ_FOREACH(it, &p->arp_entries, node)
579 if (p->default_arp_entry_present)
580 printf("Default entry: port %" PRIu32 " (entry ptr = %p)\n",
581 p->default_arp_entry_port_id,
582 p->default_arp_entry_ptr);
584 printf("Default: DROP\n");
590 app_pipeline_routing_add_arp_entry(struct app_params *app, uint32_t pipeline_id,
591 struct pipeline_routing_arp_key *key,
592 struct ether_addr *macaddr)
594 struct pipeline_routing *p;
596 struct pipeline_routing_arp_add_msg_req *req;
597 struct pipeline_routing_arp_add_msg_rsp *rsp;
599 struct app_pipeline_routing_arp_entry *entry;
603 /* Check input arguments */
609 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
614 case PIPELINE_ROUTING_ARP_IPV4:
616 uint32_t port_id = key->key.ipv4.port_id;
619 if (port_id >= p->n_ports_out)
628 /* Find existing entry or allocate new */
629 entry = app_pipeline_routing_find_arp_entry(p, key);
630 new_entry = (entry == NULL);
632 entry = rte_malloc(NULL, sizeof(*entry), RTE_CACHE_LINE_SIZE);
638 /* Message buffer allocation */
639 req = app_msg_alloc(app);
646 req->type = PIPELINE_MSG_REQ_CUSTOM;
647 req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD;
648 memcpy(&req->key, key, sizeof(*key));
649 ether_addr_copy(macaddr, &req->macaddr);
651 /* Send request and wait for response */
652 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
659 /* Read response and write entry */
661 (rsp->entry_ptr == NULL) ||
662 ((new_entry == 0) && (rsp->key_found == 0)) ||
663 ((new_entry == 1) && (rsp->key_found == 1))) {
664 app_msg_free(app, rsp);
670 memcpy(&entry->key, key, sizeof(*key));
671 ether_addr_copy(macaddr, &entry->macaddr);
672 entry->entry_ptr = rsp->entry_ptr;
676 TAILQ_INSERT_TAIL(&p->arp_entries, entry, node);
680 print_arp_entry(entry);
682 /* Message buffer free */
683 app_msg_free(app, rsp);
688 app_pipeline_routing_delete_arp_entry(struct app_params *app,
689 uint32_t pipeline_id,
690 struct pipeline_routing_arp_key *key)
692 struct pipeline_routing *p;
694 struct pipeline_routing_arp_delete_msg_req *req;
695 struct pipeline_routing_arp_delete_msg_rsp *rsp;
697 struct app_pipeline_routing_arp_entry *entry;
699 /* Check input arguments */
704 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
709 case PIPELINE_ROUTING_ARP_IPV4:
711 uint32_t port_id = key->key.ipv4.port_id;
714 if (port_id >= p->n_ports_out)
724 entry = app_pipeline_routing_find_arp_entry(p, key);
728 /* Allocate and write request */
729 req = app_msg_alloc(app);
733 req->type = PIPELINE_MSG_REQ_CUSTOM;
734 req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL;
735 memcpy(&req->key, key, sizeof(*key));
737 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
742 if (rsp->status || !rsp->key_found) {
743 app_msg_free(app, rsp);
748 TAILQ_REMOVE(&p->arp_entries, entry, node);
753 app_msg_free(app, rsp);
759 app_pipeline_routing_add_default_arp_entry(struct app_params *app,
760 uint32_t pipeline_id,
763 struct pipeline_routing *p;
765 struct pipeline_routing_arp_add_default_msg_req *req;
766 struct pipeline_routing_arp_add_default_msg_rsp *rsp;
768 /* Check input arguments */
772 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
776 if (port_id >= p->n_ports_out)
779 /* Allocate and write request */
780 req = app_msg_alloc(app);
784 req->type = PIPELINE_MSG_REQ_CUSTOM;
785 req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_ADD_DEFAULT;
786 req->port_id = port_id;
788 /* Send request and wait for response */
789 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
793 /* Read response and write entry */
794 if (rsp->status || rsp->entry_ptr == NULL) {
795 app_msg_free(app, rsp);
799 p->default_arp_entry_port_id = port_id;
800 p->default_arp_entry_ptr = rsp->entry_ptr;
803 p->default_arp_entry_present = 1;
806 app_msg_free(app, rsp);
812 app_pipeline_routing_delete_default_arp_entry(struct app_params *app,
813 uint32_t pipeline_id)
815 struct pipeline_routing *p;
817 struct pipeline_routing_arp_delete_default_msg_req *req;
818 struct pipeline_routing_arp_delete_default_msg_rsp *rsp;
820 /* Check input arguments */
824 p = app_pipeline_data_fe(app, pipeline_id, &pipeline_routing);
828 /* Allocate and write request */
829 req = app_msg_alloc(app);
833 req->type = PIPELINE_MSG_REQ_CUSTOM;
834 req->subtype = PIPELINE_ROUTING_MSG_REQ_ARP_DEL_DEFAULT;
836 /* Send request and wait for response */
837 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
841 /* Read response and write entry */
843 app_msg_free(app, rsp);
848 p->default_arp_entry_present = 0;
851 app_msg_free(app, rsp);
857 parse_labels(char *string, uint32_t *labels, uint32_t *n_labels)
859 uint32_t n_max_labels = *n_labels, count = 0;
861 /* Check for void list of labels */
862 if (strcmp(string, "<void>") == 0) {
867 /* At least one label should be present */
868 for ( ; (*string != '\0'); ) {
872 if (count >= n_max_labels)
876 if (string[0] != ':')
882 value = strtol(string, &next, 10);
887 labels[count++] = (uint32_t) value;
895 * route add (mpls = no, qinq = no, arp = no)
898 struct cmd_route_add1_result {
899 cmdline_fixed_string_t p_string;
901 cmdline_fixed_string_t route_string;
902 cmdline_fixed_string_t add_string;
905 cmdline_fixed_string_t port_string;
907 cmdline_fixed_string_t ether_string;
908 struct ether_addr macaddr;
912 cmd_route_add1_parsed(
914 __rte_unused struct cmdline *cl,
917 struct cmd_route_add1_result *params = parsed_result;
918 struct app_params *app = data;
919 struct pipeline_routing_route_key key;
920 struct pipeline_routing_route_data route_data;
924 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
925 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
926 key.key.ipv4.depth = params->depth;
928 route_data.flags = 0;
929 route_data.port_id = params->port;
930 route_data.ethernet.macaddr = params->macaddr;
932 status = app_pipeline_routing_add_route(app,
938 printf("Command failed\n");
943 static cmdline_parse_token_string_t cmd_route_add1_p_string =
944 TOKEN_STRING_INITIALIZER(struct cmd_route_add1_result, p_string,
947 static cmdline_parse_token_num_t cmd_route_add1_p =
948 TOKEN_NUM_INITIALIZER(struct cmd_route_add1_result, p, UINT32);
950 static cmdline_parse_token_string_t cmd_route_add1_route_string =
951 TOKEN_STRING_INITIALIZER(struct cmd_route_add1_result, route_string,
954 static cmdline_parse_token_string_t cmd_route_add1_add_string =
955 TOKEN_STRING_INITIALIZER(struct cmd_route_add1_result, add_string,
958 static cmdline_parse_token_ipaddr_t cmd_route_add1_ip =
959 TOKEN_IPV4_INITIALIZER(struct cmd_route_add1_result, ip);
961 static cmdline_parse_token_num_t cmd_route_add1_depth =
962 TOKEN_NUM_INITIALIZER(struct cmd_route_add1_result, depth, UINT32);
964 static cmdline_parse_token_string_t cmd_route_add1_port_string =
965 TOKEN_STRING_INITIALIZER(struct cmd_route_add1_result, port_string,
968 static cmdline_parse_token_num_t cmd_route_add1_port =
969 TOKEN_NUM_INITIALIZER(struct cmd_route_add1_result, port, UINT32);
971 static cmdline_parse_token_string_t cmd_route_add1_ether_string =
972 TOKEN_STRING_INITIALIZER(struct cmd_route_add1_result, ether_string,
975 static cmdline_parse_token_etheraddr_t cmd_route_add1_macaddr =
976 TOKEN_ETHERADDR_INITIALIZER(struct cmd_route_add1_result, macaddr);
978 static cmdline_parse_inst_t cmd_route_add1 = {
979 .f = cmd_route_add1_parsed,
981 .help_str = "Route add (mpls = no, qinq = no, arp = no)",
983 (void *)&cmd_route_add1_p_string,
984 (void *)&cmd_route_add1_p,
985 (void *)&cmd_route_add1_route_string,
986 (void *)&cmd_route_add1_add_string,
987 (void *)&cmd_route_add1_ip,
988 (void *)&cmd_route_add1_depth,
989 (void *)&cmd_route_add1_port_string,
990 (void *)&cmd_route_add1_port,
991 (void *)&cmd_route_add1_ether_string,
992 (void *)&cmd_route_add1_macaddr,
998 * route add (mpls = no, qinq = no, arp = yes)
1001 struct cmd_route_add2_result {
1002 cmdline_fixed_string_t p_string;
1004 cmdline_fixed_string_t route_string;
1005 cmdline_fixed_string_t add_string;
1006 cmdline_ipaddr_t ip;
1008 cmdline_fixed_string_t port_string;
1010 cmdline_fixed_string_t ether_string;
1011 cmdline_ipaddr_t nh_ip;
1015 cmd_route_add2_parsed(
1016 void *parsed_result,
1017 __rte_unused struct cmdline *cl,
1020 struct cmd_route_add2_result *params = parsed_result;
1021 struct app_params *app = data;
1022 struct pipeline_routing_route_key key;
1023 struct pipeline_routing_route_data route_data;
1027 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1028 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1029 key.key.ipv4.depth = params->depth;
1031 route_data.flags = PIPELINE_ROUTING_ROUTE_ARP;
1032 route_data.port_id = params->port;
1033 route_data.ethernet.ip =
1034 rte_bswap32((uint32_t) params->nh_ip.addr.ipv4.s_addr);
1036 status = app_pipeline_routing_add_route(app,
1042 printf("Command failed\n");
1047 static cmdline_parse_token_string_t cmd_route_add2_p_string =
1048 TOKEN_STRING_INITIALIZER(struct cmd_route_add2_result, p_string,
1051 static cmdline_parse_token_num_t cmd_route_add2_p =
1052 TOKEN_NUM_INITIALIZER(struct cmd_route_add2_result, p, UINT32);
1054 static cmdline_parse_token_string_t cmd_route_add2_route_string =
1055 TOKEN_STRING_INITIALIZER(struct cmd_route_add2_result, route_string,
1058 static cmdline_parse_token_string_t cmd_route_add2_add_string =
1059 TOKEN_STRING_INITIALIZER(struct cmd_route_add2_result, add_string,
1062 static cmdline_parse_token_ipaddr_t cmd_route_add2_ip =
1063 TOKEN_IPV4_INITIALIZER(struct cmd_route_add2_result, ip);
1065 static cmdline_parse_token_num_t cmd_route_add2_depth =
1066 TOKEN_NUM_INITIALIZER(struct cmd_route_add2_result, depth, UINT32);
1068 static cmdline_parse_token_string_t cmd_route_add2_port_string =
1069 TOKEN_STRING_INITIALIZER(struct cmd_route_add2_result, port_string,
1072 static cmdline_parse_token_num_t cmd_route_add2_port =
1073 TOKEN_NUM_INITIALIZER(struct cmd_route_add2_result, port, UINT32);
1075 static cmdline_parse_token_string_t cmd_route_add2_ether_string =
1076 TOKEN_STRING_INITIALIZER(struct cmd_route_add2_result, ether_string,
1079 static cmdline_parse_token_ipaddr_t cmd_route_add2_nh_ip =
1080 TOKEN_IPV4_INITIALIZER(struct cmd_route_add2_result, nh_ip);
1082 static cmdline_parse_inst_t cmd_route_add2 = {
1083 .f = cmd_route_add2_parsed,
1085 .help_str = "Route add (mpls = no, qinq = no, arp = yes)",
1087 (void *)&cmd_route_add2_p_string,
1088 (void *)&cmd_route_add2_p,
1089 (void *)&cmd_route_add2_route_string,
1090 (void *)&cmd_route_add2_add_string,
1091 (void *)&cmd_route_add2_ip,
1092 (void *)&cmd_route_add2_depth,
1093 (void *)&cmd_route_add2_port_string,
1094 (void *)&cmd_route_add2_port,
1095 (void *)&cmd_route_add2_ether_string,
1096 (void *)&cmd_route_add2_nh_ip,
1102 * route add (mpls = no, qinq = yes, arp = no)
1105 struct cmd_route_add3_result {
1106 cmdline_fixed_string_t p_string;
1108 cmdline_fixed_string_t route_string;
1109 cmdline_fixed_string_t add_string;
1110 cmdline_ipaddr_t ip;
1112 cmdline_fixed_string_t port_string;
1114 cmdline_fixed_string_t ether_string;
1115 struct ether_addr macaddr;
1116 cmdline_fixed_string_t qinq_string;
1122 cmd_route_add3_parsed(
1123 void *parsed_result,
1124 __rte_unused struct cmdline *cl,
1127 struct cmd_route_add3_result *params = parsed_result;
1128 struct app_params *app = data;
1129 struct pipeline_routing_route_key key;
1130 struct pipeline_routing_route_data route_data;
1134 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1135 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1136 key.key.ipv4.depth = params->depth;
1138 route_data.flags = PIPELINE_ROUTING_ROUTE_QINQ;
1139 route_data.port_id = params->port;
1140 route_data.ethernet.macaddr = params->macaddr;
1141 route_data.l2.qinq.svlan = params->svlan;
1142 route_data.l2.qinq.cvlan = params->cvlan;
1144 status = app_pipeline_routing_add_route(app,
1150 printf("Command failed\n");
1155 static cmdline_parse_token_string_t cmd_route_add3_p_string =
1156 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, p_string,
1159 static cmdline_parse_token_num_t cmd_route_add3_p =
1160 TOKEN_NUM_INITIALIZER(struct cmd_route_add3_result, p, UINT32);
1162 static cmdline_parse_token_string_t cmd_route_add3_route_string =
1163 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, route_string,
1166 static cmdline_parse_token_string_t cmd_route_add3_add_string =
1167 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, add_string,
1170 static cmdline_parse_token_ipaddr_t cmd_route_add3_ip =
1171 TOKEN_IPV4_INITIALIZER(struct cmd_route_add3_result, ip);
1173 static cmdline_parse_token_num_t cmd_route_add3_depth =
1174 TOKEN_NUM_INITIALIZER(struct cmd_route_add3_result, depth, UINT32);
1176 static cmdline_parse_token_string_t cmd_route_add3_port_string =
1177 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, port_string,
1180 static cmdline_parse_token_num_t cmd_route_add3_port =
1181 TOKEN_NUM_INITIALIZER(struct cmd_route_add3_result, port, UINT32);
1183 static cmdline_parse_token_string_t cmd_route_add3_ether_string =
1184 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, ether_string,
1187 static cmdline_parse_token_etheraddr_t cmd_route_add3_macaddr =
1188 TOKEN_ETHERADDR_INITIALIZER(struct cmd_route_add3_result, macaddr);
1190 static cmdline_parse_token_string_t cmd_route_add3_qinq_string =
1191 TOKEN_STRING_INITIALIZER(struct cmd_route_add3_result, qinq_string,
1194 static cmdline_parse_token_num_t cmd_route_add3_svlan =
1195 TOKEN_NUM_INITIALIZER(struct cmd_route_add3_result, svlan, UINT32);
1197 static cmdline_parse_token_num_t cmd_route_add3_cvlan =
1198 TOKEN_NUM_INITIALIZER(struct cmd_route_add3_result, cvlan, UINT32);
1200 static cmdline_parse_inst_t cmd_route_add3 = {
1201 .f = cmd_route_add3_parsed,
1203 .help_str = "Route add (qinq = yes, arp = no)",
1205 (void *)&cmd_route_add3_p_string,
1206 (void *)&cmd_route_add3_p,
1207 (void *)&cmd_route_add3_route_string,
1208 (void *)&cmd_route_add3_add_string,
1209 (void *)&cmd_route_add3_ip,
1210 (void *)&cmd_route_add3_depth,
1211 (void *)&cmd_route_add3_port_string,
1212 (void *)&cmd_route_add3_port,
1213 (void *)&cmd_route_add3_ether_string,
1214 (void *)&cmd_route_add3_macaddr,
1215 (void *)&cmd_route_add3_qinq_string,
1216 (void *)&cmd_route_add3_svlan,
1217 (void *)&cmd_route_add3_cvlan,
1223 * route add (mpls = no, qinq = yes, arp = yes)
1226 struct cmd_route_add4_result {
1227 cmdline_fixed_string_t p_string;
1229 cmdline_fixed_string_t route_string;
1230 cmdline_fixed_string_t add_string;
1231 cmdline_ipaddr_t ip;
1233 cmdline_fixed_string_t port_string;
1235 cmdline_fixed_string_t ether_string;
1236 cmdline_ipaddr_t nh_ip;
1237 cmdline_fixed_string_t qinq_string;
1243 cmd_route_add4_parsed(
1244 void *parsed_result,
1245 __rte_unused struct cmdline *cl,
1248 struct cmd_route_add4_result *params = parsed_result;
1249 struct app_params *app = data;
1250 struct pipeline_routing_route_key key;
1251 struct pipeline_routing_route_data route_data;
1255 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1256 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1257 key.key.ipv4.depth = params->depth;
1259 route_data.flags = PIPELINE_ROUTING_ROUTE_QINQ |
1260 PIPELINE_ROUTING_ROUTE_ARP;
1261 route_data.port_id = params->port;
1262 route_data.ethernet.ip =
1263 rte_bswap32((uint32_t) params->nh_ip.addr.ipv4.s_addr);
1264 route_data.l2.qinq.svlan = params->svlan;
1265 route_data.l2.qinq.cvlan = params->cvlan;
1267 status = app_pipeline_routing_add_route(app,
1273 printf("Command failed\n");
1278 static cmdline_parse_token_string_t cmd_route_add4_p_string =
1279 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, p_string,
1282 static cmdline_parse_token_num_t cmd_route_add4_p =
1283 TOKEN_NUM_INITIALIZER(struct cmd_route_add4_result, p, UINT32);
1285 static cmdline_parse_token_string_t cmd_route_add4_route_string =
1286 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, route_string,
1289 static cmdline_parse_token_string_t cmd_route_add4_add_string =
1290 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, add_string,
1293 static cmdline_parse_token_ipaddr_t cmd_route_add4_ip =
1294 TOKEN_IPV4_INITIALIZER(struct cmd_route_add4_result, ip);
1296 static cmdline_parse_token_num_t cmd_route_add4_depth =
1297 TOKEN_NUM_INITIALIZER(struct cmd_route_add4_result, depth, UINT32);
1299 static cmdline_parse_token_string_t cmd_route_add4_port_string =
1300 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, port_string,
1303 static cmdline_parse_token_num_t cmd_route_add4_port =
1304 TOKEN_NUM_INITIALIZER(struct cmd_route_add4_result, port, UINT32);
1306 static cmdline_parse_token_string_t cmd_route_add4_ether_string =
1307 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, ether_string,
1310 static cmdline_parse_token_ipaddr_t cmd_route_add4_nh_ip =
1311 TOKEN_IPV4_INITIALIZER(struct cmd_route_add4_result, nh_ip);
1313 static cmdline_parse_token_string_t cmd_route_add4_qinq_string =
1314 TOKEN_STRING_INITIALIZER(struct cmd_route_add4_result, qinq_string,
1317 static cmdline_parse_token_num_t cmd_route_add4_svlan =
1318 TOKEN_NUM_INITIALIZER(struct cmd_route_add4_result, svlan, UINT32);
1320 static cmdline_parse_token_num_t cmd_route_add4_cvlan =
1321 TOKEN_NUM_INITIALIZER(struct cmd_route_add4_result, cvlan, UINT32);
1323 static cmdline_parse_inst_t cmd_route_add4 = {
1324 .f = cmd_route_add4_parsed,
1326 .help_str = "Route add (qinq = yes, arp = yes)",
1328 (void *)&cmd_route_add4_p_string,
1329 (void *)&cmd_route_add4_p,
1330 (void *)&cmd_route_add4_route_string,
1331 (void *)&cmd_route_add4_add_string,
1332 (void *)&cmd_route_add4_ip,
1333 (void *)&cmd_route_add4_depth,
1334 (void *)&cmd_route_add4_port_string,
1335 (void *)&cmd_route_add4_port,
1336 (void *)&cmd_route_add4_ether_string,
1337 (void *)&cmd_route_add4_nh_ip,
1338 (void *)&cmd_route_add4_qinq_string,
1339 (void *)&cmd_route_add4_svlan,
1340 (void *)&cmd_route_add4_cvlan,
1346 * route add (mpls = yes, qinq = no, arp = no)
1349 struct cmd_route_add5_result {
1350 cmdline_fixed_string_t p_string;
1352 cmdline_fixed_string_t route_string;
1353 cmdline_fixed_string_t add_string;
1354 cmdline_ipaddr_t ip;
1356 cmdline_fixed_string_t port_string;
1358 cmdline_fixed_string_t ether_string;
1359 struct ether_addr macaddr;
1360 cmdline_fixed_string_t mpls_string;
1361 cmdline_fixed_string_t mpls_labels;
1365 cmd_route_add5_parsed(
1366 void *parsed_result,
1367 __rte_unused struct cmdline *cl,
1370 struct cmd_route_add5_result *params = parsed_result;
1371 struct app_params *app = data;
1372 struct pipeline_routing_route_key key;
1373 struct pipeline_routing_route_data route_data;
1374 uint32_t mpls_labels[PIPELINE_ROUTING_MPLS_LABELS_MAX];
1375 uint32_t n_labels = RTE_DIM(mpls_labels);
1379 /* Parse MPLS labels */
1380 status = parse_labels(params->mpls_labels, mpls_labels, &n_labels);
1382 printf("MPLS labels parse error\n");
1387 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1388 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1389 key.key.ipv4.depth = params->depth;
1391 route_data.flags = PIPELINE_ROUTING_ROUTE_MPLS;
1392 route_data.port_id = params->port;
1393 route_data.ethernet.macaddr = params->macaddr;
1394 for (i = 0; i < n_labels; i++)
1395 route_data.l2.mpls.labels[i] = mpls_labels[i];
1396 route_data.l2.mpls.n_labels = n_labels;
1398 status = app_pipeline_routing_add_route(app,
1404 printf("Command failed\n");
1409 static cmdline_parse_token_string_t cmd_route_add5_p_string =
1410 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, p_string,
1413 static cmdline_parse_token_num_t cmd_route_add5_p =
1414 TOKEN_NUM_INITIALIZER(struct cmd_route_add5_result, p, UINT32);
1416 static cmdline_parse_token_string_t cmd_route_add5_route_string =
1417 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, route_string,
1420 static cmdline_parse_token_string_t cmd_route_add5_add_string =
1421 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, add_string,
1424 static cmdline_parse_token_ipaddr_t cmd_route_add5_ip =
1425 TOKEN_IPV4_INITIALIZER(struct cmd_route_add5_result, ip);
1427 static cmdline_parse_token_num_t cmd_route_add5_depth =
1428 TOKEN_NUM_INITIALIZER(struct cmd_route_add5_result, depth, UINT32);
1430 static cmdline_parse_token_string_t cmd_route_add5_port_string =
1431 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, port_string,
1434 static cmdline_parse_token_num_t cmd_route_add5_port =
1435 TOKEN_NUM_INITIALIZER(struct cmd_route_add5_result, port, UINT32);
1437 static cmdline_parse_token_string_t cmd_route_add5_ether_string =
1438 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, ether_string,
1441 static cmdline_parse_token_etheraddr_t cmd_route_add5_macaddr =
1442 TOKEN_ETHERADDR_INITIALIZER(struct cmd_route_add5_result, macaddr);
1444 static cmdline_parse_token_string_t cmd_route_add5_mpls_string =
1445 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, mpls_string,
1448 static cmdline_parse_token_string_t cmd_route_add5_mpls_labels =
1449 TOKEN_STRING_INITIALIZER(struct cmd_route_add5_result, mpls_labels,
1452 static cmdline_parse_inst_t cmd_route_add5 = {
1453 .f = cmd_route_add5_parsed,
1455 .help_str = "Route add (mpls = yes, arp = no)",
1457 (void *)&cmd_route_add5_p_string,
1458 (void *)&cmd_route_add5_p,
1459 (void *)&cmd_route_add5_route_string,
1460 (void *)&cmd_route_add5_add_string,
1461 (void *)&cmd_route_add5_ip,
1462 (void *)&cmd_route_add5_depth,
1463 (void *)&cmd_route_add5_port_string,
1464 (void *)&cmd_route_add5_port,
1465 (void *)&cmd_route_add5_ether_string,
1466 (void *)&cmd_route_add5_macaddr,
1467 (void *)&cmd_route_add5_mpls_string,
1468 (void *)&cmd_route_add5_mpls_labels,
1474 * route add (mpls = yes, qinq = no, arp = yes)
1477 struct cmd_route_add6_result {
1478 cmdline_fixed_string_t p_string;
1480 cmdline_fixed_string_t route_string;
1481 cmdline_fixed_string_t add_string;
1482 cmdline_ipaddr_t ip;
1484 cmdline_fixed_string_t port_string;
1486 cmdline_fixed_string_t ether_string;
1487 cmdline_ipaddr_t nh_ip;
1488 cmdline_fixed_string_t mpls_string;
1489 cmdline_fixed_string_t mpls_labels;
1493 cmd_route_add6_parsed(
1494 void *parsed_result,
1495 __rte_unused struct cmdline *cl,
1498 struct cmd_route_add6_result *params = parsed_result;
1499 struct app_params *app = data;
1500 struct pipeline_routing_route_key key;
1501 struct pipeline_routing_route_data route_data;
1502 uint32_t mpls_labels[PIPELINE_ROUTING_MPLS_LABELS_MAX];
1503 uint32_t n_labels = RTE_DIM(mpls_labels);
1507 /* Parse MPLS labels */
1508 status = parse_labels(params->mpls_labels, mpls_labels, &n_labels);
1510 printf("MPLS labels parse error\n");
1515 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1516 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1517 key.key.ipv4.depth = params->depth;
1519 route_data.flags = PIPELINE_ROUTING_ROUTE_MPLS |
1520 PIPELINE_ROUTING_ROUTE_ARP;
1521 route_data.port_id = params->port;
1522 route_data.ethernet.ip =
1523 rte_bswap32((uint32_t) params->nh_ip.addr.ipv4.s_addr);
1524 for (i = 0; i < n_labels; i++)
1525 route_data.l2.mpls.labels[i] = mpls_labels[i];
1526 route_data.l2.mpls.n_labels = n_labels;
1528 status = app_pipeline_routing_add_route(app,
1534 printf("Command failed\n");
1539 static cmdline_parse_token_string_t cmd_route_add6_p_string =
1540 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, p_string,
1543 static cmdline_parse_token_num_t cmd_route_add6_p =
1544 TOKEN_NUM_INITIALIZER(struct cmd_route_add6_result, p, UINT32);
1546 static cmdline_parse_token_string_t cmd_route_add6_route_string =
1547 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, route_string,
1550 static cmdline_parse_token_string_t cmd_route_add6_add_string =
1551 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, add_string,
1554 static cmdline_parse_token_ipaddr_t cmd_route_add6_ip =
1555 TOKEN_IPV4_INITIALIZER(struct cmd_route_add6_result, ip);
1557 static cmdline_parse_token_num_t cmd_route_add6_depth =
1558 TOKEN_NUM_INITIALIZER(struct cmd_route_add6_result, depth, UINT32);
1560 static cmdline_parse_token_string_t cmd_route_add6_port_string =
1561 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, port_string,
1564 static cmdline_parse_token_num_t cmd_route_add6_port =
1565 TOKEN_NUM_INITIALIZER(struct cmd_route_add6_result, port, UINT32);
1567 static cmdline_parse_token_string_t cmd_route_add6_ether_string =
1568 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, ether_string,
1571 static cmdline_parse_token_ipaddr_t cmd_route_add6_nh_ip =
1572 TOKEN_IPV4_INITIALIZER(struct cmd_route_add6_result, nh_ip);
1574 static cmdline_parse_token_string_t cmd_route_add6_mpls_string =
1575 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, mpls_string,
1578 static cmdline_parse_token_string_t cmd_route_add6_mpls_labels =
1579 TOKEN_STRING_INITIALIZER(struct cmd_route_add6_result, mpls_labels,
1582 static cmdline_parse_inst_t cmd_route_add6 = {
1583 .f = cmd_route_add6_parsed,
1585 .help_str = "Route add (mpls = yes, arp = yes)",
1587 (void *)&cmd_route_add6_p_string,
1588 (void *)&cmd_route_add6_p,
1589 (void *)&cmd_route_add6_route_string,
1590 (void *)&cmd_route_add6_add_string,
1591 (void *)&cmd_route_add6_ip,
1592 (void *)&cmd_route_add6_depth,
1593 (void *)&cmd_route_add6_port_string,
1594 (void *)&cmd_route_add6_port,
1595 (void *)&cmd_route_add6_ether_string,
1596 (void *)&cmd_route_add6_nh_ip,
1597 (void *)&cmd_route_add6_mpls_string,
1598 (void *)&cmd_route_add6_mpls_labels,
1607 struct cmd_route_del_result {
1608 cmdline_fixed_string_t p_string;
1610 cmdline_fixed_string_t route_string;
1611 cmdline_fixed_string_t del_string;
1612 cmdline_ipaddr_t ip;
1617 cmd_route_del_parsed(
1618 void *parsed_result,
1619 __rte_unused struct cmdline *cl,
1622 struct cmd_route_del_result *params = parsed_result;
1623 struct app_params *app = data;
1624 struct pipeline_routing_route_key key;
1629 key.type = PIPELINE_ROUTING_ROUTE_IPV4;
1630 key.key.ipv4.ip = rte_bswap32((uint32_t) params->ip.addr.ipv4.s_addr);
1631 key.key.ipv4.depth = params->depth;
1633 status = app_pipeline_routing_delete_route(app, params->p, &key);
1636 printf("Command failed\n");
1641 static cmdline_parse_token_string_t cmd_route_del_p_string =
1642 TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, p_string,
1645 static cmdline_parse_token_num_t cmd_route_del_p =
1646 TOKEN_NUM_INITIALIZER(struct cmd_route_del_result, p, UINT32);
1648 static cmdline_parse_token_string_t cmd_route_del_route_string =
1649 TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, route_string,
1652 static cmdline_parse_token_string_t cmd_route_del_del_string =
1653 TOKEN_STRING_INITIALIZER(struct cmd_route_del_result, del_string,
1656 static cmdline_parse_token_ipaddr_t cmd_route_del_ip =
1657 TOKEN_IPV4_INITIALIZER(struct cmd_route_del_result, ip);
1659 static cmdline_parse_token_num_t cmd_route_del_depth =
1660 TOKEN_NUM_INITIALIZER(struct cmd_route_del_result, depth, UINT32);
1662 static cmdline_parse_inst_t cmd_route_del = {
1663 .f = cmd_route_del_parsed,
1665 .help_str = "Route delete",
1667 (void *)&cmd_route_del_p_string,
1668 (void *)&cmd_route_del_p,
1669 (void *)&cmd_route_del_route_string,
1670 (void *)&cmd_route_del_del_string,
1671 (void *)&cmd_route_del_ip,
1672 (void *)&cmd_route_del_depth,
1681 struct cmd_route_add_default_result {
1682 cmdline_fixed_string_t p_string;
1684 cmdline_fixed_string_t route_string;
1685 cmdline_fixed_string_t add_string;
1686 cmdline_fixed_string_t default_string;
1691 cmd_route_add_default_parsed(
1692 void *parsed_result,
1693 __attribute__((unused)) struct cmdline *cl,
1696 struct cmd_route_add_default_result *params = parsed_result;
1697 struct app_params *app = data;
1700 status = app_pipeline_routing_add_default_route(app, params->p,
1704 printf("Command failed\n");
1709 static cmdline_parse_token_string_t cmd_route_add_default_p_string =
1710 TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result, p_string,
1713 static cmdline_parse_token_num_t cmd_route_add_default_p =
1714 TOKEN_NUM_INITIALIZER(struct cmd_route_add_default_result, p, UINT32);
1716 cmdline_parse_token_string_t cmd_route_add_default_route_string =
1717 TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1718 route_string, "route");
1720 cmdline_parse_token_string_t cmd_route_add_default_add_string =
1721 TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1724 cmdline_parse_token_string_t cmd_route_add_default_default_string =
1725 TOKEN_STRING_INITIALIZER(struct cmd_route_add_default_result,
1726 default_string, "default");
1728 cmdline_parse_token_num_t cmd_route_add_default_port =
1729 TOKEN_NUM_INITIALIZER(struct cmd_route_add_default_result,
1732 cmdline_parse_inst_t cmd_route_add_default = {
1733 .f = cmd_route_add_default_parsed,
1735 .help_str = "Route default set",
1737 (void *)&cmd_route_add_default_p_string,
1738 (void *)&cmd_route_add_default_p,
1739 (void *)&cmd_route_add_default_route_string,
1740 (void *)&cmd_route_add_default_add_string,
1741 (void *)&cmd_route_add_default_default_string,
1742 (void *)&cmd_route_add_default_port,
1751 struct cmd_route_del_default_result {
1752 cmdline_fixed_string_t p_string;
1754 cmdline_fixed_string_t route_string;
1755 cmdline_fixed_string_t del_string;
1756 cmdline_fixed_string_t default_string;
1760 cmd_route_del_default_parsed(
1761 void *parsed_result,
1762 __rte_unused struct cmdline *cl,
1765 struct cmd_route_del_default_result *params = parsed_result;
1766 struct app_params *app = data;
1769 status = app_pipeline_routing_delete_default_route(app, params->p);
1772 printf("Command failed\n");
1777 static cmdline_parse_token_string_t cmd_route_del_default_p_string =
1778 TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result, p_string,
1781 static cmdline_parse_token_num_t cmd_route_del_default_p =
1782 TOKEN_NUM_INITIALIZER(struct cmd_route_del_default_result, p, UINT32);
1784 static cmdline_parse_token_string_t cmd_route_del_default_route_string =
1785 TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1786 route_string, "route");
1788 static cmdline_parse_token_string_t cmd_route_del_default_del_string =
1789 TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1792 static cmdline_parse_token_string_t cmd_route_del_default_default_string =
1793 TOKEN_STRING_INITIALIZER(struct cmd_route_del_default_result,
1794 default_string, "default");
1797 static cmdline_parse_inst_t cmd_route_del_default = {
1798 .f = cmd_route_del_default_parsed,
1800 .help_str = "Route default clear",
1802 (void *)&cmd_route_del_default_p_string,
1803 (void *)&cmd_route_del_default_p,
1804 (void *)&cmd_route_del_default_route_string,
1805 (void *)&cmd_route_del_default_del_string,
1806 (void *)&cmd_route_del_default_default_string,
1815 struct cmd_route_ls_result {
1816 cmdline_fixed_string_t p_string;
1818 cmdline_fixed_string_t route_string;
1819 cmdline_fixed_string_t ls_string;
1823 cmd_route_ls_parsed(
1824 void *parsed_result,
1825 __rte_unused struct cmdline *cl,
1828 struct cmd_route_ls_result *params = parsed_result;
1829 struct app_params *app = data;
1832 status = app_pipeline_routing_route_ls(app, params->p);
1835 printf("Command failed\n");
1840 static cmdline_parse_token_string_t cmd_route_ls_p_string =
1841 TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result, p_string, "p");
1843 static cmdline_parse_token_num_t cmd_route_ls_p =
1844 TOKEN_NUM_INITIALIZER(struct cmd_route_ls_result, p, UINT32);
1846 static cmdline_parse_token_string_t cmd_route_ls_route_string =
1847 TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result,
1848 route_string, "route");
1850 static cmdline_parse_token_string_t cmd_route_ls_ls_string =
1851 TOKEN_STRING_INITIALIZER(struct cmd_route_ls_result, ls_string,
1854 static cmdline_parse_inst_t cmd_route_ls = {
1855 .f = cmd_route_ls_parsed,
1857 .help_str = "Route list",
1859 (void *)&cmd_route_ls_p_string,
1860 (void *)&cmd_route_ls_p,
1861 (void *)&cmd_route_ls_route_string,
1862 (void *)&cmd_route_ls_ls_string,
1871 struct cmd_arp_add_result {
1872 cmdline_fixed_string_t p_string;
1874 cmdline_fixed_string_t arp_string;
1875 cmdline_fixed_string_t add_string;
1877 cmdline_ipaddr_t ip;
1878 struct ether_addr macaddr;
1884 void *parsed_result,
1885 __rte_unused struct cmdline *cl,
1888 struct cmd_arp_add_result *params = parsed_result;
1889 struct app_params *app = data;
1891 struct pipeline_routing_arp_key key;
1894 key.type = PIPELINE_ROUTING_ARP_IPV4;
1895 key.key.ipv4.port_id = params->port_id;
1896 key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
1898 status = app_pipeline_routing_add_arp_entry(app,
1904 printf("Command failed\n");
1909 static cmdline_parse_token_string_t cmd_arp_add_p_string =
1910 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, p_string,
1913 static cmdline_parse_token_num_t cmd_arp_add_p =
1914 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, p, UINT32);
1916 static cmdline_parse_token_string_t cmd_arp_add_arp_string =
1917 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, arp_string, "arp");
1919 static cmdline_parse_token_string_t cmd_arp_add_add_string =
1920 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, add_string, "add");
1922 static cmdline_parse_token_num_t cmd_arp_add_port_id =
1923 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, port_id, UINT32);
1925 static cmdline_parse_token_ipaddr_t cmd_arp_add_ip =
1926 TOKEN_IPV4_INITIALIZER(struct cmd_arp_add_result, ip);
1928 static cmdline_parse_token_etheraddr_t cmd_arp_add_macaddr =
1929 TOKEN_ETHERADDR_INITIALIZER(struct cmd_arp_add_result, macaddr);
1931 static cmdline_parse_inst_t cmd_arp_add = {
1932 .f = cmd_arp_add_parsed,
1934 .help_str = "ARP add",
1936 (void *)&cmd_arp_add_p_string,
1937 (void *)&cmd_arp_add_p,
1938 (void *)&cmd_arp_add_arp_string,
1939 (void *)&cmd_arp_add_add_string,
1940 (void *)&cmd_arp_add_port_id,
1941 (void *)&cmd_arp_add_ip,
1942 (void *)&cmd_arp_add_macaddr,
1951 struct cmd_arp_del_result {
1952 cmdline_fixed_string_t p_string;
1954 cmdline_fixed_string_t arp_string;
1955 cmdline_fixed_string_t del_string;
1957 cmdline_ipaddr_t ip;
1962 void *parsed_result,
1963 __rte_unused struct cmdline *cl,
1966 struct cmd_arp_del_result *params = parsed_result;
1967 struct app_params *app = data;
1969 struct pipeline_routing_arp_key key;
1972 key.type = PIPELINE_ROUTING_ARP_IPV4;
1973 key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
1974 key.key.ipv4.port_id = params->port_id;
1976 status = app_pipeline_routing_delete_arp_entry(app, params->p, &key);
1979 printf("Command failed\n");
1984 static cmdline_parse_token_string_t cmd_arp_del_p_string =
1985 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, p_string,
1988 static cmdline_parse_token_num_t cmd_arp_del_p =
1989 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, p, UINT32);
1991 static cmdline_parse_token_string_t cmd_arp_del_arp_string =
1992 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arp");
1994 static cmdline_parse_token_string_t cmd_arp_del_del_string =
1995 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, del_string, "del");
1997 static cmdline_parse_token_num_t cmd_arp_del_port_id =
1998 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, port_id, UINT32);
2000 static cmdline_parse_token_ipaddr_t cmd_arp_del_ip =
2001 TOKEN_IPV4_INITIALIZER(struct cmd_arp_del_result, ip);
2003 static cmdline_parse_inst_t cmd_arp_del = {
2004 .f = cmd_arp_del_parsed,
2006 .help_str = "ARP delete",
2008 (void *)&cmd_arp_del_p_string,
2009 (void *)&cmd_arp_del_p,
2010 (void *)&cmd_arp_del_arp_string,
2011 (void *)&cmd_arp_del_del_string,
2012 (void *)&cmd_arp_del_port_id,
2013 (void *)&cmd_arp_del_ip,
2022 struct cmd_arp_add_default_result {
2023 cmdline_fixed_string_t p_string;
2025 cmdline_fixed_string_t arp_string;
2026 cmdline_fixed_string_t add_string;
2027 cmdline_fixed_string_t default_string;
2032 cmd_arp_add_default_parsed(
2033 void *parsed_result,
2034 __rte_unused struct cmdline *cl,
2037 struct cmd_arp_add_default_result *params = parsed_result;
2038 struct app_params *app = data;
2042 status = app_pipeline_routing_add_default_arp_entry(app,
2047 printf("Command failed\n");
2052 static cmdline_parse_token_string_t cmd_arp_add_default_p_string =
2053 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, p_string,
2056 static cmdline_parse_token_num_t cmd_arp_add_default_p =
2057 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_default_result, p, UINT32);
2059 static cmdline_parse_token_string_t cmd_arp_add_default_arp_string =
2060 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, arp_string,
2063 static cmdline_parse_token_string_t cmd_arp_add_default_add_string =
2064 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result, add_string,
2067 static cmdline_parse_token_string_t cmd_arp_add_default_default_string =
2068 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_default_result,
2069 default_string, "default");
2071 static cmdline_parse_token_num_t cmd_arp_add_default_port_id =
2072 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_default_result, port_id,
2075 static cmdline_parse_inst_t cmd_arp_add_default = {
2076 .f = cmd_arp_add_default_parsed,
2078 .help_str = "ARP add default",
2080 (void *)&cmd_arp_add_default_p_string,
2081 (void *)&cmd_arp_add_default_p,
2082 (void *)&cmd_arp_add_default_arp_string,
2083 (void *)&cmd_arp_add_default_add_string,
2084 (void *)&cmd_arp_add_default_default_string,
2085 (void *)&cmd_arp_add_default_port_id,
2094 struct cmd_arp_del_default_result {
2095 cmdline_fixed_string_t p_string;
2097 cmdline_fixed_string_t arp_string;
2098 cmdline_fixed_string_t del_string;
2099 cmdline_fixed_string_t default_string;
2103 cmd_arp_del_default_parsed(
2104 void *parsed_result,
2105 __rte_unused struct cmdline *cl,
2108 struct cmd_arp_del_default_result *params = parsed_result;
2109 struct app_params *app = data;
2113 status = app_pipeline_routing_delete_default_arp_entry(app, params->p);
2116 printf("Command failed\n");
2121 static cmdline_parse_token_string_t cmd_arp_del_default_p_string =
2122 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, p_string,
2125 static cmdline_parse_token_num_t cmd_arp_del_default_p =
2126 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_default_result, p, UINT32);
2128 static cmdline_parse_token_string_t cmd_arp_del_default_arp_string =
2129 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, arp_string,
2132 static cmdline_parse_token_string_t cmd_arp_del_default_del_string =
2133 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result, del_string,
2136 static cmdline_parse_token_string_t cmd_arp_del_default_default_string =
2137 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_default_result,
2138 default_string, "default");
2140 static cmdline_parse_inst_t cmd_arp_del_default = {
2141 .f = cmd_arp_del_default_parsed,
2143 .help_str = "ARP delete default",
2145 (void *)&cmd_arp_del_default_p_string,
2146 (void *)&cmd_arp_del_default_p,
2147 (void *)&cmd_arp_del_default_arp_string,
2148 (void *)&cmd_arp_del_default_del_string,
2149 (void *)&cmd_arp_del_default_default_string,
2158 struct cmd_arp_ls_result {
2159 cmdline_fixed_string_t p_string;
2161 cmdline_fixed_string_t arp_string;
2162 cmdline_fixed_string_t ls_string;
2167 void *parsed_result,
2168 __rte_unused struct cmdline *cl,
2171 struct cmd_arp_ls_result *params = parsed_result;
2172 struct app_params *app = data;
2173 struct pipeline_routing *p;
2175 p = app_pipeline_data_fe(app, params->p, &pipeline_routing);
2179 app_pipeline_routing_arp_ls(app, params->p);
2182 static cmdline_parse_token_string_t cmd_arp_ls_p_string =
2183 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, p_string,
2186 static cmdline_parse_token_num_t cmd_arp_ls_p =
2187 TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, p, UINT32);
2189 static cmdline_parse_token_string_t cmd_arp_ls_arp_string =
2190 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
2193 static cmdline_parse_token_string_t cmd_arp_ls_ls_string =
2194 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, ls_string,
2197 static cmdline_parse_inst_t cmd_arp_ls = {
2198 .f = cmd_arp_ls_parsed,
2200 .help_str = "ARP list",
2202 (void *)&cmd_arp_ls_p_string,
2203 (void *)&cmd_arp_ls_p,
2204 (void *)&cmd_arp_ls_arp_string,
2205 (void *)&cmd_arp_ls_ls_string,
2210 static cmdline_parse_ctx_t pipeline_cmds[] = {
2211 (cmdline_parse_inst_t *)&cmd_route_add1,
2212 (cmdline_parse_inst_t *)&cmd_route_add2,
2213 (cmdline_parse_inst_t *)&cmd_route_add3,
2214 (cmdline_parse_inst_t *)&cmd_route_add4,
2215 (cmdline_parse_inst_t *)&cmd_route_add5,
2216 (cmdline_parse_inst_t *)&cmd_route_add6,
2217 (cmdline_parse_inst_t *)&cmd_route_del,
2218 (cmdline_parse_inst_t *)&cmd_route_add_default,
2219 (cmdline_parse_inst_t *)&cmd_route_del_default,
2220 (cmdline_parse_inst_t *)&cmd_route_ls,
2221 (cmdline_parse_inst_t *)&cmd_arp_add,
2222 (cmdline_parse_inst_t *)&cmd_arp_del,
2223 (cmdline_parse_inst_t *)&cmd_arp_add_default,
2224 (cmdline_parse_inst_t *)&cmd_arp_del_default,
2225 (cmdline_parse_inst_t *)&cmd_arp_ls,
2229 static struct pipeline_fe_ops pipeline_routing_fe_ops = {
2230 .f_init = pipeline_routing_init,
2231 .f_free = app_pipeline_routing_free,
2232 .cmds = pipeline_cmds,
2235 struct pipeline_type pipeline_routing = {
2237 .be_ops = &pipeline_routing_be_ops,
2238 .fe_ops = &pipeline_routing_fe_ops,