2 // Copyright (c) 2017 Intel Corporation
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
17 #include <cmdline_parse.h>
18 #include <cmdline_parse_num.h>
19 #include <cmdline_parse_string.h>
20 #include <cmdline_parse_ipaddr.h>
21 #include <cmdline_parse_etheraddr.h>
24 #include "pipeline_common_fe.h"
25 #include "pipeline_arpicmp_be.h"
26 #include "pipeline_arpicmp.h"
27 #include "vnf_common.h"
30 #include "vnf_common.h"
37 #include <rte_string_fns.h>
39 uint16_t verbose_level = 1; /**< should be Silent by default. */
40 uint16_t nb_pkt_per_burst = DEF_PKT_BURST; /**< Number of packets per burst. */
43 * Work-around of a compilation error with ICC on invocations of the
44 * rte_be_to_cpu_16() function.
47 #define RTE_BE_TO_CPU_16(be_16_v) rte_be_to_cpu_16((be_16_v))
48 #define RTE_CPU_TO_BE_16(cpu_16_v) rte_cpu_to_be_16((cpu_16_v))
50 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
51 #define RTE_BE_TO_CPU_16(be_16_v) (be_16_v)
52 #define RTE_CPU_TO_BE_16(cpu_16_v) (cpu_16_v)
54 #define RTE_BE_TO_CPU_16(be_16_v) \
55 ((uint16_t) ((((be_16_v) & 0xFF) << 8) | ((be_16_v) >> 8)))
56 #define RTE_CPU_TO_BE_16(cpu_16_v) \
57 ((uint16_t) ((((cpu_16_v) & 0xFF) << 8) | ((cpu_16_v) >> 8)))
65 struct cmd_arp_add_result {
66 cmdline_fixed_string_t p_string;
68 cmdline_fixed_string_t arpadd_string;
71 struct ether_addr macaddr;
76 cmd_arp_add_parsed(void *parsed_result,
77 __rte_unused struct cmdline *cl, __rte_unused void *data)
79 struct cmd_arp_add_result *params = parsed_result;
83 struct pipeline_arp_icmp_arp_key key;
84 key.type = PIPELINE_ARP_ICMP_ARP_IPV4;
85 key.key.ipv4.port_id = params->port_id;
86 key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
87 populate_arp_entry(&req->macaddr, rte_bswap32(req->key.key.ipv4.ip),
88 req->key.key.ipv4.port_id);
90 if (params->ip.family == AF_INET) {
91 populate_arp_entry(¶ms->macaddr,
92 rte_cpu_to_be_32(params->ip.addr.
98 memcpy(ipv6, params->ip.addr.ipv6.s6_addr, 16);
99 populate_nd_entry(¶ms->macaddr, ipv6, params->port_id
107 static cmdline_parse_token_string_t cmd_arp_add_p_string =
108 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, p_string,
111 static cmdline_parse_token_num_t cmd_arp_add_p =
112 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, p, UINT32);
114 static cmdline_parse_token_string_t cmd_arp_add_arp_string =
115 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, arpadd_string, "arpadd");
117 static cmdline_parse_token_num_t cmd_arp_add_port_id =
118 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, port_id, UINT32);
120 static cmdline_parse_token_ipaddr_t cmd_arp_add_ip =
121 TOKEN_IPADDR_INITIALIZER(struct cmd_arp_add_result, ip);
123 static cmdline_parse_token_etheraddr_t cmd_arp_add_macaddr =
124 TOKEN_ETHERADDR_INITIALIZER(struct cmd_arp_add_result, macaddr);
126 static cmdline_parse_inst_t cmd_arp_add = {
127 .f = cmd_arp_add_parsed,
129 .help_str = "ARP add",
131 (void *)&cmd_arp_add_p_string,
132 (void *)&cmd_arp_add_p,
133 (void *)&cmd_arp_add_arp_string,
134 (void *)&cmd_arp_add_port_id,
135 (void *)&cmd_arp_add_ip,
136 (void *)&cmd_arp_add_macaddr,
145 struct cmd_arp_del_result {
146 cmdline_fixed_string_t p_string;
148 cmdline_fixed_string_t arp_string;
154 cmd_arp_del_parsed(void *parsed_result,
155 __rte_unused struct cmdline *cl, __rte_unused void *data)
157 struct cmd_arp_del_result *params = parsed_result;
161 struct pipeline_arp_icmp_arp_key key;
162 key.type = PIPELINE_ARP_ICMP_ARP_IPV4;
163 key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
164 key.key.ipv4.port_id = params->port_id;
165 remove_arp_entry(rte_bswap32(req->key.key.ipv4.ip),
166 req->key.key.ipv4.port_id);
168 struct arp_key_ipv4 arp_key;
169 arp_key.port_id = params->port_id;
170 arp_key.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
175 struct arp_entry_data *new_arp_data = retrieve_arp_entry(arp_key, STATIC_ARP);
177 if (params->ip.family == AF_INET) {
178 remove_arp_entry(new_arp_data, &arp_key);
180 memcpy(ipv6, params->ip.addr.ipv6.s6_addr, 16);
181 remove_nd_entry_ipv6(ipv6, params->port_id);
185 static cmdline_parse_token_string_t cmd_arp_del_p_string =
186 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, p_string,
189 static cmdline_parse_token_num_t cmd_arp_del_p =
190 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, p, UINT32);
192 static cmdline_parse_token_string_t cmd_arp_del_arp_string =
193 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arpdel");
195 static cmdline_parse_token_num_t cmd_arp_del_port_id =
196 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, port_id, UINT32);
198 static cmdline_parse_token_ipaddr_t cmd_arp_del_ip =
199 TOKEN_IPADDR_INITIALIZER(struct cmd_arp_del_result, ip);
201 static cmdline_parse_inst_t cmd_arp_del = {
202 .f = cmd_arp_del_parsed,
204 .help_str = "ARP delete",
206 (void *)&cmd_arp_del_p_string,
207 (void *)&cmd_arp_del_p,
208 (void *)&cmd_arp_del_arp_string,
209 (void *)&cmd_arp_del_port_id,
210 (void *)&cmd_arp_del_ip,
219 /*Re-uses delete structures*/
222 cmd_arp_req_parsed(void *parsed_result,
223 __rte_unused struct cmdline *cl, __rte_unused void *data)
225 struct cmd_arp_del_result *params = parsed_result;
226 /*struct app_params *app = data;*/
228 struct arp_key_ipv4 key;
231 /* key.type = ARP_IPV4;*/
232 /* key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);*/
233 /* key.key.ipv4.port_id = params->port_id;*/
234 key.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
235 key.port_id = params->port_id;
240 struct arp_entry_data *arp_data = retrieve_arp_entry(key, STATIC_ARP);
244 printf("ARP entry exists for ip 0x%x, port %d\n",
245 params->ip.addr.ipv4.s_addr, params->port_id);
248 /* else request an arp*/
250 printf("ARP - requesting arp for ip 0x%x, port %d\n",
251 params->ip.addr.ipv4.s_addr, params->port_id);
254 request_arp_wrap(params->port_id, params->ip.addr.ipv4.s_addr);
256 request_arp(params->port_id, params->ip.addr.ipv4.s_addr);
258 /*give pipeline number too*/
261 static cmdline_parse_token_string_t cmd_arp_req_string =
262 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arpreq");
264 static cmdline_parse_inst_t cmd_arp_req = {
265 .f = cmd_arp_req_parsed,
267 .help_str = "ARP request",
269 (void *)&cmd_arp_del_p_string,
270 (void *)&cmd_arp_del_p,
271 (void *)&cmd_arp_req_string,
272 (void *)&cmd_arp_del_port_id,
273 (void *)&cmd_arp_del_ip,
282 /*Re-uses delete structures*/
285 cmd_icmp_echo_req_parsed(void *parsed_result,
286 __rte_unused struct cmdline *cl,
287 __rte_unused void *data)
289 struct cmd_arp_del_result *params = parsed_result;
292 printf("Echo Req Handler ip %x, port %d\n",
293 params->ip.addr.ipv4.s_addr, params->port_id);
295 request_echo(params->port_id, params->ip.addr.ipv4.s_addr);
298 static cmdline_parse_token_string_t cmd_icmp_echo_req_string =
299 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "icmpecho");
301 static cmdline_parse_inst_t cmd_icmp_echo_req = {
302 .f = cmd_icmp_echo_req_parsed,
304 .help_str = "ICMP echo request",
306 (void *)&cmd_arp_del_p_string,
307 (void *)&cmd_arp_del_p,
308 (void *)&cmd_icmp_echo_req_string,
309 (void *)&cmd_arp_del_port_id,
310 (void *)&cmd_arp_del_ip,
319 struct cmd_arp_ls_result {
320 cmdline_fixed_string_t p_string;
322 cmdline_fixed_string_t arp_string;
327 cmd_arp_ls_parsed(__rte_unused void *parsed_result,
328 __rte_unused struct cmdline *cl, __rte_unused void *data)
330 struct cmd_arp_ls_result *params = parsed_result;
332 if (!params->ip_type) {
333 printf("\nARP table ...\n");
334 printf("-------------\n");
337 printf("\nND IPv6 table:\n");
338 printf("--------------\n");
343 static cmdline_parse_token_string_t cmd_arp_ls_p_string =
344 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, p_string,
347 static cmdline_parse_token_num_t cmd_arp_ls_p =
348 TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, p, UINT32);
350 static cmdline_parse_token_string_t cmd_arp_ls_arp_string =
351 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
354 static cmdline_parse_token_num_t cmd_arp_ls_ip_type =
355 TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, ip_type, UINT32);
357 static cmdline_parse_inst_t cmd_arp_ls = {
358 .f = cmd_arp_ls_parsed,
360 .help_str = "ARP list",
362 (void *)&cmd_arp_ls_p_string,
363 (void *)&cmd_arp_ls_p,
364 (void *)&cmd_arp_ls_arp_string,
365 (void *)&cmd_arp_ls_ip_type,
374 struct cmd_show_ports_info_result {
375 cmdline_fixed_string_t p_string;
377 cmdline_fixed_string_t arp_string;
381 cmd_show_ports_info_parsed(__rte_unused void *parsed_result,
382 __rte_unused struct cmdline *cl,
383 __rte_unused void *data)
388 static cmdline_parse_token_string_t cmd_show_ports_info_string =
389 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
392 static cmdline_parse_inst_t cmd_show_ports_info = {
393 .f = cmd_show_ports_info_parsed,
395 .help_str = "show ports info",
397 (void *)&cmd_arp_ls_p_string,
398 (void *)&cmd_arp_ls_p,
399 (void *)&cmd_show_ports_info_string,
405 struct cmd_arp_dbg_result {
406 cmdline_fixed_string_t arpdbg_str;
410 cmdline_parse_token_string_t cmd_arp_dbg_string =
411 TOKEN_STRING_INITIALIZER(struct cmd_arp_dbg_result, arpdbg_str,
413 cmdline_parse_token_num_t cmd_arp_dbg_flag =
414 TOKEN_NUM_INITIALIZER(struct cmd_arp_dbg_result, flag, UINT32);
419 __attribute__((unused)) struct cmdline *cl,
420 __rte_unused void *data)
422 struct cmd_arp_dbg_result *params = parsed_result;
425 set_arpdebug(params->flag);
429 printf("%s: Params is NULL",__FUNCTION__);
433 cmdline_parse_inst_t cmd_arp_dbg = {
434 .f = cmd_arp_dbg_parse,
436 .help_str = "Turn on/off(1/0) arp debug",
438 (void *)&cmd_arp_dbg_string,
439 (void *)&cmd_arp_dbg_flag,
444 struct cmd_arp_timer_result {
445 cmdline_fixed_string_t arptimer_str;
446 uint32_t arptimer_val;
449 cmdline_parse_token_string_t cmd_arp_timer_string =
450 TOKEN_STRING_INITIALIZER(struct cmd_arp_timer_result, arptimer_str,
452 cmdline_parse_token_num_t cmd_arp_timer_val =
453 TOKEN_NUM_INITIALIZER(struct cmd_arp_timer_result, arptimer_val, UINT32);
458 __attribute__((unused)) struct cmdline *cl,
459 __rte_unused void *data)
461 struct cmd_arp_timer_result *params = parsed_result;
464 set_arptimeout(params->arptimer_val);
468 printf("%s: Params is NULL",__FUNCTION__);
472 cmdline_parse_inst_t cmd_arp_timer = {
473 .f = cmd_arp_timer_parse,
475 .help_str = "Timer expiry val by def 10 sec",
477 (void *)&cmd_arp_timer_string,
478 (void *)&cmd_arp_timer_val,
485 * Forwarding of packets in I/O mode.
486 * Forward packets "as-is".
487 * This is the fastest possible forwarding operation, as it does not access
491 pkt_burst_io_forward(struct fwd_stream *fs)
493 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
497 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
500 uint64_t core_cycles;
503 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
504 start_tsc = rte_rdtsc();
508 * Receive a burst of packets and forward them.
510 nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
512 if (unlikely(nb_rx == 0))
515 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
516 fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
519 fs->rx_packets += nb_rx;
520 nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
521 fs->tx_packets += nb_tx;
523 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
524 fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
527 if (unlikely(nb_tx < nb_rx)) {
528 fs->fwd_dropped += (nb_rx - nb_tx);
530 rte_pktmbuf_free(pkts_burst[nb_tx]);
531 } while (++nb_tx < nb_rx);
534 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
535 end_tsc = rte_rdtsc();
536 core_cycles = (end_tsc - start_tsc);
537 fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
542 struct fwd_engine io_fwd_engine = {
543 .fwd_mode_name = "io",
544 .port_fwd_begin = NULL,
545 .port_fwd_end = NULL,
546 .packet_fwd = pkt_burst_io_forward,
549 static inline void print_ether_addr(
551 struct ether_addr *eth_addr)
553 char buf[ETHER_ADDR_FMT_SIZE];
554 ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
555 printf("%s%s", what, buf);
559 * Received a burst of packets.
562 pkt_burst_receive(struct fwd_stream *fs)
564 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
566 struct ether_hdr *eth_hdr;
570 uint16_t i, packet_type;
571 uint16_t is_encapsulation;
573 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
576 uint64_t core_cycles;
579 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
580 start_tsc = rte_rdtsc();
584 * Receive a burst of packets.
586 nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
588 if (unlikely(nb_rx == 0))
591 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
592 fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
595 fs->rx_packets += nb_rx;
598 * Dump each received packet if verbose_level > 0.
600 if (verbose_level > 0)
601 printf("port %u/queue %u: received %u packets\n",
602 (unsigned int) fs->rx_port,
603 (unsigned int) fs->rx_queue,
604 (unsigned int) nb_rx);
605 for (i = 0; i < nb_rx; i++) {
607 if (verbose_level == 0) {
608 rte_pktmbuf_free(mb);
611 eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
612 eth_type = RTE_BE_TO_CPU_16(eth_hdr->ether_type);
613 ol_flags = mb->ol_flags;
614 packet_type = mb->packet_type;
615 is_encapsulation = RTE_ETH_IS_TUNNEL_PKT(packet_type);
617 print_ether_addr(" src=", ð_hdr->s_addr);
618 print_ether_addr(" - dst=", ð_hdr->d_addr);
619 printf(" - type=0x%04x - length=%u - nb_segs=%d",
620 eth_type, (unsigned int) mb->pkt_len,
622 if (ol_flags & PKT_RX_RSS_HASH) {
623 printf(" - RSS hash=0x%x", (unsigned int)
625 printf(" - RSS queue=0x%x", (unsigned int)
627 } else if (ol_flags & PKT_RX_FDIR) {
628 printf(" - FDIR matched ");
629 if (ol_flags & PKT_RX_FDIR_ID)
632 else if (ol_flags & PKT_RX_FDIR_FLX)
633 printf("flex bytes=0x%08x %08x",
634 mb->hash.fdir.hi, mb->hash.fdir.lo);
636 printf("hash=0x%x ID=0x%x ",
637 mb->hash.fdir.hash, mb->hash.fdir.id);
639 if (ol_flags & PKT_RX_VLAN_PKT)
640 printf(" - VLAN tci=0x%x", mb->vlan_tci);
641 if (ol_flags & PKT_RX_QINQ_PKT)
642 printf(" - QinQ VLAN tci=0x%x, VLAN tci outer=0x%x",
643 mb->vlan_tci, mb->vlan_tci_outer);
644 if (mb->packet_type) {
647 /* (outer) L2 packet type */
648 ptype = mb->packet_type & RTE_PTYPE_L2_MASK;
650 case RTE_PTYPE_L2_ETHER:
651 printf(" - (outer) L2 type: ETHER");
653 case RTE_PTYPE_L2_ETHER_TIMESYNC:
654 printf(" - (outer) L2 type: ETHER_Timesync");
656 case RTE_PTYPE_L2_ETHER_ARP:
657 printf(" - (outer) L2 type: ETHER_ARP");
659 case RTE_PTYPE_L2_ETHER_LLDP:
660 printf(" - (outer) L2 type: ETHER_LLDP");
663 printf(" - (outer) L2 type: Unknown");
667 /* (outer) L3 packet type */
668 ptype = mb->packet_type & RTE_PTYPE_L3_MASK;
670 case RTE_PTYPE_L3_IPV4:
671 printf(" - (outer) L3 type: IPV4");
673 case RTE_PTYPE_L3_IPV4_EXT:
674 printf(" - (outer) L3 type: IPV4_EXT");
676 case RTE_PTYPE_L3_IPV6:
677 printf(" - (outer) L3 type: IPV6");
679 case RTE_PTYPE_L3_IPV4_EXT_UNKNOWN:
680 printf(" - (outer) L3 type: IPV4_EXT_UNKNOWN");
682 case RTE_PTYPE_L3_IPV6_EXT:
683 printf(" - (outer) L3 type: IPV6_EXT");
685 case RTE_PTYPE_L3_IPV6_EXT_UNKNOWN:
686 printf(" - (outer) L3 type: IPV6_EXT_UNKNOWN");
689 printf(" - (outer) L3 type: Unknown");
693 /* (outer) L4 packet type */
694 ptype = mb->packet_type & RTE_PTYPE_L4_MASK;
696 case RTE_PTYPE_L4_TCP:
697 printf(" - (outer) L4 type: TCP");
699 case RTE_PTYPE_L4_UDP:
700 printf(" - (outer) L4 type: UDP");
702 case RTE_PTYPE_L4_FRAG:
703 printf(" - (outer) L4 type: L4_FRAG");
705 case RTE_PTYPE_L4_SCTP:
706 printf(" - (outer) L4 type: SCTP");
708 case RTE_PTYPE_L4_ICMP:
709 printf(" - (outer) L4 type: ICMP");
711 case RTE_PTYPE_L4_NONFRAG:
712 printf(" - (outer) L4 type: L4_NONFRAG");
715 printf(" - (outer) L4 type: Unknown");
719 /* packet tunnel type */
720 ptype = mb->packet_type & RTE_PTYPE_TUNNEL_MASK;
722 case RTE_PTYPE_TUNNEL_IP:
723 printf(" - Tunnel type: IP");
725 case RTE_PTYPE_TUNNEL_GRE:
726 printf(" - Tunnel type: GRE");
728 case RTE_PTYPE_TUNNEL_VXLAN:
729 printf(" - Tunnel type: VXLAN");
731 case RTE_PTYPE_TUNNEL_NVGRE:
732 printf(" - Tunnel type: NVGRE");
734 case RTE_PTYPE_TUNNEL_GENEVE:
735 printf(" - Tunnel type: GENEVE");
737 case RTE_PTYPE_TUNNEL_GRENAT:
738 printf(" - Tunnel type: GRENAT");
741 printf(" - Tunnel type: Unknown");
745 /* inner L2 packet type */
746 ptype = mb->packet_type & RTE_PTYPE_INNER_L2_MASK;
748 case RTE_PTYPE_INNER_L2_ETHER:
749 printf(" - Inner L2 type: ETHER");
751 case RTE_PTYPE_INNER_L2_ETHER_VLAN:
752 printf(" - Inner L2 type: ETHER_VLAN");
755 printf(" - Inner L2 type: Unknown");
758 /* inner L3 packet type */
759 ptype = mb->packet_type & RTE_PTYPE_INNER_L3_MASK;
761 case RTE_PTYPE_INNER_L3_IPV4:
762 printf(" - Inner L3 type: IPV4");
764 case RTE_PTYPE_INNER_L3_IPV4_EXT:
765 printf(" - Inner L3 type: IPV4_EXT");
767 case RTE_PTYPE_INNER_L3_IPV6:
768 printf(" - Inner L3 type: IPV6");
770 case RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN:
771 printf(" - Inner L3 type: "
774 case RTE_PTYPE_INNER_L3_IPV6_EXT:
775 printf(" - Inner L3 type: IPV6_EXT");
777 case RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN:
778 printf(" - Inner L3 type: "
782 printf(" - Inner L3 type: Unknown");
786 /* inner L4 packet type */
787 ptype = mb->packet_type & RTE_PTYPE_INNER_L4_MASK;
789 case RTE_PTYPE_INNER_L4_TCP:
790 printf(" - Inner L4 type: TCP");
792 case RTE_PTYPE_INNER_L4_UDP:
793 printf(" - Inner L4 type: UDP");
795 case RTE_PTYPE_INNER_L4_FRAG:
796 printf(" - Inner L4 type: L4_FRAG");
798 case RTE_PTYPE_INNER_L4_SCTP:
799 printf(" - Inner L4 type: SCTP");
801 case RTE_PTYPE_INNER_L4_ICMP:
802 printf(" - Inner L4 type: ICMP");
804 case RTE_PTYPE_INNER_L4_NONFRAG:
805 printf(" - Inner L4 type: L4_NONFRAG");
808 printf(" - Inner L4 type: Unknown");
813 printf("Unknown packet type\n");
814 if (is_encapsulation) {
815 struct ipv4_hdr *ipv4_hdr;
816 struct ipv6_hdr *ipv6_hdr;
817 struct udp_hdr *udp_hdr;
822 struct vxlan_hdr *vxlan_hdr;
824 l2_len = sizeof(struct ether_hdr);
826 /* Do not support ipv4 option field */
827 if (RTE_ETH_IS_IPV4_HDR(packet_type)) {
828 l3_len = sizeof(struct ipv4_hdr);
829 ipv4_hdr = rte_pktmbuf_mtod_offset(mb,
832 l4_proto = ipv4_hdr->next_proto_id;
834 l3_len = sizeof(struct ipv6_hdr);
835 ipv6_hdr = rte_pktmbuf_mtod_offset(mb,
838 l4_proto = ipv6_hdr->proto;
840 if (l4_proto == IPPROTO_UDP) {
841 udp_hdr = rte_pktmbuf_mtod_offset(mb,
844 l4_len = sizeof(struct udp_hdr);
845 vxlan_hdr = rte_pktmbuf_mtod_offset(mb,
847 l2_len + l3_len + l4_len);
849 printf(" - VXLAN packet: packet type =%d, "
850 "Destination UDP port =%d, VNI = %d",
852 RTE_BE_TO_CPU_16(udp_hdr->dst_port),
854 vxlan_hdr->vx_vni) >> 8);
857 printf(" - Receive queue=0x%x", (unsigned int) fs->rx_queue);
863 for (rxf = 0; rxf < sizeof(mb->ol_flags) * 8; rxf++) {
864 if ((ol_flags & (1ULL << rxf)) == 0)
866 name = rte_get_rx_ol_flag_name(1ULL << rxf);
869 printf(" %s\n", name);
872 rte_pktmbuf_free(mb);
875 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
876 end_tsc = rte_rdtsc();
877 core_cycles = (end_tsc - start_tsc);
878 fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
882 struct fwd_engine rx_only_engine = {
883 .fwd_mode_name = "rxonly",
884 .port_fwd_begin = NULL,
885 .port_fwd_end = NULL,
886 .packet_fwd = pkt_burst_receive,
889 /* *** SET FORWARDING MODE *** */
890 struct cmd_set_fwd_mode_result {
891 cmdline_fixed_string_t set;
892 cmdline_fixed_string_t fwd;
893 cmdline_fixed_string_t mode;
897 * Forwarding engines.
899 struct fwd_engine *fwd_engines[] = {
903 &mac_retry_fwd_engine,
912 #ifdef RTE_LIBRTE_IEEE1588
913 &ieee1588_fwd_engine,
919 struct fwd_engine *cur_fwd_eng = &io_fwd_engine; /**< IO mode by default. */
921 void set_pkt_forwarding_mode(const char *fwd_mode_name)
923 struct fwd_engine *fwd_eng;
927 while ((fwd_eng = fwd_engines[i]) != NULL) {
928 if (!strcmp(fwd_eng->fwd_mode_name, fwd_mode_name)) {
929 printf("Set %s packet forwarding mode\n",
931 cur_fwd_eng = fwd_eng;
936 printf("Invalid %s packet forwarding mode\n", fwd_mode_name);
939 static void cmd_set_fwd_mode_parsed(void *parsed_result,
940 __attribute__((unused)) struct cmdline *cl,
941 __attribute__((unused)) void *data)
943 struct cmd_set_fwd_mode_result *res = parsed_result;
945 set_pkt_forwarding_mode(res->mode);
948 cmdline_parse_token_string_t cmd_setfwd_set =
949 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, set, "set");
950 cmdline_parse_token_string_t cmd_setfwd_fwd =
951 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, fwd, "fwd");
952 cmdline_parse_token_string_t cmd_setfwd_mode =
953 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode,
954 "rxonly" /* defined at init */);
956 cmdline_parse_inst_t cmd_set_fwd_mode = {
957 .f = cmd_set_fwd_mode_parsed,
959 .help_str = NULL, /* defined at init */
961 (void *)&cmd_setfwd_set,
962 (void *)&cmd_setfwd_fwd,
963 (void *)&cmd_setfwd_mode,
971 str2flowtype(char *string)
974 static const struct {
978 {"raw", RTE_ETH_FLOW_RAW},
979 {"ipv4", RTE_ETH_FLOW_IPV4},
980 {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
981 {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
982 {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
983 {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
984 {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
985 {"ipv6", RTE_ETH_FLOW_IPV6},
986 {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
987 {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
988 {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
989 {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
990 {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
991 {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
994 for (i = 0; i < RTE_DIM(flowtype_str); i++) {
995 if (!strcmp(flowtype_str[i].str, string))
996 return flowtype_str[i].type;
998 return RTE_ETH_FLOW_UNKNOWN;
1002 parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
1005 const char *p, *p0 = q_arg;
1007 unsigned long int_fld;
1008 char *str_fld[max_num];
1013 p = strchr(p0, '(');
1017 p0 = strchr(p, ')');
1022 if (size >= sizeof(s))
1025 snprintf(s, sizeof(s), "%.*s", size, p);
1026 ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
1027 if (ret < 0 || ret > max_num)
1029 for (i = 0; i < ret; i++) {
1031 int_fld = strtoul(str_fld[i], &end, 0);
1032 if (errno != 0 || *end != '\0' || int_fld > UINT8_MAX)
1034 flexbytes[i] = (uint8_t)int_fld;
1039 /* *** deal with flow director filter *** */
1040 struct cmd_flow_director_result {
1041 cmdline_fixed_string_t flow_director_filter;
1043 cmdline_fixed_string_t mode;
1044 cmdline_fixed_string_t mode_value;
1045 cmdline_fixed_string_t ops;
1046 cmdline_fixed_string_t flow;
1047 cmdline_fixed_string_t flow_type;
1048 cmdline_fixed_string_t ether;
1049 uint16_t ether_type;
1050 cmdline_fixed_string_t src;
1051 cmdline_ipaddr_t ip_src;
1053 cmdline_fixed_string_t dst;
1054 cmdline_ipaddr_t ip_dst;
1056 cmdline_fixed_string_t verify_tag;
1057 uint32_t verify_tag_value;
1058 cmdline_ipaddr_t tos;
1060 cmdline_ipaddr_t proto;
1061 uint8_t proto_value;
1062 cmdline_ipaddr_t ttl;
1064 cmdline_fixed_string_t vlan;
1065 uint16_t vlan_value;
1066 cmdline_fixed_string_t flexbytes;
1067 cmdline_fixed_string_t flexbytes_value;
1068 cmdline_fixed_string_t pf_vf;
1069 cmdline_fixed_string_t drop;
1070 cmdline_fixed_string_t queue;
1072 cmdline_fixed_string_t fd_id;
1073 uint32_t fd_id_value;
1074 cmdline_fixed_string_t mac;
1075 struct ether_addr mac_addr;
1076 cmdline_fixed_string_t tunnel;
1077 cmdline_fixed_string_t tunnel_type;
1078 cmdline_fixed_string_t tunnel_id;
1079 uint32_t tunnel_id_value;
1083 cmd_flow_director_filter_parsed(void *parsed_result,
1084 __attribute__((unused)) struct cmdline *cl,
1085 __attribute__((unused)) void *data)
1087 struct cmd_flow_director_result *res = parsed_result;
1088 struct rte_eth_fdir_filter entry;
1089 uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
1091 unsigned long vf_id;
1095 printf("Hash Filter is already Defined !\n");
1096 printf("Please undefine HWLD flag and define "
1097 "FDIR_FILTER flag\n");
1101 ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
1103 printf("flow director is not supported on port %u.\n",
1107 memset(flexbytes, 0, sizeof(flexbytes));
1108 memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
1110 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
1111 if (strcmp(res->mode_value, "MAC-VLAN")) {
1112 printf("Please set mode to MAC-VLAN.\n");
1115 } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
1116 if (strcmp(res->mode_value, "Tunnel")) {
1117 printf("Please set mode to Tunnel.\n");
1121 if (strcmp(res->mode_value, "IP")) {
1122 printf("Please set mode to IP.\n");
1127 entry.input.flow_type = str2flowtype(res->flow_type);
1130 ret = parse_flexbytes(res->flexbytes_value,
1132 RTE_ETH_FDIR_MAX_FLEXLEN);
1134 printf("error: Cannot parse flexbytes input.\n");
1138 switch (entry.input.flow_type) {
1139 case RTE_ETH_FLOW_FRAG_IPV4:
1140 case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
1141 entry.input.flow.ip4_flow.proto = res->proto_value;
1142 case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
1143 case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
1144 IPV4_ADDR_TO_UINT(res->ip_dst,
1145 entry.input.flow.ip4_flow.dst_ip);
1146 IPV4_ADDR_TO_UINT(res->ip_src,
1147 entry.input.flow.ip4_flow.src_ip);
1148 entry.input.flow.ip4_flow.tos = res->tos_value;
1149 entry.input.flow.ip4_flow.ttl = res->ttl_value;
1150 /* need convert to big endian. */
1151 entry.input.flow.udp4_flow.dst_port =
1152 rte_cpu_to_be_16(res->port_dst);
1153 entry.input.flow.udp4_flow.src_port =
1154 rte_cpu_to_be_16(res->port_src);
1157 case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
1158 IPV4_ADDR_TO_UINT(res->ip_dst,
1159 entry.input.flow.sctp4_flow.ip.dst_ip);
1160 IPV4_ADDR_TO_UINT(res->ip_src,
1161 entry.input.flow.sctp4_flow.ip.src_ip);
1162 entry.input.flow.ip4_flow.tos = res->tos_value;
1163 entry.input.flow.ip4_flow.ttl = res->ttl_value;
1164 /* need convert to big endian. */
1165 entry.input.flow.sctp4_flow.dst_port =
1166 rte_cpu_to_be_16(res->port_dst);
1167 entry.input.flow.sctp4_flow.src_port =
1168 rte_cpu_to_be_16(res->port_src);
1169 entry.input.flow.sctp4_flow.verify_tag =
1170 rte_cpu_to_be_32(res->verify_tag_value);
1173 case RTE_ETH_FLOW_FRAG_IPV6:
1174 case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
1175 entry.input.flow.ipv6_flow.proto = res->proto_value;
1176 case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
1177 case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
1178 IPV6_ADDR_TO_ARRAY(res->ip_dst,
1179 entry.input.flow.ipv6_flow.dst_ip);
1180 IPV6_ADDR_TO_ARRAY(res->ip_src,
1181 entry.input.flow.ipv6_flow.src_ip);
1182 entry.input.flow.ipv6_flow.tc = res->tos_value;
1183 entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
1184 /* need convert to big endian. */
1185 entry.input.flow.udp6_flow.dst_port =
1186 rte_cpu_to_be_16(res->port_dst);
1187 entry.input.flow.udp6_flow.src_port =
1188 rte_cpu_to_be_16(res->port_src);
1191 case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
1192 IPV6_ADDR_TO_ARRAY(res->ip_dst,
1193 entry.input.flow.sctp6_flow.ip.dst_ip);
1194 IPV6_ADDR_TO_ARRAY(res->ip_src,
1195 entry.input.flow.sctp6_flow.ip.src_ip);
1196 entry.input.flow.ipv6_flow.tc = res->tos_value;
1197 entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
1198 /* need convert to big endian. */
1199 entry.input.flow.sctp6_flow.dst_port =
1200 rte_cpu_to_be_16(res->port_dst);
1201 entry.input.flow.sctp6_flow.src_port =
1202 rte_cpu_to_be_16(res->port_src);
1203 entry.input.flow.sctp6_flow.verify_tag =
1204 rte_cpu_to_be_32(res->verify_tag_value);
1206 case RTE_ETH_FLOW_L2_PAYLOAD:
1207 entry.input.flow.l2_flow.ether_type =
1208 rte_cpu_to_be_16(res->ether_type);
1214 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN)
1215 (void)rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
1217 sizeof(struct ether_addr));
1219 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
1220 (void)rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
1222 sizeof(struct ether_addr));
1223 entry.input.flow.tunnel_flow.tunnel_type =
1224 str2fdir_tunneltype(res->tunnel_type);
1225 entry.input.flow.tunnel_flow.tunnel_id =
1226 rte_cpu_to_be_32(res->tunnel_id_value);
1230 (void)rte_memcpy(entry.input.flow_ext.flexbytes,
1232 RTE_ETH_FDIR_MAX_FLEXLEN);
1234 entry.input.flow_ext.vlan_tci = rte_cpu_to_be_16(res->vlan_value);
1236 entry.action.flex_off = 0; /*use 0 by default */
1237 if (!strcmp(res->drop, "drop"))
1238 entry.action.behavior = RTE_ETH_FDIR_REJECT;
1240 entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
1242 if (!strcmp(res->pf_vf, "pf"))
1243 entry.input.flow_ext.is_vf = 0;
1244 else if (!strncmp(res->pf_vf, "vf", 2)) {
1245 struct rte_eth_dev_info dev_info;
1247 memset(&dev_info, 0, sizeof(dev_info));
1248 rte_eth_dev_info_get(res->port_id, &dev_info);
1250 vf_id = strtoul(res->pf_vf + 2, &end, 10);
1251 if (errno != 0 || *end != '\0' || vf_id >= dev_info.max_vfs) {
1252 printf("invalid parameter %s.\n", res->pf_vf);
1255 entry.input.flow_ext.is_vf = 1;
1256 entry.input.flow_ext.dst_id = (uint16_t)vf_id;
1258 printf("invalid parameter %s.\n", res->pf_vf);
1261 /* set to report FD ID by default */
1262 entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
1263 entry.action.rx_queue = res->queue_id;
1264 entry.soft_id = res->fd_id_value;
1265 if (!strcmp(res->ops, "add"))
1266 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1267 RTE_ETH_FILTER_ADD, &entry);
1268 else if (!strcmp(res->ops, "del"))
1269 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1270 RTE_ETH_FILTER_DELETE, &entry);
1272 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1273 RTE_ETH_FILTER_UPDATE, &entry);
1275 printf("flow director programming error: (%s)\n",
1277 // fdir_filter_enabled = 1;
1282 cmdline_parse_token_string_t cmd_flow_director_filter =
1283 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1284 flow_director_filter, "flow_director_filter");
1286 cmdline_parse_token_num_t cmd_flow_director_port_id =
1287 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1291 cmdline_parse_token_string_t cmd_flow_director_mode =
1292 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1295 cmdline_parse_token_string_t cmd_flow_director_mode_ip =
1296 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1299 cmdline_parse_token_string_t cmd_flow_director_ops =
1300 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1301 ops, "add#del#update");
1303 cmdline_parse_token_string_t cmd_flow_director_flow =
1304 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1307 cmdline_parse_token_string_t cmd_flow_director_flow_type =
1308 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1309 flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
1310 "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload");
1312 cmdline_parse_token_string_t cmd_flow_director_src =
1313 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1315 cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
1316 TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
1318 cmdline_parse_token_num_t cmd_flow_director_port_src =
1319 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1321 cmdline_parse_token_string_t cmd_flow_director_dst =
1322 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1324 cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
1325 TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
1327 cmdline_parse_token_num_t cmd_flow_director_port_dst =
1328 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1331 cmdline_parse_token_string_t cmd_flow_director_tos =
1332 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1334 cmdline_parse_token_num_t cmd_flow_director_tos_value =
1335 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1338 cmdline_parse_token_string_t cmd_flow_director_ttl =
1339 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1341 cmdline_parse_token_num_t cmd_flow_director_ttl_value =
1342 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1345 cmdline_parse_token_string_t cmd_flow_director_vlan =
1346 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1348 cmdline_parse_token_num_t cmd_flow_director_vlan_value =
1349 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1350 vlan_value, UINT16);
1351 cmdline_parse_token_string_t cmd_flow_director_flexbytes =
1352 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1353 flexbytes, "flexbytes");
1354 cmdline_parse_token_string_t cmd_flow_director_flexbytes_value =
1355 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1356 flexbytes_value, NULL);
1357 cmdline_parse_token_string_t cmd_flow_director_drop =
1358 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1360 cmdline_parse_token_string_t cmd_flow_director_pf_vf =
1361 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1363 cmdline_parse_token_string_t cmd_flow_director_queue =
1364 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1366 cmdline_parse_token_num_t cmd_flow_director_queue_id =
1367 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1369 cmdline_parse_token_string_t cmd_flow_director_fd_id =
1370 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1372 cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
1373 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1374 fd_id_value, UINT32);
1377 cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
1378 .f = cmd_flow_director_filter_parsed,
1380 .help_str = "add or delete an udp/tcp flow director entry on NIC",
1382 (void *)&cmd_flow_director_filter,
1383 (void *)&cmd_flow_director_port_id,
1384 (void *)&cmd_flow_director_mode,
1385 (void *)&cmd_flow_director_mode_ip,
1386 (void *)&cmd_flow_director_ops,
1387 (void *)&cmd_flow_director_flow,
1388 (void *)&cmd_flow_director_flow_type,
1389 (void *)&cmd_flow_director_src,
1390 (void *)&cmd_flow_director_ip_src,
1391 (void *)&cmd_flow_director_port_src,
1392 (void *)&cmd_flow_director_dst,
1393 (void *)&cmd_flow_director_ip_dst,
1394 (void *)&cmd_flow_director_port_dst,
1395 (void *)&cmd_flow_director_tos,
1396 (void *)&cmd_flow_director_tos_value,
1397 (void *)&cmd_flow_director_ttl,
1398 (void *)&cmd_flow_director_ttl_value,
1399 (void *)&cmd_flow_director_vlan,
1400 (void *)&cmd_flow_director_vlan_value,
1401 (void *)&cmd_flow_director_flexbytes,
1402 (void *)&cmd_flow_director_flexbytes_value,
1403 (void *)&cmd_flow_director_drop,
1404 (void *)&cmd_flow_director_pf_vf,
1405 (void *)&cmd_flow_director_queue,
1406 (void *)&cmd_flow_director_queue_id,
1407 (void *)&cmd_flow_director_fd_id,
1408 (void *)&cmd_flow_director_fd_id_value,
1413 cmdline_parse_token_string_t cmd_flow_director_ether =
1414 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1416 cmdline_parse_token_num_t cmd_flow_director_ether_type =
1417 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1418 ether_type, UINT16);
1420 cmdline_parse_inst_t cmd_add_del_l2_flow_director = {
1421 .f = cmd_flow_director_filter_parsed,
1423 .help_str = "add or delete a L2 flow director entry on NIC",
1425 (void *)&cmd_flow_director_filter,
1426 (void *)&cmd_flow_director_port_id,
1427 (void *)&cmd_flow_director_mode,
1428 (void *)&cmd_flow_director_mode_ip,
1429 (void *)&cmd_flow_director_ops,
1430 (void *)&cmd_flow_director_flow,
1431 (void *)&cmd_flow_director_flow_type,
1432 (void *)&cmd_flow_director_ether,
1433 (void *)&cmd_flow_director_ether_type,
1434 (void *)&cmd_flow_director_flexbytes,
1435 (void *)&cmd_flow_director_flexbytes_value,
1436 (void *)&cmd_flow_director_drop,
1437 (void *)&cmd_flow_director_pf_vf,
1438 (void *)&cmd_flow_director_queue,
1439 (void *)&cmd_flow_director_queue_id,
1440 (void *)&cmd_flow_director_fd_id,
1441 (void *)&cmd_flow_director_fd_id_value,
1447 /* Set hash input set */
1448 struct cmd_set_hash_input_set_result {
1449 cmdline_fixed_string_t set_hash_input_set;
1451 cmdline_fixed_string_t flow_type;
1452 cmdline_fixed_string_t inset_field0;
1453 cmdline_fixed_string_t inset_field1;
1454 cmdline_fixed_string_t inset_field2;
1455 cmdline_fixed_string_t inset_field3;
1456 cmdline_fixed_string_t inset_field4;
1457 cmdline_fixed_string_t select;
1460 static enum rte_eth_input_set_field
1461 str2inset(char *string)
1465 static const struct {
1467 enum rte_eth_input_set_field inset;
1469 {"ethertype", RTE_ETH_INPUT_SET_L2_ETHERTYPE},
1470 {"ovlan", RTE_ETH_INPUT_SET_L2_OUTER_VLAN},
1471 {"ivlan", RTE_ETH_INPUT_SET_L2_INNER_VLAN},
1472 {"src-ipv4", RTE_ETH_INPUT_SET_L3_SRC_IP4},
1473 {"dst-ipv4", RTE_ETH_INPUT_SET_L3_DST_IP4},
1474 {"ipv4-tos", RTE_ETH_INPUT_SET_L3_IP4_TOS},
1475 {"ipv4-proto", RTE_ETH_INPUT_SET_L3_IP4_PROTO},
1476 {"ipv4-ttl", RTE_ETH_INPUT_SET_L3_IP4_TTL},
1477 {"src-ipv6", RTE_ETH_INPUT_SET_L3_SRC_IP6},
1478 {"dst-ipv6", RTE_ETH_INPUT_SET_L3_DST_IP6},
1479 {"ipv6-tc", RTE_ETH_INPUT_SET_L3_IP6_TC},
1480 {"ipv6-next-header", RTE_ETH_INPUT_SET_L3_IP6_NEXT_HEADER},
1481 {"ipv6-hop-limits", RTE_ETH_INPUT_SET_L3_IP6_HOP_LIMITS},
1482 {"udp-src-port", RTE_ETH_INPUT_SET_L4_UDP_SRC_PORT},
1483 {"udp-dst-port", RTE_ETH_INPUT_SET_L4_UDP_DST_PORT},
1484 {"tcp-src-port", RTE_ETH_INPUT_SET_L4_TCP_SRC_PORT},
1485 {"tcp-dst-port", RTE_ETH_INPUT_SET_L4_TCP_DST_PORT},
1486 {"sctp-src-port", RTE_ETH_INPUT_SET_L4_SCTP_SRC_PORT},
1487 {"sctp-dst-port", RTE_ETH_INPUT_SET_L4_SCTP_DST_PORT},
1488 {"sctp-veri-tag", RTE_ETH_INPUT_SET_L4_SCTP_VERIFICATION_TAG},
1489 {"udp-key", RTE_ETH_INPUT_SET_TUNNEL_L4_UDP_KEY},
1490 {"gre-key", RTE_ETH_INPUT_SET_TUNNEL_GRE_KEY},
1491 {"fld-1st", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_1ST_WORD},
1492 {"fld-2nd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_2ND_WORD},
1493 {"fld-3rd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_3RD_WORD},
1494 {"fld-4th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_4TH_WORD},
1495 {"fld-5th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_5TH_WORD},
1496 {"fld-6th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_6TH_WORD},
1497 {"fld-7th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_7TH_WORD},
1498 {"fld-8th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_8TH_WORD},
1499 {"none", RTE_ETH_INPUT_SET_NONE},
1501 for (i = 0; i < RTE_DIM(inset_table); i++) {
1502 if (!strcmp(string, inset_table[i].str))
1503 return inset_table[i].inset;
1506 return RTE_ETH_INPUT_SET_UNKNOWN;
1510 cmd_set_hash_input_set_1_parsed(void *parsed_result,
1511 __rte_unused struct cmdline *cl,
1512 __rte_unused void *data)
1514 struct cmd_set_hash_input_set_result *res = parsed_result;
1515 struct rte_eth_hash_filter_info info;
1517 if (enable_flow_dir) {
1518 printf("FDIR Filter is Defined!\n");
1519 printf("Please undefine FDIR_FILTER flag and define "
1524 memset(&info, 0, sizeof(info));
1525 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1526 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1528 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1529 info.info.input_set_conf.inset_size = 1;
1531 if (!strcmp(res->select, "select"))
1532 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1533 else if (!strcmp(res->select, "add"))
1534 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1536 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1537 RTE_ETH_FILTER_SET, &info);
1539 //hash_filter_enabled = 1;
1543 cmd_set_hash_input_set_2_parsed(void *parsed_result,
1544 __rte_unused struct cmdline *cl,
1545 __rte_unused void *data)
1547 struct cmd_set_hash_input_set_result *res = parsed_result;
1548 struct rte_eth_hash_filter_info info;
1550 if (enable_flow_dir) {
1551 printf("FDIR Filter is Defined!\n");
1552 printf("Please undefine FDIR_FILTER flag and define "
1557 memset(&info, 0, sizeof(info));
1558 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1559 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1561 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1562 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1564 info.info.input_set_conf.inset_size = 2;
1566 if (!strcmp(res->select, "select"))
1567 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1568 else if (!strcmp(res->select, "add"))
1569 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1571 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1572 RTE_ETH_FILTER_SET, &info);
1574 //hash_filter_enabled = 1;
1579 cmd_set_hash_input_set_3_parsed(void *parsed_result,
1580 __rte_unused struct cmdline *cl,
1581 __rte_unused void *data)
1583 struct cmd_set_hash_input_set_result *res = parsed_result;
1584 struct rte_eth_hash_filter_info info;
1586 memset(&info, 0, sizeof(info));
1587 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1588 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1590 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1591 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1592 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1593 info.info.input_set_conf.inset_size = 3;
1595 if (!strcmp(res->select, "select"))
1596 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1597 else if (!strcmp(res->select, "add"))
1598 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1600 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1601 RTE_ETH_FILTER_SET, &info);
1605 cmd_set_hash_input_set_4_parsed(void *parsed_result,
1606 __rte_unused struct cmdline *cl,
1607 __rte_unused void *data)
1609 struct cmd_set_hash_input_set_result *res = parsed_result;
1610 struct rte_eth_hash_filter_info info;
1612 if (enable_flow_dir) {
1613 printf("FDIR Filter is Defined!\n");
1614 printf("Please undefine FDIR_FILTER flag and define "
1619 memset(&info, 0, sizeof(info));
1620 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1621 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1623 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1624 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1625 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1626 info.info.input_set_conf.field[3] = str2inset(res->inset_field3);
1628 info.info.input_set_conf.inset_size = 4;
1629 if (!strcmp(res->select, "select"))
1630 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1631 else if (!strcmp(res->select, "add"))
1632 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1634 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1635 RTE_ETH_FILTER_SET, &info);
1636 //hash_filter_enabled = 1;
1641 cmd_set_hash_input_set_5_parsed(void *parsed_result,
1642 __rte_unused struct cmdline *cl,
1643 __rte_unused void *data)
1645 struct cmd_set_hash_input_set_result *res = parsed_result;
1646 struct rte_eth_hash_filter_info info;
1648 memset(&info, 0, sizeof(info));
1649 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1650 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1652 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1653 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1654 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1655 info.info.input_set_conf.field[3] = str2inset(res->inset_field3);
1656 info.info.input_set_conf.field[4] = str2inset(res->inset_field4);
1658 info.info.input_set_conf.inset_size = 5;
1659 if (!strcmp(res->select, "select"))
1660 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1661 else if (!strcmp(res->select, "add"))
1662 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1663 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1664 RTE_ETH_FILTER_SET, &info);
1668 cmdline_parse_token_string_t cmd_set_hash_input_set_cmd =
1669 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1670 set_hash_input_set, "set_hash_input_set");
1671 cmdline_parse_token_num_t cmd_set_hash_input_set_port_id =
1672 TOKEN_NUM_INITIALIZER(struct cmd_set_hash_input_set_result,
1674 cmdline_parse_token_string_t cmd_set_hash_input_set_flow_type =
1675 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1677 "ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
1678 "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
1680 cmdline_parse_token_string_t cmd_set_hash_input_set_field0 =
1681 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1683 "src-ipv4#src-ipv6#dst-ipv4#dst-ipv6#"
1684 "udp-src-port#udp-dst-port#tcp-src-port#tcp-dst-port#none");
1686 cmdline_parse_token_string_t cmd_set_hash_input_set_field1 =
1687 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1689 "dst-ipv4#dst-ipv6#"
1690 "udp-src-port#tcp-src-port#udp-dst-port#tcp-dst-port#none");
1692 cmdline_parse_token_string_t cmd_set_hash_input_set_field2 =
1693 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1695 "udp-src-port#tcp-src-port#none");
1697 cmdline_parse_token_string_t cmd_set_hash_input_set_field3 =
1698 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1700 "udp-dst-port#tcp-dst-port#none");
1702 cmdline_parse_token_string_t cmd_set_hash_input_set_field4 =
1703 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1704 inset_field4, "ipv4-proto#ipv6-next-header#none");
1707 cmdline_parse_token_string_t cmd_set_hash_input_set_select =
1708 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1709 select, "select#add");
1711 cmdline_parse_inst_t cmd_set_hash_input_set_1 = {
1712 .f = cmd_set_hash_input_set_1_parsed,
1714 .help_str = "set_hash_input_set_1 <port_id> "
1715 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1716 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1717 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6|"
1718 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1721 (void *)&cmd_set_hash_input_set_cmd,
1722 (void *)&cmd_set_hash_input_set_port_id,
1723 (void *)&cmd_set_hash_input_set_flow_type,
1724 (void *)&cmd_set_hash_input_set_field0,
1725 (void *)&cmd_set_hash_input_set_select,
1730 cmdline_parse_inst_t cmd_set_hash_input_set_2 = {
1731 .f = cmd_set_hash_input_set_2_parsed,
1733 .help_str = "set_hash_input_set_2 <port_id> "
1734 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other| "
1735 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1736 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6| "
1737 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1738 "udp-src-port|tcp-src-port|udp-dst-port|tcp-dst-port|none "
1741 (void *)&cmd_set_hash_input_set_cmd,
1742 (void *)&cmd_set_hash_input_set_port_id,
1743 (void *)&cmd_set_hash_input_set_flow_type,
1744 (void *)&cmd_set_hash_input_set_field0,
1745 (void *)&cmd_set_hash_input_set_field1,
1746 (void *)&cmd_set_hash_input_set_select,
1752 cmdline_parse_inst_t cmd_set_hash_input_set_3 = {
1753 .f = cmd_set_hash_input_set_3_parsed,
1755 .help_str = "set_hash_input_set_3 <port_id> "
1756 "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1757 "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1758 "ovlan|ivlan|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|"
1759 "ipv6-tc|ipv6-next-header|udp-src-port|udp-dst-port|tcp-src-port|"
1760 "tcp-dst-port|sctp-src-port|sctp-dst-port|sctp-veri-tag|udp-key|"
1761 "gre-key|fld-1st|fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|"
1762 "fld-7th|fld-8th|none "
1763 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1766 (void *)&cmd_set_hash_input_set_cmd,
1767 (void *)&cmd_set_hash_input_set_port_id,
1768 (void *)&cmd_set_hash_input_set_flow_type,
1769 (void *)&cmd_set_hash_input_set_field0,
1770 (void *)&cmd_set_hash_input_set_field1,
1771 (void *)&cmd_set_hash_input_set_field2,
1772 (void *)&cmd_set_hash_input_set_select,
1778 cmdline_parse_inst_t cmd_set_hash_input_set_4 = {
1779 .f = cmd_set_hash_input_set_4_parsed,
1781 .help_str = "set_hash_input_set_4 <port_id> "
1782 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1783 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1784 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6|"
1785 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1786 "udp-src-port|tcp-src-port|udp-dst-port|tcp-dst-port|none "
1787 "udp-src-port|tcp-src-port|dst-ipv4|none "
1788 "udp-dst-port|tcp-dst-port|none "
1791 (void *)&cmd_set_hash_input_set_cmd,
1792 (void *)&cmd_set_hash_input_set_port_id,
1793 (void *)&cmd_set_hash_input_set_flow_type,
1794 (void *)&cmd_set_hash_input_set_field0,
1795 (void *)&cmd_set_hash_input_set_field1,
1796 (void *)&cmd_set_hash_input_set_field2,
1797 (void *)&cmd_set_hash_input_set_field3,
1798 (void *)&cmd_set_hash_input_set_select,
1803 cmdline_parse_inst_t cmd_set_hash_input_set_5 = {
1804 .f = cmd_set_hash_input_set_5_parsed,
1806 .help_str = "set_hash_input_set_5 <port_id> "
1807 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1808 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1809 "src-ipv4|src-ipv6|none "
1810 "dst-ipv4|dst-ipv6|none "
1811 "udp-src-port|tcp-src-port|none "
1812 "udp-dst-port|tcp-dst-port|none "
1813 "ipv4-proto|ipv6-next-header|none "
1817 (void *)&cmd_set_hash_input_set_cmd,
1818 (void *)&cmd_set_hash_input_set_port_id,
1819 (void *)&cmd_set_hash_input_set_flow_type,
1820 (void *)&cmd_set_hash_input_set_field0,
1821 (void *)&cmd_set_hash_input_set_field1,
1822 (void *)&cmd_set_hash_input_set_field2,
1823 (void *)&cmd_set_hash_input_set_field3,
1824 (void *)&cmd_set_hash_input_set_field4,
1825 (void *)&cmd_set_hash_input_set_select,
1831 /* set hash global config */
1832 struct cmd_set_hash_global_config_result {
1833 cmdline_fixed_string_t set_hash_global_config;
1835 cmdline_fixed_string_t hash_func;
1836 cmdline_fixed_string_t flow_type;
1837 cmdline_fixed_string_t enable;
1841 cmd_set_hash_global_config_parsed(void *parsed_result,
1842 __rte_unused struct cmdline *cl,
1843 __rte_unused void *data)
1845 struct cmd_set_hash_global_config_result *res = parsed_result;
1846 struct rte_eth_hash_filter_info info;
1847 uint32_t ftype, idx, offset;
1850 if (rte_eth_dev_filter_supported(res->port_id,
1851 RTE_ETH_FILTER_HASH) < 0) {
1852 printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
1856 memset(&info, 0, sizeof(info));
1857 info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
1858 if (!strcmp(res->hash_func, "toeplitz"))
1859 info.info.global_conf.hash_func =
1860 RTE_ETH_HASH_FUNCTION_TOEPLITZ;
1861 else if (!strcmp(res->hash_func, "simple_xor"))
1862 info.info.global_conf.hash_func =
1863 RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
1864 else if (!strcmp(res->hash_func, "default"))
1865 info.info.global_conf.hash_func =
1866 RTE_ETH_HASH_FUNCTION_DEFAULT;
1868 ftype = str2flowtype(res->flow_type);
1869 idx = ftype / (CHAR_BIT * sizeof(uint32_t));
1870 offset = ftype % (CHAR_BIT * sizeof(uint32_t));
1871 info.info.global_conf.valid_bit_mask[idx] |= (1UL << offset);
1872 if (!strcmp(res->enable, "enable"))
1873 if(idx < RTE_SYM_HASH_MASK_ARRAY_SIZE)
1874 info.info.global_conf.sym_hash_enable_mask[idx] |=
1876 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1877 RTE_ETH_FILTER_SET, &info);
1879 printf("Cannot set global hash configurations by port %d\n",
1882 printf("Global hash configurations have been set "
1883 "succcessfully by port %d\n", res->port_id);
1885 cmdline_parse_token_string_t cmd_set_hash_global_config_all =
1886 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1887 set_hash_global_config, "set_hash_global_config");
1888 cmdline_parse_token_num_t cmd_set_hash_global_config_port_id =
1889 TOKEN_NUM_INITIALIZER(struct cmd_set_hash_global_config_result,
1891 cmdline_parse_token_string_t cmd_set_hash_global_config_hash_func =
1892 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1893 hash_func, "toeplitz#simple_xor#default");
1894 cmdline_parse_token_string_t cmd_set_hash_global_config_flow_type =
1895 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1897 "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#ipv6#"
1898 "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
1899 cmdline_parse_token_string_t cmd_set_hash_global_config_enable =
1900 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1901 enable, "enable#disable");
1903 cmdline_parse_inst_t cmd_set_hash_global_config = {
1904 .f = cmd_set_hash_global_config_parsed,
1906 .help_str = "set_hash_global_config port_id "
1907 "toeplitz|simple_xor|default "
1908 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
1909 "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1912 (void *)&cmd_set_hash_global_config_all,
1913 (void *)&cmd_set_hash_global_config_port_id,
1914 (void *)&cmd_set_hash_global_config_hash_func,
1915 (void *)&cmd_set_hash_global_config_flow_type,
1916 (void *)&cmd_set_hash_global_config_enable,
1921 /* *** Set symmetric hash enable per port *** */
1922 struct cmd_set_sym_hash_ena_per_port_result {
1923 cmdline_fixed_string_t set_sym_hash_ena_per_port;
1924 cmdline_fixed_string_t enable;
1929 cmd_set_sym_hash_per_port_parsed(void *parsed_result,
1930 __rte_unused struct cmdline *cl,
1931 __rte_unused void *data)
1933 struct cmd_set_sym_hash_ena_per_port_result *res = parsed_result;
1934 struct rte_eth_hash_filter_info info;
1937 if (rte_eth_dev_filter_supported(res->port_id,
1938 RTE_ETH_FILTER_HASH) < 0) {
1939 printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
1944 memset(&info, 0, sizeof(info));
1945 info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
1947 if (!strcmp(res->enable, "enable"))
1948 info.info.enable = 1;
1950 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1951 RTE_ETH_FILTER_SET, &info);
1953 printf("Cannot set symmetric hash enable per port on "
1954 "port %u\n", res->port_id);
1957 printf("Symmetric hash has been set to %s on port %u\n",
1958 res->enable, res->port_id);
1961 cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_all =
1962 TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1963 set_sym_hash_ena_per_port, "set_sym_hash_ena_per_port");
1964 cmdline_parse_token_num_t cmd_set_sym_hash_ena_per_port_port_id =
1965 TOKEN_NUM_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1967 cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_enable =
1968 TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1969 enable, "enable#disable");
1971 cmdline_parse_inst_t cmd_set_sym_hash_ena_per_port = {
1972 .f = cmd_set_sym_hash_per_port_parsed,
1974 .help_str = "set_sym_hash_ena_per_port port_id enable|disable",
1976 (void *)&cmd_set_sym_hash_ena_per_port_all,
1977 (void *)&cmd_set_sym_hash_ena_per_port_port_id,
1978 (void *)&cmd_set_sym_hash_ena_per_port_enable,
1985 app_pipeline_arpicmp_entry_dbg(struct app_params *app,
1986 uint32_t pipeline_id, uint8_t *msg)
1988 struct pipeline_arpicmp_entry_dbg_msg_req *req;
1989 struct pipeline_arpicmp_entry_dbg_msg_rsp *rsp;
1991 /* Check input arguments */
1995 /* Allocate and write request */
1996 req = app_msg_alloc(app);
2000 req->type = PIPELINE_MSG_REQ_CUSTOM;
2001 req->subtype = PIPELINE_ARPICMP_MSG_REQ_ENTRY_DBG;
2002 req->data[0] = msg[0];
2003 req->data[1] = msg[1];
2005 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
2011 app_msg_free(app, rsp);
2012 printf("Error rsp->status %d\n", rsp->status);
2017 app_msg_free(app, rsp);
2027 struct cmd_entry_dbg_result {
2028 cmdline_fixed_string_t p_string;
2030 cmdline_fixed_string_t entry_string;
2031 cmdline_fixed_string_t dbg_string;
2037 cmd_entry_dbg_parsed(void *parsed_result,
2038 __rte_unused struct cmdline *cl, void *data)
2040 struct cmd_entry_dbg_result *params = parsed_result;
2041 struct app_params *app = data;
2045 msg[0] = params->cmd;
2046 msg[1] = params->d1;
2047 status = app_pipeline_arpicmp_entry_dbg(app, params->p, msg);
2050 printf("Dbg Command failed\n");
2055 static cmdline_parse_token_string_t lb_cmd_entry_dbg_p_string =
2056 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result, p_string, "p");
2058 static cmdline_parse_token_num_t lb_cmd_entry_dbg_p =
2059 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, p, UINT32);
2061 static cmdline_parse_token_string_t lb_cmd_entry_dbg_entry_string =
2062 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result,
2063 entry_string, "txrx");
2065 static cmdline_parse_token_string_t lb_cmd_entry_dbg_dbg_string =
2066 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result, dbg_string,
2069 static cmdline_parse_token_num_t lb_cmd_entry_dbg_cmd =
2070 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, cmd, UINT8);
2072 static cmdline_parse_token_num_t lb_cmd_entry_dbg_d1 =
2073 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, d1, UINT8);
2075 static cmdline_parse_inst_t lb_cmd_entry_dbg = {
2076 .f = cmd_entry_dbg_parsed,
2078 .help_str = "ARPICMP dbg cmd",
2080 (void *)&lb_cmd_entry_dbg_p_string,
2081 (void *)&lb_cmd_entry_dbg_p,
2082 (void *)&lb_cmd_entry_dbg_entry_string,
2083 (void *)&lb_cmd_entry_dbg_dbg_string,
2084 (void *)&lb_cmd_entry_dbg_cmd,
2085 (void *)&lb_cmd_entry_dbg_d1,
2090 static cmdline_parse_ctx_t pipeline_cmds[] = {
2091 (cmdline_parse_inst_t *) &lb_cmd_entry_dbg,
2092 (cmdline_parse_inst_t *) &cmd_arp_add,
2093 (cmdline_parse_inst_t *) &cmd_arp_del,
2094 (cmdline_parse_inst_t *) &cmd_arp_req,
2095 (cmdline_parse_inst_t *) &cmd_icmp_echo_req,
2096 (cmdline_parse_inst_t *) &cmd_arp_ls,
2097 (cmdline_parse_inst_t *) &cmd_show_ports_info,
2099 (cmdline_parse_inst_t *) &cmd_set_fwd_mode,
2100 (cmdline_parse_inst_t *) &cmd_add_del_udp_flow_director,
2101 (cmdline_parse_inst_t *) &cmd_add_del_l2_flow_director,
2102 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_1,
2103 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_2,
2104 /* (cmdline_parse_inst_t *) & cmd_set_hash_input_set_3,*/
2105 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_4,
2106 /* (cmdline_parse_inst_t *) & cmd_set_hash_input_set_5,*/
2107 (cmdline_parse_inst_t *) &cmd_set_hash_global_config,
2108 (cmdline_parse_inst_t *) &cmd_set_sym_hash_ena_per_port,
2110 (cmdline_parse_inst_t *) &cmd_arp_dbg,
2111 (cmdline_parse_inst_t *) &cmd_arp_timer,
2116 static struct pipeline_fe_ops pipeline_arpicmp_fe_ops = {
2119 .cmds = pipeline_cmds,
2122 struct pipeline_type pipeline_arpicmp = {
2124 .be_ops = &pipeline_arpicmp_be_ops,
2125 .fe_ops = &pipeline_arpicmp_fe_ops,