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"
35 #include <rte_string_fns.h>
37 uint16_t verbose_level = 1; /**< should be Silent by default. */
38 uint16_t nb_pkt_per_burst = DEF_PKT_BURST; /**< Number of packets per burst. */
41 * Work-around of a compilation error with ICC on invocations of the
42 * rte_be_to_cpu_16() function.
45 #define RTE_BE_TO_CPU_16(be_16_v) rte_be_to_cpu_16((be_16_v))
46 #define RTE_CPU_TO_BE_16(cpu_16_v) rte_cpu_to_be_16((cpu_16_v))
48 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
49 #define RTE_BE_TO_CPU_16(be_16_v) (be_16_v)
50 #define RTE_CPU_TO_BE_16(cpu_16_v) (cpu_16_v)
52 #define RTE_BE_TO_CPU_16(be_16_v) \
53 ((uint16_t) ((((be_16_v) & 0xFF) << 8) | ((be_16_v) >> 8)))
54 #define RTE_CPU_TO_BE_16(cpu_16_v) \
55 ((uint16_t) ((((cpu_16_v) & 0xFF) << 8) | ((cpu_16_v) >> 8)))
63 struct cmd_arp_add_result {
64 cmdline_fixed_string_t p_string;
66 cmdline_fixed_string_t arpadd_string;
69 struct ether_addr macaddr;
73 uint16_t str2flowtype(const char *string);
74 int parse_flexbytes(const char *q_arg, uint8_t *flexbytes,
76 enum rte_eth_input_set_field str2inset(const char *string);
77 int app_pipeline_arpicmp_entry_dbg(struct app_params *app,
78 uint32_t pipeline_id, uint8_t *msg);
82 cmd_arp_add_parsed(void *parsed_result,
83 __rte_unused struct cmdline *cl, __rte_unused void *data)
85 struct cmd_arp_add_result *params = parsed_result;
89 struct pipeline_arp_icmp_arp_key key;
90 key.type = PIPELINE_ARP_ICMP_ARP_IPV4;
91 key.key.ipv4.port_id = params->port_id;
92 key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
93 populate_arp_entry(&req->macaddr, rte_bswap32(req->key.key.ipv4.ip),
94 req->key.key.ipv4.port_id);
96 if (params->ip.family == AF_INET) {
97 populate_arp_entry(¶ms->macaddr,
98 rte_cpu_to_be_32(params->ip.addr.
104 memcpy(ipv6, params->ip.addr.ipv6.s6_addr, 16);
105 populate_nd_entry(¶ms->macaddr, ipv6, params->port_id
111 static cmdline_parse_token_string_t cmd_arp_add_p_string =
112 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, p_string,
115 static cmdline_parse_token_num_t cmd_arp_add_p =
116 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, p, UINT32);
118 static cmdline_parse_token_string_t cmd_arp_add_arp_string =
119 TOKEN_STRING_INITIALIZER(struct cmd_arp_add_result, arpadd_string, "arpadd");
121 static cmdline_parse_token_num_t cmd_arp_add_port_id =
122 TOKEN_NUM_INITIALIZER(struct cmd_arp_add_result, port_id, UINT32);
124 static cmdline_parse_token_ipaddr_t cmd_arp_add_ip =
125 TOKEN_IPADDR_INITIALIZER(struct cmd_arp_add_result, ip);
127 static cmdline_parse_token_etheraddr_t cmd_arp_add_macaddr =
128 TOKEN_ETHERADDR_INITIALIZER(struct cmd_arp_add_result, macaddr);
130 static cmdline_parse_inst_t cmd_arp_add = {
131 .f = cmd_arp_add_parsed,
133 .help_str = "ARP add",
135 (void *)&cmd_arp_add_p_string,
136 (void *)&cmd_arp_add_p,
137 (void *)&cmd_arp_add_arp_string,
138 (void *)&cmd_arp_add_port_id,
139 (void *)&cmd_arp_add_ip,
140 (void *)&cmd_arp_add_macaddr,
149 struct cmd_arp_del_result {
150 cmdline_fixed_string_t p_string;
152 cmdline_fixed_string_t arp_string;
158 cmd_arp_del_parsed(void *parsed_result,
159 __rte_unused struct cmdline *cl, __rte_unused void *data)
161 struct cmd_arp_del_result *params = parsed_result;
163 if (params->ip.family == AF_INET) {
164 struct arp_key_ipv4 arp_key;
165 arp_key.port_id = params->port_id;
166 arp_key.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
170 struct arp_entry_data *new_arp_data = retrieve_arp_entry(arp_key, STATIC_ARP);
171 if(new_arp_data == NULL) {
173 printf("Retrieve arp returned NULL\n");
176 remove_arp_entry(new_arp_data, &arp_key);
178 struct nd_key_ipv6 nd_key;
179 nd_key.port_id = params->port_id;
180 memcpy(&nd_key.ipv6[0], params->ip.addr.ipv6.s6_addr, 16);
184 struct nd_entry_data *new_nd_data = retrieve_nd_entry(nd_key, STATIC_ND);
185 if(new_nd_data == NULL) {
187 printf("Retrieve ND returned NULL\n");
190 remove_nd_entry_ipv6(new_nd_data, &nd_key);
194 static cmdline_parse_token_string_t cmd_arp_del_p_string =
195 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, p_string,
198 static cmdline_parse_token_num_t cmd_arp_del_p =
199 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, p, UINT32);
201 static cmdline_parse_token_string_t cmd_arp_del_arp_string =
202 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arpdel");
204 static cmdline_parse_token_num_t cmd_arp_del_port_id =
205 TOKEN_NUM_INITIALIZER(struct cmd_arp_del_result, port_id, UINT32);
207 static cmdline_parse_token_ipaddr_t cmd_arp_del_ip =
208 TOKEN_IPADDR_INITIALIZER(struct cmd_arp_del_result, ip);
210 static cmdline_parse_inst_t cmd_arp_del = {
211 .f = cmd_arp_del_parsed,
213 .help_str = "ARP delete",
215 (void *)&cmd_arp_del_p_string,
216 (void *)&cmd_arp_del_p,
217 (void *)&cmd_arp_del_arp_string,
218 (void *)&cmd_arp_del_port_id,
219 (void *)&cmd_arp_del_ip,
228 /*Re-uses delete structures*/
231 cmd_arp_req_parsed(void *parsed_result,
232 __rte_unused struct cmdline *cl, __rte_unused void *data)
234 struct cmd_arp_del_result *params = parsed_result;
235 /*struct app_params *app = data;*/
237 struct arp_key_ipv4 key;
240 /* key.type = ARP_IPV4;*/
241 /* key.key.ipv4.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);*/
242 /* key.key.ipv4.port_id = params->port_id;*/
243 key.ip = rte_cpu_to_be_32(params->ip.addr.ipv4.s_addr);
244 key.port_id = params->port_id;
249 struct arp_entry_data *arp_data = retrieve_arp_entry(key, STATIC_ARP);
253 printf("ARP entry exists for ip 0x%x, port %d\n",
254 params->ip.addr.ipv4.s_addr, params->port_id);
257 /* else request an arp*/
259 printf("ARP - requesting arp for ip 0x%x, port %d\n",
260 params->ip.addr.ipv4.s_addr, params->port_id);
262 request_arp(params->port_id, params->ip.addr.ipv4.s_addr);
263 /*give pipeline number too*/
266 static cmdline_parse_token_string_t cmd_arp_req_string =
267 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "arpreq");
269 static cmdline_parse_inst_t cmd_arp_req = {
270 .f = cmd_arp_req_parsed,
272 .help_str = "ARP request",
274 (void *)&cmd_arp_del_p_string,
275 (void *)&cmd_arp_del_p,
276 (void *)&cmd_arp_req_string,
277 (void *)&cmd_arp_del_port_id,
278 (void *)&cmd_arp_del_ip,
287 /*Re-uses delete structures*/
290 cmd_icmp_echo_req_parsed(void *parsed_result,
291 __rte_unused struct cmdline *cl,
292 __rte_unused void *data)
294 struct cmd_arp_del_result *params = parsed_result;
297 printf("Echo Req Handler ip %x, port %d\n",
298 params->ip.addr.ipv4.s_addr, params->port_id);
300 request_echo(params->port_id, params->ip.addr.ipv4.s_addr);
303 static cmdline_parse_token_string_t cmd_icmp_echo_req_string =
304 TOKEN_STRING_INITIALIZER(struct cmd_arp_del_result, arp_string, "icmpecho");
306 static cmdline_parse_inst_t cmd_icmp_echo_req = {
307 .f = cmd_icmp_echo_req_parsed,
309 .help_str = "ICMP echo request",
311 (void *)&cmd_arp_del_p_string,
312 (void *)&cmd_arp_del_p,
313 (void *)&cmd_icmp_echo_req_string,
314 (void *)&cmd_arp_del_port_id,
315 (void *)&cmd_arp_del_ip,
324 struct cmd_arp_ls_result {
325 cmdline_fixed_string_t p_string;
327 cmdline_fixed_string_t arp_string;
332 cmd_arp_ls_parsed(__rte_unused void *parsed_result,
333 __rte_unused struct cmdline *cl, __rte_unused void *data)
335 struct cmd_arp_ls_result *params = parsed_result;
337 if (!params->ip_type) {
338 printf("\nARP table ...\n");
339 printf("-------------\n");
342 printf("\nND IPv6 table:\n");
343 printf("--------------\n");
348 static cmdline_parse_token_string_t cmd_arp_ls_p_string =
349 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, p_string,
352 static cmdline_parse_token_num_t cmd_arp_ls_p =
353 TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, p, UINT32);
355 static cmdline_parse_token_string_t cmd_arp_ls_arp_string =
356 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
359 static cmdline_parse_token_num_t cmd_arp_ls_ip_type =
360 TOKEN_NUM_INITIALIZER(struct cmd_arp_ls_result, ip_type, UINT32);
362 static cmdline_parse_inst_t cmd_arp_ls = {
363 .f = cmd_arp_ls_parsed,
365 .help_str = "ARP list",
367 (void *)&cmd_arp_ls_p_string,
368 (void *)&cmd_arp_ls_p,
369 (void *)&cmd_arp_ls_arp_string,
370 (void *)&cmd_arp_ls_ip_type,
379 struct cmd_show_ports_info_result {
380 cmdline_fixed_string_t p_string;
382 cmdline_fixed_string_t arp_string;
386 cmd_show_ports_info_parsed(__rte_unused void *parsed_result,
387 __rte_unused struct cmdline *cl,
388 __rte_unused void *data)
393 static cmdline_parse_token_string_t cmd_show_ports_info_string =
394 TOKEN_STRING_INITIALIZER(struct cmd_arp_ls_result, arp_string,
397 static cmdline_parse_inst_t cmd_show_ports_info = {
398 .f = cmd_show_ports_info_parsed,
400 .help_str = "show ports info",
402 (void *)&cmd_arp_ls_p_string,
403 (void *)&cmd_arp_ls_p,
404 (void *)&cmd_show_ports_info_string,
409 struct cmd_arp_dbg_result {
410 cmdline_fixed_string_t arpdbg_str;
414 cmdline_parse_token_string_t cmd_arp_dbg_string =
415 TOKEN_STRING_INITIALIZER(struct cmd_arp_dbg_result, arpdbg_str,
417 cmdline_parse_token_num_t cmd_arp_dbg_flag =
418 TOKEN_NUM_INITIALIZER(struct cmd_arp_dbg_result, flag, UINT32);
423 __attribute__((unused)) struct cmdline *cl,
424 __rte_unused void *data)
426 struct cmd_arp_dbg_result *params = parsed_result;
429 set_arpdebug(params->flag);
433 printf("%s: Params is NULL",__FUNCTION__);
437 cmdline_parse_inst_t cmd_arp_dbg = {
438 .f = cmd_arp_dbg_parse,
440 .help_str = "Turn on/off(1/0) arp debug",
442 (void *)&cmd_arp_dbg_string,
443 (void *)&cmd_arp_dbg_flag,
448 struct cmd_arp_timer_result {
449 cmdline_fixed_string_t arptimer_str;
450 uint32_t arptimer_val;
453 cmdline_parse_token_string_t cmd_arp_timer_string =
454 TOKEN_STRING_INITIALIZER(struct cmd_arp_timer_result, arptimer_str,
456 cmdline_parse_token_num_t cmd_arp_timer_val =
457 TOKEN_NUM_INITIALIZER(struct cmd_arp_timer_result, arptimer_val, UINT32);
462 __attribute__((unused)) struct cmdline *cl,
463 __rte_unused void *data)
465 struct cmd_arp_timer_result *params = parsed_result;
468 set_arptimeout(params->arptimer_val);
472 printf("%s: Params is NULL",__FUNCTION__);
476 cmdline_parse_inst_t cmd_arp_timer = {
477 .f = cmd_arp_timer_parse,
479 .help_str = "Timer expiry val by def 10 sec",
481 (void *)&cmd_arp_timer_string,
482 (void *)&cmd_arp_timer_val,
488 * Forwarding of packets in I/O mode.
489 * Forward packets "as-is".
490 * This is the fastest possible forwarding operation, as it does not access
494 pkt_burst_io_forward(struct fwd_stream *fs)
496 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
500 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
503 uint64_t core_cycles;
506 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
507 start_tsc = rte_rdtsc();
511 * Receive a burst of packets and forward them.
513 nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
515 if (unlikely(nb_rx == 0))
518 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
519 fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
522 fs->rx_packets += nb_rx;
523 nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
524 fs->tx_packets += nb_tx;
526 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
527 fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
530 if (unlikely(nb_tx < nb_rx)) {
531 fs->fwd_dropped += (nb_rx - nb_tx);
533 rte_pktmbuf_free(pkts_burst[nb_tx]);
534 } while (++nb_tx < nb_rx);
537 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
538 end_tsc = rte_rdtsc();
539 core_cycles = (end_tsc - start_tsc);
540 fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
545 struct fwd_engine io_fwd_engine = {
546 .fwd_mode_name = "io",
547 .port_fwd_begin = NULL,
548 .port_fwd_end = NULL,
549 .packet_fwd = pkt_burst_io_forward,
552 static inline void print_ether_addr(
554 struct ether_addr *eth_addr)
556 char buf[ETHER_ADDR_FMT_SIZE];
557 ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
558 printf("%s%s", what, buf);
562 * Received a burst of packets.
565 pkt_burst_receive(struct fwd_stream *fs)
567 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
569 struct ether_hdr *eth_hdr;
573 uint16_t i, packet_type;
574 uint16_t is_encapsulation;
576 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
579 uint64_t core_cycles;
582 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
583 start_tsc = rte_rdtsc();
587 * Receive a burst of packets.
589 nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
591 if (unlikely(nb_rx == 0))
594 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
595 fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
598 fs->rx_packets += nb_rx;
601 * Dump each received packet if verbose_level > 0.
603 if (verbose_level > 0)
604 printf("port %u/queue %u: received %u packets\n",
605 (unsigned int) fs->rx_port,
606 (unsigned int) fs->rx_queue,
607 (unsigned int) nb_rx);
608 for (i = 0; i < nb_rx; i++) {
610 if (verbose_level == 0) {
611 rte_pktmbuf_free(mb);
614 eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
615 eth_type = RTE_BE_TO_CPU_16(eth_hdr->ether_type);
616 ol_flags = mb->ol_flags;
617 packet_type = mb->packet_type;
618 is_encapsulation = RTE_ETH_IS_TUNNEL_PKT(packet_type);
620 print_ether_addr(" src=", ð_hdr->s_addr);
621 print_ether_addr(" - dst=", ð_hdr->d_addr);
622 printf(" - type=0x%04x - length=%u - nb_segs=%d",
623 eth_type, (unsigned int) mb->pkt_len,
625 if (ol_flags & PKT_RX_RSS_HASH) {
626 printf(" - RSS hash=0x%x", (unsigned int)
628 printf(" - RSS queue=0x%x", (unsigned int)
630 } else if (ol_flags & PKT_RX_FDIR) {
631 printf(" - FDIR matched ");
632 if (ol_flags & PKT_RX_FDIR_ID)
635 else if (ol_flags & PKT_RX_FDIR_FLX)
636 printf("flex bytes=0x%08x %08x",
637 mb->hash.fdir.hi, mb->hash.fdir.lo);
639 printf("hash=0x%x ID=0x%x ",
640 mb->hash.fdir.hash, mb->hash.fdir.id);
642 if (ol_flags & PKT_RX_VLAN_PKT)
643 printf(" - VLAN tci=0x%x", mb->vlan_tci);
644 if (ol_flags & PKT_RX_QINQ_PKT)
645 printf(" - QinQ VLAN tci=0x%x, VLAN tci outer=0x%x",
646 mb->vlan_tci, mb->vlan_tci_outer);
647 if (mb->packet_type) {
650 /* (outer) L2 packet type */
651 ptype = mb->packet_type & RTE_PTYPE_L2_MASK;
653 case RTE_PTYPE_L2_ETHER:
654 printf(" - (outer) L2 type: ETHER");
656 case RTE_PTYPE_L2_ETHER_TIMESYNC:
657 printf(" - (outer) L2 type: ETHER_Timesync");
659 case RTE_PTYPE_L2_ETHER_ARP:
660 printf(" - (outer) L2 type: ETHER_ARP");
662 case RTE_PTYPE_L2_ETHER_LLDP:
663 printf(" - (outer) L2 type: ETHER_LLDP");
666 printf(" - (outer) L2 type: Unknown");
670 /* (outer) L3 packet type */
671 ptype = mb->packet_type & RTE_PTYPE_L3_MASK;
673 case RTE_PTYPE_L3_IPV4:
674 printf(" - (outer) L3 type: IPV4");
676 case RTE_PTYPE_L3_IPV4_EXT:
677 printf(" - (outer) L3 type: IPV4_EXT");
679 case RTE_PTYPE_L3_IPV6:
680 printf(" - (outer) L3 type: IPV6");
682 case RTE_PTYPE_L3_IPV4_EXT_UNKNOWN:
683 printf(" - (outer) L3 type: IPV4_EXT_UNKNOWN");
685 case RTE_PTYPE_L3_IPV6_EXT:
686 printf(" - (outer) L3 type: IPV6_EXT");
688 case RTE_PTYPE_L3_IPV6_EXT_UNKNOWN:
689 printf(" - (outer) L3 type: IPV6_EXT_UNKNOWN");
692 printf(" - (outer) L3 type: Unknown");
696 /* (outer) L4 packet type */
697 ptype = mb->packet_type & RTE_PTYPE_L4_MASK;
699 case RTE_PTYPE_L4_TCP:
700 printf(" - (outer) L4 type: TCP");
702 case RTE_PTYPE_L4_UDP:
703 printf(" - (outer) L4 type: UDP");
705 case RTE_PTYPE_L4_FRAG:
706 printf(" - (outer) L4 type: L4_FRAG");
708 case RTE_PTYPE_L4_SCTP:
709 printf(" - (outer) L4 type: SCTP");
711 case RTE_PTYPE_L4_ICMP:
712 printf(" - (outer) L4 type: ICMP");
714 case RTE_PTYPE_L4_NONFRAG:
715 printf(" - (outer) L4 type: L4_NONFRAG");
718 printf(" - (outer) L4 type: Unknown");
722 /* packet tunnel type */
723 ptype = mb->packet_type & RTE_PTYPE_TUNNEL_MASK;
725 case RTE_PTYPE_TUNNEL_IP:
726 printf(" - Tunnel type: IP");
728 case RTE_PTYPE_TUNNEL_GRE:
729 printf(" - Tunnel type: GRE");
731 case RTE_PTYPE_TUNNEL_VXLAN:
732 printf(" - Tunnel type: VXLAN");
734 case RTE_PTYPE_TUNNEL_NVGRE:
735 printf(" - Tunnel type: NVGRE");
737 case RTE_PTYPE_TUNNEL_GENEVE:
738 printf(" - Tunnel type: GENEVE");
740 case RTE_PTYPE_TUNNEL_GRENAT:
741 printf(" - Tunnel type: GRENAT");
744 printf(" - Tunnel type: Unknown");
748 /* inner L2 packet type */
749 ptype = mb->packet_type & RTE_PTYPE_INNER_L2_MASK;
751 case RTE_PTYPE_INNER_L2_ETHER:
752 printf(" - Inner L2 type: ETHER");
754 case RTE_PTYPE_INNER_L2_ETHER_VLAN:
755 printf(" - Inner L2 type: ETHER_VLAN");
758 printf(" - Inner L2 type: Unknown");
761 /* inner L3 packet type */
762 ptype = mb->packet_type & RTE_PTYPE_INNER_L3_MASK;
764 case RTE_PTYPE_INNER_L3_IPV4:
765 printf(" - Inner L3 type: IPV4");
767 case RTE_PTYPE_INNER_L3_IPV4_EXT:
768 printf(" - Inner L3 type: IPV4_EXT");
770 case RTE_PTYPE_INNER_L3_IPV6:
771 printf(" - Inner L3 type: IPV6");
773 case RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN:
774 printf(" - Inner L3 type: "
777 case RTE_PTYPE_INNER_L3_IPV6_EXT:
778 printf(" - Inner L3 type: IPV6_EXT");
780 case RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN:
781 printf(" - Inner L3 type: "
785 printf(" - Inner L3 type: Unknown");
789 /* inner L4 packet type */
790 ptype = mb->packet_type & RTE_PTYPE_INNER_L4_MASK;
792 case RTE_PTYPE_INNER_L4_TCP:
793 printf(" - Inner L4 type: TCP");
795 case RTE_PTYPE_INNER_L4_UDP:
796 printf(" - Inner L4 type: UDP");
798 case RTE_PTYPE_INNER_L4_FRAG:
799 printf(" - Inner L4 type: L4_FRAG");
801 case RTE_PTYPE_INNER_L4_SCTP:
802 printf(" - Inner L4 type: SCTP");
804 case RTE_PTYPE_INNER_L4_ICMP:
805 printf(" - Inner L4 type: ICMP");
807 case RTE_PTYPE_INNER_L4_NONFRAG:
808 printf(" - Inner L4 type: L4_NONFRAG");
811 printf(" - Inner L4 type: Unknown");
816 printf("Unknown packet type\n");
817 if (is_encapsulation) {
818 struct ipv4_hdr *ipv4_hdr;
819 struct ipv6_hdr *ipv6_hdr;
820 struct udp_hdr *udp_hdr;
825 struct vxlan_hdr *vxlan_hdr;
827 l2_len = sizeof(struct ether_hdr);
829 /* Do not support ipv4 option field */
830 if (RTE_ETH_IS_IPV4_HDR(packet_type)) {
831 l3_len = sizeof(struct ipv4_hdr);
832 ipv4_hdr = rte_pktmbuf_mtod_offset(mb,
835 l4_proto = ipv4_hdr->next_proto_id;
837 l3_len = sizeof(struct ipv6_hdr);
838 ipv6_hdr = rte_pktmbuf_mtod_offset(mb,
841 l4_proto = ipv6_hdr->proto;
843 if (l4_proto == IPPROTO_UDP) {
844 udp_hdr = rte_pktmbuf_mtod_offset(mb,
847 l4_len = sizeof(struct udp_hdr);
848 vxlan_hdr = rte_pktmbuf_mtod_offset(mb,
850 l2_len + l3_len + l4_len);
852 printf(" - VXLAN packet: packet type =%d, "
853 "Destination UDP port =%d, VNI = %d",
855 RTE_BE_TO_CPU_16(udp_hdr->dst_port),
857 vxlan_hdr->vx_vni) >> 8);
860 printf(" - Receive queue=0x%x", (unsigned int) fs->rx_queue);
866 for (rxf = 0; rxf < sizeof(mb->ol_flags) * 8; rxf++) {
867 if ((ol_flags & (1ULL << rxf)) == 0)
869 name = rte_get_rx_ol_flag_name(1ULL << rxf);
872 printf(" %s\n", name);
875 rte_pktmbuf_free(mb);
878 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
879 end_tsc = rte_rdtsc();
880 core_cycles = (end_tsc - start_tsc);
881 fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
885 struct fwd_engine rx_only_engine = {
886 .fwd_mode_name = "rxonly",
887 .port_fwd_begin = NULL,
888 .port_fwd_end = NULL,
889 .packet_fwd = pkt_burst_receive,
892 /* *** SET FORWARDING MODE *** */
893 struct cmd_set_fwd_mode_result {
894 cmdline_fixed_string_t set;
895 cmdline_fixed_string_t fwd;
896 cmdline_fixed_string_t mode;
900 * Forwarding engines.
902 struct fwd_engine *fwd_engines[] = {
906 &mac_retry_fwd_engine,
915 #ifdef RTE_LIBRTE_IEEE1588
916 &ieee1588_fwd_engine,
922 struct fwd_engine *cur_fwd_eng = &io_fwd_engine; /**< IO mode by default. */
924 void set_pkt_forwarding_mode(const char *fwd_mode_name)
926 struct fwd_engine *fwd_eng;
930 while ((fwd_eng = fwd_engines[i]) != NULL) {
931 if (!strcmp(fwd_eng->fwd_mode_name, fwd_mode_name)) {
932 printf("Set %s packet forwarding mode\n",
934 cur_fwd_eng = fwd_eng;
939 printf("Invalid %s packet forwarding mode\n", fwd_mode_name);
942 static void cmd_set_fwd_mode_parsed(void *parsed_result,
943 __attribute__((unused)) struct cmdline *cl,
944 __attribute__((unused)) void *data)
946 struct cmd_set_fwd_mode_result *res = parsed_result;
948 set_pkt_forwarding_mode(res->mode);
951 cmdline_parse_token_string_t cmd_setfwd_set =
952 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, set, "set");
953 cmdline_parse_token_string_t cmd_setfwd_fwd =
954 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, fwd, "fwd");
955 cmdline_parse_token_string_t cmd_setfwd_mode =
956 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode,
957 "rxonly" /* defined at init */);
959 cmdline_parse_inst_t cmd_set_fwd_mode = {
960 .f = cmd_set_fwd_mode_parsed,
962 .help_str = NULL, /* defined at init */
964 (void *)&cmd_setfwd_set,
965 (void *)&cmd_setfwd_fwd,
966 (void *)&cmd_setfwd_mode,
973 uint16_t str2flowtype(const char *string)
976 static const struct {
980 {"raw", RTE_ETH_FLOW_RAW},
981 {"ipv4", RTE_ETH_FLOW_IPV4},
982 {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
983 {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
984 {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
985 {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
986 {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
987 {"ipv6", RTE_ETH_FLOW_IPV6},
988 {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
989 {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
990 {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
991 {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
992 {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
993 {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
996 for (i = 0; i < RTE_DIM(flowtype_str); i++) {
997 if (!strcmp(flowtype_str[i].str, string))
998 return flowtype_str[i].type;
1000 return RTE_ETH_FLOW_UNKNOWN;
1004 parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
1007 const char *p, *p0 = q_arg;
1009 unsigned long int_fld;
1010 char *str_fld[max_num];
1015 p = strchr(p0, '(');
1019 p0 = strchr(p, ')');
1024 if (size >= sizeof(s))
1027 snprintf(s, sizeof(s), "%.*s", size, p);
1028 ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
1029 if (ret < 0 || ret > max_num)
1031 for (i = 0; i < ret; i++) {
1033 int_fld = strtoul(str_fld[i], &end, 0);
1034 if (errno != 0 || *end != '\0' || int_fld > UINT8_MAX)
1036 flexbytes[i] = (uint8_t)int_fld;
1041 /* *** deal with flow director filter *** */
1042 struct cmd_flow_director_result {
1043 cmdline_fixed_string_t flow_director_filter;
1045 cmdline_fixed_string_t mode;
1046 cmdline_fixed_string_t mode_value;
1047 cmdline_fixed_string_t ops;
1048 cmdline_fixed_string_t flow;
1049 cmdline_fixed_string_t flow_type;
1050 cmdline_fixed_string_t ether;
1051 uint16_t ether_type;
1052 cmdline_fixed_string_t src;
1053 cmdline_ipaddr_t ip_src;
1055 cmdline_fixed_string_t dst;
1056 cmdline_ipaddr_t ip_dst;
1058 cmdline_fixed_string_t verify_tag;
1059 uint32_t verify_tag_value;
1060 cmdline_ipaddr_t tos;
1062 cmdline_ipaddr_t proto;
1063 uint8_t proto_value;
1064 cmdline_ipaddr_t ttl;
1066 cmdline_fixed_string_t vlan;
1067 uint16_t vlan_value;
1068 cmdline_fixed_string_t flexbytes;
1069 cmdline_fixed_string_t flexbytes_value;
1070 cmdline_fixed_string_t pf_vf;
1071 cmdline_fixed_string_t drop;
1072 cmdline_fixed_string_t queue;
1074 cmdline_fixed_string_t fd_id;
1075 uint32_t fd_id_value;
1076 cmdline_fixed_string_t mac;
1077 struct ether_addr mac_addr;
1078 cmdline_fixed_string_t tunnel;
1079 cmdline_fixed_string_t tunnel_type;
1080 cmdline_fixed_string_t tunnel_id;
1081 uint32_t tunnel_id_value;
1085 cmd_flow_director_filter_parsed(void *parsed_result,
1086 __attribute__((unused)) struct cmdline *cl,
1087 __attribute__((unused)) void *data)
1089 struct cmd_flow_director_result *res = parsed_result;
1090 struct rte_eth_fdir_filter entry;
1091 uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
1093 unsigned long vf_id;
1097 printf("Hash Filter is already Defined !\n");
1098 printf("Please undefine HWLD flag and define "
1099 "FDIR_FILTER flag\n");
1103 ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
1105 printf("flow director is not supported on port %u.\n",
1109 memset(flexbytes, 0, sizeof(flexbytes));
1110 memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
1112 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
1113 if (strcmp(res->mode_value, "MAC-VLAN")) {
1114 printf("Please set mode to MAC-VLAN.\n");
1117 } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
1118 if (strcmp(res->mode_value, "Tunnel")) {
1119 printf("Please set mode to Tunnel.\n");
1123 if (strcmp(res->mode_value, "IP")) {
1124 printf("Please set mode to IP.\n");
1129 entry.input.flow_type = str2flowtype(res->flow_type);
1132 ret = parse_flexbytes(res->flexbytes_value,
1134 RTE_ETH_FDIR_MAX_FLEXLEN);
1136 printf("error: Cannot parse flexbytes input.\n");
1140 switch (entry.input.flow_type) {
1141 case RTE_ETH_FLOW_FRAG_IPV4:
1142 case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
1143 entry.input.flow.ip4_flow.proto = res->proto_value;
1144 case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
1145 case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
1146 IPV4_ADDR_TO_UINT(res->ip_dst,
1147 entry.input.flow.ip4_flow.dst_ip);
1148 IPV4_ADDR_TO_UINT(res->ip_src,
1149 entry.input.flow.ip4_flow.src_ip);
1150 entry.input.flow.ip4_flow.tos = res->tos_value;
1151 entry.input.flow.ip4_flow.ttl = res->ttl_value;
1152 /* need convert to big endian. */
1153 entry.input.flow.udp4_flow.dst_port =
1154 rte_cpu_to_be_16(res->port_dst);
1155 entry.input.flow.udp4_flow.src_port =
1156 rte_cpu_to_be_16(res->port_src);
1159 case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
1160 IPV4_ADDR_TO_UINT(res->ip_dst,
1161 entry.input.flow.sctp4_flow.ip.dst_ip);
1162 IPV4_ADDR_TO_UINT(res->ip_src,
1163 entry.input.flow.sctp4_flow.ip.src_ip);
1164 entry.input.flow.ip4_flow.tos = res->tos_value;
1165 entry.input.flow.ip4_flow.ttl = res->ttl_value;
1166 /* need convert to big endian. */
1167 entry.input.flow.sctp4_flow.dst_port =
1168 rte_cpu_to_be_16(res->port_dst);
1169 entry.input.flow.sctp4_flow.src_port =
1170 rte_cpu_to_be_16(res->port_src);
1171 entry.input.flow.sctp4_flow.verify_tag =
1172 rte_cpu_to_be_32(res->verify_tag_value);
1175 case RTE_ETH_FLOW_FRAG_IPV6:
1176 case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
1177 entry.input.flow.ipv6_flow.proto = res->proto_value;
1178 case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
1179 case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
1180 IPV6_ADDR_TO_ARRAY(res->ip_dst,
1181 entry.input.flow.ipv6_flow.dst_ip);
1182 IPV6_ADDR_TO_ARRAY(res->ip_src,
1183 entry.input.flow.ipv6_flow.src_ip);
1184 entry.input.flow.ipv6_flow.tc = res->tos_value;
1185 entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
1186 /* need convert to big endian. */
1187 entry.input.flow.udp6_flow.dst_port =
1188 rte_cpu_to_be_16(res->port_dst);
1189 entry.input.flow.udp6_flow.src_port =
1190 rte_cpu_to_be_16(res->port_src);
1193 case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
1194 IPV6_ADDR_TO_ARRAY(res->ip_dst,
1195 entry.input.flow.sctp6_flow.ip.dst_ip);
1196 IPV6_ADDR_TO_ARRAY(res->ip_src,
1197 entry.input.flow.sctp6_flow.ip.src_ip);
1198 entry.input.flow.ipv6_flow.tc = res->tos_value;
1199 entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
1200 /* need convert to big endian. */
1201 entry.input.flow.sctp6_flow.dst_port =
1202 rte_cpu_to_be_16(res->port_dst);
1203 entry.input.flow.sctp6_flow.src_port =
1204 rte_cpu_to_be_16(res->port_src);
1205 entry.input.flow.sctp6_flow.verify_tag =
1206 rte_cpu_to_be_32(res->verify_tag_value);
1208 case RTE_ETH_FLOW_L2_PAYLOAD:
1209 entry.input.flow.l2_flow.ether_type =
1210 rte_cpu_to_be_16(res->ether_type);
1216 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN)
1217 (void)rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
1219 sizeof(struct ether_addr));
1221 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
1222 (void)rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
1224 sizeof(struct ether_addr));
1225 entry.input.flow.tunnel_flow.tunnel_type =
1226 str2fdir_tunneltype(res->tunnel_type);
1227 entry.input.flow.tunnel_flow.tunnel_id =
1228 rte_cpu_to_be_32(res->tunnel_id_value);
1232 (void)rte_memcpy(entry.input.flow_ext.flexbytes,
1234 RTE_ETH_FDIR_MAX_FLEXLEN);
1236 entry.input.flow_ext.vlan_tci = rte_cpu_to_be_16(res->vlan_value);
1238 entry.action.flex_off = 0; /*use 0 by default */
1239 if (!strcmp(res->drop, "drop"))
1240 entry.action.behavior = RTE_ETH_FDIR_REJECT;
1242 entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
1244 if (!strcmp(res->pf_vf, "pf"))
1245 entry.input.flow_ext.is_vf = 0;
1246 else if (!strncmp(res->pf_vf, "vf", 2)) {
1247 struct rte_eth_dev_info dev_info;
1249 memset(&dev_info, 0, sizeof(dev_info));
1250 rte_eth_dev_info_get(res->port_id, &dev_info);
1252 vf_id = strtoul(res->pf_vf + 2, &end, 10);
1253 if (errno != 0 || *end != '\0' || vf_id >= dev_info.max_vfs) {
1254 printf("invalid parameter %s.\n", res->pf_vf);
1257 entry.input.flow_ext.is_vf = 1;
1258 entry.input.flow_ext.dst_id = (uint16_t)vf_id;
1260 printf("invalid parameter %s.\n", res->pf_vf);
1263 /* set to report FD ID by default */
1264 entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
1265 entry.action.rx_queue = res->queue_id;
1266 entry.soft_id = res->fd_id_value;
1267 if (!strcmp(res->ops, "add"))
1268 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1269 RTE_ETH_FILTER_ADD, &entry);
1270 else if (!strcmp(res->ops, "del"))
1271 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1272 RTE_ETH_FILTER_DELETE, &entry);
1274 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
1275 RTE_ETH_FILTER_UPDATE, &entry);
1277 printf("flow director programming error: (%s)\n",
1279 // fdir_filter_enabled = 1;
1284 cmdline_parse_token_string_t cmd_flow_director_filter =
1285 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1286 flow_director_filter, "flow_director_filter");
1288 cmdline_parse_token_num_t cmd_flow_director_port_id =
1289 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1293 cmdline_parse_token_string_t cmd_flow_director_mode =
1294 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1297 cmdline_parse_token_string_t cmd_flow_director_mode_ip =
1298 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1301 cmdline_parse_token_string_t cmd_flow_director_ops =
1302 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1303 ops, "add#del#update");
1305 cmdline_parse_token_string_t cmd_flow_director_flow =
1306 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1309 cmdline_parse_token_string_t cmd_flow_director_flow_type =
1310 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1311 flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
1312 "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload");
1314 cmdline_parse_token_string_t cmd_flow_director_src =
1315 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1317 cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
1318 TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
1320 cmdline_parse_token_num_t cmd_flow_director_port_src =
1321 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1323 cmdline_parse_token_string_t cmd_flow_director_dst =
1324 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1326 cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
1327 TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
1329 cmdline_parse_token_num_t cmd_flow_director_port_dst =
1330 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1333 cmdline_parse_token_string_t cmd_flow_director_tos =
1334 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1336 cmdline_parse_token_num_t cmd_flow_director_tos_value =
1337 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1340 cmdline_parse_token_string_t cmd_flow_director_ttl =
1341 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1343 cmdline_parse_token_num_t cmd_flow_director_ttl_value =
1344 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1347 cmdline_parse_token_string_t cmd_flow_director_vlan =
1348 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1350 cmdline_parse_token_num_t cmd_flow_director_vlan_value =
1351 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1352 vlan_value, UINT16);
1353 cmdline_parse_token_string_t cmd_flow_director_flexbytes =
1354 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1355 flexbytes, "flexbytes");
1356 cmdline_parse_token_string_t cmd_flow_director_flexbytes_value =
1357 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1358 flexbytes_value, NULL);
1359 cmdline_parse_token_string_t cmd_flow_director_drop =
1360 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1362 cmdline_parse_token_string_t cmd_flow_director_pf_vf =
1363 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1365 cmdline_parse_token_string_t cmd_flow_director_queue =
1366 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1368 cmdline_parse_token_num_t cmd_flow_director_queue_id =
1369 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1371 cmdline_parse_token_string_t cmd_flow_director_fd_id =
1372 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1374 cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
1375 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1376 fd_id_value, UINT32);
1379 cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
1380 .f = cmd_flow_director_filter_parsed,
1382 .help_str = "add or delete an udp/tcp flow director entry on NIC",
1384 (void *)&cmd_flow_director_filter,
1385 (void *)&cmd_flow_director_port_id,
1386 (void *)&cmd_flow_director_mode,
1387 (void *)&cmd_flow_director_mode_ip,
1388 (void *)&cmd_flow_director_ops,
1389 (void *)&cmd_flow_director_flow,
1390 (void *)&cmd_flow_director_flow_type,
1391 (void *)&cmd_flow_director_src,
1392 (void *)&cmd_flow_director_ip_src,
1393 (void *)&cmd_flow_director_port_src,
1394 (void *)&cmd_flow_director_dst,
1395 (void *)&cmd_flow_director_ip_dst,
1396 (void *)&cmd_flow_director_port_dst,
1397 (void *)&cmd_flow_director_tos,
1398 (void *)&cmd_flow_director_tos_value,
1399 (void *)&cmd_flow_director_ttl,
1400 (void *)&cmd_flow_director_ttl_value,
1401 (void *)&cmd_flow_director_vlan,
1402 (void *)&cmd_flow_director_vlan_value,
1403 (void *)&cmd_flow_director_flexbytes,
1404 (void *)&cmd_flow_director_flexbytes_value,
1405 (void *)&cmd_flow_director_drop,
1406 (void *)&cmd_flow_director_pf_vf,
1407 (void *)&cmd_flow_director_queue,
1408 (void *)&cmd_flow_director_queue_id,
1409 (void *)&cmd_flow_director_fd_id,
1410 (void *)&cmd_flow_director_fd_id_value,
1415 cmdline_parse_token_string_t cmd_flow_director_ether =
1416 TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
1418 cmdline_parse_token_num_t cmd_flow_director_ether_type =
1419 TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
1420 ether_type, UINT16);
1422 cmdline_parse_inst_t cmd_add_del_l2_flow_director = {
1423 .f = cmd_flow_director_filter_parsed,
1425 .help_str = "add or delete a L2 flow director entry on NIC",
1427 (void *)&cmd_flow_director_filter,
1428 (void *)&cmd_flow_director_port_id,
1429 (void *)&cmd_flow_director_mode,
1430 (void *)&cmd_flow_director_mode_ip,
1431 (void *)&cmd_flow_director_ops,
1432 (void *)&cmd_flow_director_flow,
1433 (void *)&cmd_flow_director_flow_type,
1434 (void *)&cmd_flow_director_ether,
1435 (void *)&cmd_flow_director_ether_type,
1436 (void *)&cmd_flow_director_flexbytes,
1437 (void *)&cmd_flow_director_flexbytes_value,
1438 (void *)&cmd_flow_director_drop,
1439 (void *)&cmd_flow_director_pf_vf,
1440 (void *)&cmd_flow_director_queue,
1441 (void *)&cmd_flow_director_queue_id,
1442 (void *)&cmd_flow_director_fd_id,
1443 (void *)&cmd_flow_director_fd_id_value,
1449 /* Set hash input set */
1450 struct cmd_set_hash_input_set_result {
1451 cmdline_fixed_string_t set_hash_input_set;
1453 cmdline_fixed_string_t flow_type;
1454 cmdline_fixed_string_t inset_field0;
1455 cmdline_fixed_string_t inset_field1;
1456 cmdline_fixed_string_t inset_field2;
1457 cmdline_fixed_string_t inset_field3;
1458 cmdline_fixed_string_t inset_field4;
1459 cmdline_fixed_string_t select;
1462 enum rte_eth_input_set_field
1463 str2inset(const char *string)
1467 static const struct {
1469 enum rte_eth_input_set_field inset;
1471 {"ethertype", RTE_ETH_INPUT_SET_L2_ETHERTYPE},
1472 {"ovlan", RTE_ETH_INPUT_SET_L2_OUTER_VLAN},
1473 {"ivlan", RTE_ETH_INPUT_SET_L2_INNER_VLAN},
1474 {"src-ipv4", RTE_ETH_INPUT_SET_L3_SRC_IP4},
1475 {"dst-ipv4", RTE_ETH_INPUT_SET_L3_DST_IP4},
1476 {"ipv4-tos", RTE_ETH_INPUT_SET_L3_IP4_TOS},
1477 {"ipv4-proto", RTE_ETH_INPUT_SET_L3_IP4_PROTO},
1478 {"ipv4-ttl", RTE_ETH_INPUT_SET_L3_IP4_TTL},
1479 {"src-ipv6", RTE_ETH_INPUT_SET_L3_SRC_IP6},
1480 {"dst-ipv6", RTE_ETH_INPUT_SET_L3_DST_IP6},
1481 {"ipv6-tc", RTE_ETH_INPUT_SET_L3_IP6_TC},
1482 {"ipv6-next-header", RTE_ETH_INPUT_SET_L3_IP6_NEXT_HEADER},
1483 {"ipv6-hop-limits", RTE_ETH_INPUT_SET_L3_IP6_HOP_LIMITS},
1484 {"udp-src-port", RTE_ETH_INPUT_SET_L4_UDP_SRC_PORT},
1485 {"udp-dst-port", RTE_ETH_INPUT_SET_L4_UDP_DST_PORT},
1486 {"tcp-src-port", RTE_ETH_INPUT_SET_L4_TCP_SRC_PORT},
1487 {"tcp-dst-port", RTE_ETH_INPUT_SET_L4_TCP_DST_PORT},
1488 {"sctp-src-port", RTE_ETH_INPUT_SET_L4_SCTP_SRC_PORT},
1489 {"sctp-dst-port", RTE_ETH_INPUT_SET_L4_SCTP_DST_PORT},
1490 {"sctp-veri-tag", RTE_ETH_INPUT_SET_L4_SCTP_VERIFICATION_TAG},
1491 {"udp-key", RTE_ETH_INPUT_SET_TUNNEL_L4_UDP_KEY},
1492 {"gre-key", RTE_ETH_INPUT_SET_TUNNEL_GRE_KEY},
1493 {"fld-1st", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_1ST_WORD},
1494 {"fld-2nd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_2ND_WORD},
1495 {"fld-3rd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_3RD_WORD},
1496 {"fld-4th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_4TH_WORD},
1497 {"fld-5th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_5TH_WORD},
1498 {"fld-6th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_6TH_WORD},
1499 {"fld-7th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_7TH_WORD},
1500 {"fld-8th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_8TH_WORD},
1501 {"none", RTE_ETH_INPUT_SET_NONE},
1503 for (i = 0; i < RTE_DIM(inset_table); i++) {
1504 if (!strcmp(string, inset_table[i].str))
1505 return inset_table[i].inset;
1508 return RTE_ETH_INPUT_SET_UNKNOWN;
1512 cmd_set_hash_input_set_1_parsed(void *parsed_result,
1513 __rte_unused struct cmdline *cl,
1514 __rte_unused void *data)
1516 struct cmd_set_hash_input_set_result *res = parsed_result;
1517 struct rte_eth_hash_filter_info info;
1519 if (enable_flow_dir) {
1520 printf("FDIR Filter is Defined!\n");
1521 printf("Please undefine FDIR_FILTER flag and define "
1526 memset(&info, 0, sizeof(info));
1527 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1528 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1530 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1531 info.info.input_set_conf.inset_size = 1;
1533 if (!strcmp(res->select, "select"))
1534 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1535 else if (!strcmp(res->select, "add"))
1536 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1538 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1539 RTE_ETH_FILTER_SET, &info);
1541 //hash_filter_enabled = 1;
1545 cmd_set_hash_input_set_2_parsed(void *parsed_result,
1546 __rte_unused struct cmdline *cl,
1547 __rte_unused void *data)
1549 struct cmd_set_hash_input_set_result *res = parsed_result;
1550 struct rte_eth_hash_filter_info info;
1552 if (enable_flow_dir) {
1553 printf("FDIR Filter is Defined!\n");
1554 printf("Please undefine FDIR_FILTER flag and define "
1559 memset(&info, 0, sizeof(info));
1560 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1561 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1563 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1564 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1566 info.info.input_set_conf.inset_size = 2;
1568 if (!strcmp(res->select, "select"))
1569 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1570 else if (!strcmp(res->select, "add"))
1571 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1573 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1574 RTE_ETH_FILTER_SET, &info);
1576 //hash_filter_enabled = 1;
1581 cmd_set_hash_input_set_3_parsed(void *parsed_result,
1582 __rte_unused struct cmdline *cl,
1583 __rte_unused void *data)
1585 struct cmd_set_hash_input_set_result *res = parsed_result;
1586 struct rte_eth_hash_filter_info info;
1588 memset(&info, 0, sizeof(info));
1589 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1590 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1592 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1593 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1594 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1595 info.info.input_set_conf.inset_size = 3;
1597 if (!strcmp(res->select, "select"))
1598 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1599 else if (!strcmp(res->select, "add"))
1600 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1602 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1603 RTE_ETH_FILTER_SET, &info);
1607 cmd_set_hash_input_set_4_parsed(void *parsed_result,
1608 __rte_unused struct cmdline *cl,
1609 __rte_unused void *data)
1611 struct cmd_set_hash_input_set_result *res = parsed_result;
1612 struct rte_eth_hash_filter_info info;
1614 if (enable_flow_dir) {
1615 printf("FDIR Filter is Defined!\n");
1616 printf("Please undefine FDIR_FILTER flag and define "
1621 memset(&info, 0, sizeof(info));
1622 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1623 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1625 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1626 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1627 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1628 info.info.input_set_conf.field[3] = str2inset(res->inset_field3);
1630 info.info.input_set_conf.inset_size = 4;
1631 if (!strcmp(res->select, "select"))
1632 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1633 else if (!strcmp(res->select, "add"))
1634 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1636 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1637 RTE_ETH_FILTER_SET, &info);
1638 //hash_filter_enabled = 1;
1643 cmd_set_hash_input_set_5_parsed(void *parsed_result,
1644 __rte_unused struct cmdline *cl,
1645 __rte_unused void *data)
1647 struct cmd_set_hash_input_set_result *res = parsed_result;
1648 struct rte_eth_hash_filter_info info;
1650 memset(&info, 0, sizeof(info));
1651 info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
1652 info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
1654 info.info.input_set_conf.field[0] = str2inset(res->inset_field0);
1655 info.info.input_set_conf.field[1] = str2inset(res->inset_field1);
1656 info.info.input_set_conf.field[2] = str2inset(res->inset_field2);
1657 info.info.input_set_conf.field[3] = str2inset(res->inset_field3);
1658 info.info.input_set_conf.field[4] = str2inset(res->inset_field4);
1660 info.info.input_set_conf.inset_size = 5;
1661 if (!strcmp(res->select, "select"))
1662 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
1663 else if (!strcmp(res->select, "add"))
1664 info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
1665 rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1666 RTE_ETH_FILTER_SET, &info);
1670 cmdline_parse_token_string_t cmd_set_hash_input_set_cmd =
1671 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1672 set_hash_input_set, "set_hash_input_set");
1673 cmdline_parse_token_num_t cmd_set_hash_input_set_port_id =
1674 TOKEN_NUM_INITIALIZER(struct cmd_set_hash_input_set_result,
1676 cmdline_parse_token_string_t cmd_set_hash_input_set_flow_type =
1677 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1679 "ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
1680 "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
1682 cmdline_parse_token_string_t cmd_set_hash_input_set_field0 =
1683 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1685 "src-ipv4#src-ipv6#dst-ipv4#dst-ipv6#"
1686 "udp-src-port#udp-dst-port#tcp-src-port#tcp-dst-port#none");
1688 cmdline_parse_token_string_t cmd_set_hash_input_set_field1 =
1689 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1691 "dst-ipv4#dst-ipv6#"
1692 "udp-src-port#tcp-src-port#udp-dst-port#tcp-dst-port#none");
1694 cmdline_parse_token_string_t cmd_set_hash_input_set_field2 =
1695 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1697 "udp-src-port#tcp-src-port#none");
1699 cmdline_parse_token_string_t cmd_set_hash_input_set_field3 =
1700 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1702 "udp-dst-port#tcp-dst-port#none");
1704 cmdline_parse_token_string_t cmd_set_hash_input_set_field4 =
1705 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1706 inset_field4, "ipv4-proto#ipv6-next-header#none");
1709 cmdline_parse_token_string_t cmd_set_hash_input_set_select =
1710 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
1711 select, "select#add");
1713 cmdline_parse_inst_t cmd_set_hash_input_set_1 = {
1714 .f = cmd_set_hash_input_set_1_parsed,
1716 .help_str = "set_hash_input_set_1 <port_id> "
1717 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1718 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1719 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6|"
1720 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1723 (void *)&cmd_set_hash_input_set_cmd,
1724 (void *)&cmd_set_hash_input_set_port_id,
1725 (void *)&cmd_set_hash_input_set_flow_type,
1726 (void *)&cmd_set_hash_input_set_field0,
1727 (void *)&cmd_set_hash_input_set_select,
1732 cmdline_parse_inst_t cmd_set_hash_input_set_2 = {
1733 .f = cmd_set_hash_input_set_2_parsed,
1735 .help_str = "set_hash_input_set_2 <port_id> "
1736 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other| "
1737 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1738 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6| "
1739 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1740 "udp-src-port|tcp-src-port|udp-dst-port|tcp-dst-port|none "
1743 (void *)&cmd_set_hash_input_set_cmd,
1744 (void *)&cmd_set_hash_input_set_port_id,
1745 (void *)&cmd_set_hash_input_set_flow_type,
1746 (void *)&cmd_set_hash_input_set_field0,
1747 (void *)&cmd_set_hash_input_set_field1,
1748 (void *)&cmd_set_hash_input_set_select,
1754 cmdline_parse_inst_t cmd_set_hash_input_set_3 = {
1755 .f = cmd_set_hash_input_set_3_parsed,
1757 .help_str = "set_hash_input_set_3 <port_id> "
1758 "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1759 "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1760 "ovlan|ivlan|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|"
1761 "ipv6-tc|ipv6-next-header|udp-src-port|udp-dst-port|tcp-src-port|"
1762 "tcp-dst-port|sctp-src-port|sctp-dst-port|sctp-veri-tag|udp-key|"
1763 "gre-key|fld-1st|fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|"
1764 "fld-7th|fld-8th|none "
1765 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1768 (void *)&cmd_set_hash_input_set_cmd,
1769 (void *)&cmd_set_hash_input_set_port_id,
1770 (void *)&cmd_set_hash_input_set_flow_type,
1771 (void *)&cmd_set_hash_input_set_field0,
1772 (void *)&cmd_set_hash_input_set_field1,
1773 (void *)&cmd_set_hash_input_set_field2,
1774 (void *)&cmd_set_hash_input_set_select,
1780 cmdline_parse_inst_t cmd_set_hash_input_set_4 = {
1781 .f = cmd_set_hash_input_set_4_parsed,
1783 .help_str = "set_hash_input_set_4 <port_id> "
1784 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1785 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1786 "src-ipv4|src-ipv6|dst-ipv4|dst-ipv6|"
1787 "udp-src-port|udp-dst-port|tcp-src-port|tcp-dst-port|none "
1788 "udp-src-port|tcp-src-port|udp-dst-port|tcp-dst-port|none "
1789 "udp-src-port|tcp-src-port|dst-ipv4|none "
1790 "udp-dst-port|tcp-dst-port|none "
1793 (void *)&cmd_set_hash_input_set_cmd,
1794 (void *)&cmd_set_hash_input_set_port_id,
1795 (void *)&cmd_set_hash_input_set_flow_type,
1796 (void *)&cmd_set_hash_input_set_field0,
1797 (void *)&cmd_set_hash_input_set_field1,
1798 (void *)&cmd_set_hash_input_set_field2,
1799 (void *)&cmd_set_hash_input_set_field3,
1800 (void *)&cmd_set_hash_input_set_select,
1805 cmdline_parse_inst_t cmd_set_hash_input_set_5 = {
1806 .f = cmd_set_hash_input_set_5_parsed,
1808 .help_str = "set_hash_input_set_5 <port_id> "
1809 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
1810 "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1811 "src-ipv4|src-ipv6|none "
1812 "dst-ipv4|dst-ipv6|none "
1813 "udp-src-port|tcp-src-port|none "
1814 "udp-dst-port|tcp-dst-port|none "
1815 "ipv4-proto|ipv6-next-header|none "
1819 (void *)&cmd_set_hash_input_set_cmd,
1820 (void *)&cmd_set_hash_input_set_port_id,
1821 (void *)&cmd_set_hash_input_set_flow_type,
1822 (void *)&cmd_set_hash_input_set_field0,
1823 (void *)&cmd_set_hash_input_set_field1,
1824 (void *)&cmd_set_hash_input_set_field2,
1825 (void *)&cmd_set_hash_input_set_field3,
1826 (void *)&cmd_set_hash_input_set_field4,
1827 (void *)&cmd_set_hash_input_set_select,
1833 /* set hash global config */
1834 struct cmd_set_hash_global_config_result {
1835 cmdline_fixed_string_t set_hash_global_config;
1837 cmdline_fixed_string_t hash_func;
1838 cmdline_fixed_string_t flow_type;
1839 cmdline_fixed_string_t enable;
1843 cmd_set_hash_global_config_parsed(void *parsed_result,
1844 __rte_unused struct cmdline *cl,
1845 __rte_unused void *data)
1847 struct cmd_set_hash_global_config_result *res = parsed_result;
1848 struct rte_eth_hash_filter_info info;
1849 uint32_t ftype, idx, offset;
1852 if (rte_eth_dev_filter_supported(res->port_id,
1853 RTE_ETH_FILTER_HASH) < 0) {
1854 printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
1858 memset(&info, 0, sizeof(info));
1859 info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
1860 if (!strcmp(res->hash_func, "toeplitz"))
1861 info.info.global_conf.hash_func =
1862 RTE_ETH_HASH_FUNCTION_TOEPLITZ;
1863 else if (!strcmp(res->hash_func, "simple_xor"))
1864 info.info.global_conf.hash_func =
1865 RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
1866 else if (!strcmp(res->hash_func, "default"))
1867 info.info.global_conf.hash_func =
1868 RTE_ETH_HASH_FUNCTION_DEFAULT;
1870 ftype = str2flowtype(res->flow_type);
1871 idx = ftype / (CHAR_BIT * sizeof(uint32_t));
1872 offset = ftype % (CHAR_BIT * sizeof(uint32_t));
1873 info.info.global_conf.valid_bit_mask[idx] |= (1UL << offset);
1874 if (!strcmp(res->enable, "enable"))
1875 if(idx < RTE_SYM_HASH_MASK_ARRAY_SIZE)
1876 info.info.global_conf.sym_hash_enable_mask[idx] |=
1878 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1879 RTE_ETH_FILTER_SET, &info);
1881 printf("Cannot set global hash configurations by port %d\n",
1884 printf("Global hash configurations have been set "
1885 "succcessfully by port %d\n", res->port_id);
1887 cmdline_parse_token_string_t cmd_set_hash_global_config_all =
1888 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1889 set_hash_global_config, "set_hash_global_config");
1890 cmdline_parse_token_num_t cmd_set_hash_global_config_port_id =
1891 TOKEN_NUM_INITIALIZER(struct cmd_set_hash_global_config_result,
1893 cmdline_parse_token_string_t cmd_set_hash_global_config_hash_func =
1894 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1895 hash_func, "toeplitz#simple_xor#default");
1896 cmdline_parse_token_string_t cmd_set_hash_global_config_flow_type =
1897 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1899 "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#ipv6#"
1900 "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
1901 cmdline_parse_token_string_t cmd_set_hash_global_config_enable =
1902 TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
1903 enable, "enable#disable");
1905 cmdline_parse_inst_t cmd_set_hash_global_config = {
1906 .f = cmd_set_hash_global_config_parsed,
1908 .help_str = "set_hash_global_config port_id "
1909 "toeplitz|simple_xor|default "
1910 "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
1911 "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
1914 (void *)&cmd_set_hash_global_config_all,
1915 (void *)&cmd_set_hash_global_config_port_id,
1916 (void *)&cmd_set_hash_global_config_hash_func,
1917 (void *)&cmd_set_hash_global_config_flow_type,
1918 (void *)&cmd_set_hash_global_config_enable,
1923 /* *** Set symmetric hash enable per port *** */
1924 struct cmd_set_sym_hash_ena_per_port_result {
1925 cmdline_fixed_string_t set_sym_hash_ena_per_port;
1926 cmdline_fixed_string_t enable;
1931 cmd_set_sym_hash_per_port_parsed(void *parsed_result,
1932 __rte_unused struct cmdline *cl,
1933 __rte_unused void *data)
1935 struct cmd_set_sym_hash_ena_per_port_result *res = parsed_result;
1936 struct rte_eth_hash_filter_info info;
1939 if (rte_eth_dev_filter_supported(res->port_id,
1940 RTE_ETH_FILTER_HASH) < 0) {
1941 printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
1946 memset(&info, 0, sizeof(info));
1947 info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
1949 if (!strcmp(res->enable, "enable"))
1950 info.info.enable = 1;
1952 ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
1953 RTE_ETH_FILTER_SET, &info);
1955 printf("Cannot set symmetric hash enable per port on "
1956 "port %u\n", res->port_id);
1959 printf("Symmetric hash has been set to %s on port %u\n",
1960 res->enable, res->port_id);
1963 cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_all =
1964 TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1965 set_sym_hash_ena_per_port, "set_sym_hash_ena_per_port");
1966 cmdline_parse_token_num_t cmd_set_sym_hash_ena_per_port_port_id =
1967 TOKEN_NUM_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1969 cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_enable =
1970 TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
1971 enable, "enable#disable");
1973 cmdline_parse_inst_t cmd_set_sym_hash_ena_per_port = {
1974 .f = cmd_set_sym_hash_per_port_parsed,
1976 .help_str = "set_sym_hash_ena_per_port port_id enable|disable",
1978 (void *)&cmd_set_sym_hash_ena_per_port_all,
1979 (void *)&cmd_set_sym_hash_ena_per_port_port_id,
1980 (void *)&cmd_set_sym_hash_ena_per_port_enable,
1987 app_pipeline_arpicmp_entry_dbg(struct app_params *app,
1988 uint32_t pipeline_id, uint8_t *msg)
1990 struct pipeline_arpicmp_entry_dbg_msg_req *req;
1991 struct pipeline_arpicmp_entry_dbg_msg_rsp *rsp;
1993 /* Check input arguments */
1997 /* Allocate and write request */
1998 req = app_msg_alloc(app);
2002 req->type = PIPELINE_MSG_REQ_CUSTOM;
2003 req->subtype = PIPELINE_ARPICMP_MSG_REQ_ENTRY_DBG;
2004 req->data[0] = msg[0];
2005 req->data[1] = msg[1];
2007 rsp = app_msg_send_recv(app, pipeline_id, req, MSG_TIMEOUT_DEFAULT);
2013 app_msg_free(app, rsp);
2014 printf("Error rsp->status %d\n", rsp->status);
2019 app_msg_free(app, rsp);
2029 struct cmd_entry_dbg_result {
2030 cmdline_fixed_string_t p_string;
2032 cmdline_fixed_string_t entry_string;
2033 cmdline_fixed_string_t dbg_string;
2039 cmd_entry_dbg_parsed(void *parsed_result,
2040 __rte_unused struct cmdline *cl, void *data)
2042 struct cmd_entry_dbg_result *params = parsed_result;
2043 struct app_params *app = data;
2047 msg[0] = params->cmd;
2048 msg[1] = params->d1;
2049 status = app_pipeline_arpicmp_entry_dbg(app, params->p, msg);
2052 printf("Dbg Command failed\n");
2057 static cmdline_parse_token_string_t lb_cmd_entry_dbg_p_string =
2058 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result, p_string, "p");
2060 static cmdline_parse_token_num_t lb_cmd_entry_dbg_p =
2061 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, p, UINT32);
2063 static cmdline_parse_token_string_t lb_cmd_entry_dbg_entry_string =
2064 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result,
2065 entry_string, "txrx");
2067 static cmdline_parse_token_string_t lb_cmd_entry_dbg_dbg_string =
2068 TOKEN_STRING_INITIALIZER(struct cmd_entry_dbg_result, dbg_string,
2071 static cmdline_parse_token_num_t lb_cmd_entry_dbg_cmd =
2072 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, cmd, UINT8);
2074 static cmdline_parse_token_num_t lb_cmd_entry_dbg_d1 =
2075 TOKEN_NUM_INITIALIZER(struct cmd_entry_dbg_result, d1, UINT8);
2077 static cmdline_parse_inst_t lb_cmd_entry_dbg = {
2078 .f = cmd_entry_dbg_parsed,
2080 .help_str = "ARPICMP dbg cmd",
2082 (void *)&lb_cmd_entry_dbg_p_string,
2083 (void *)&lb_cmd_entry_dbg_p,
2084 (void *)&lb_cmd_entry_dbg_entry_string,
2085 (void *)&lb_cmd_entry_dbg_dbg_string,
2086 (void *)&lb_cmd_entry_dbg_cmd,
2087 (void *)&lb_cmd_entry_dbg_d1,
2092 static cmdline_parse_ctx_t pipeline_cmds[] = {
2093 (cmdline_parse_inst_t *) &lb_cmd_entry_dbg,
2094 (cmdline_parse_inst_t *) &cmd_arp_add,
2095 (cmdline_parse_inst_t *) &cmd_arp_del,
2096 (cmdline_parse_inst_t *) &cmd_arp_req,
2097 (cmdline_parse_inst_t *) &cmd_icmp_echo_req,
2098 (cmdline_parse_inst_t *) &cmd_arp_ls,
2099 (cmdline_parse_inst_t *) &cmd_show_ports_info,
2101 (cmdline_parse_inst_t *) &cmd_set_fwd_mode,
2102 (cmdline_parse_inst_t *) &cmd_add_del_udp_flow_director,
2103 (cmdline_parse_inst_t *) &cmd_add_del_l2_flow_director,
2104 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_1,
2105 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_2,
2106 /* (cmdline_parse_inst_t *) & cmd_set_hash_input_set_3,*/
2107 (cmdline_parse_inst_t *) &cmd_set_hash_input_set_4,
2108 /* (cmdline_parse_inst_t *) & cmd_set_hash_input_set_5,*/
2109 (cmdline_parse_inst_t *) &cmd_set_hash_global_config,
2110 (cmdline_parse_inst_t *) &cmd_set_sym_hash_ena_per_port,
2111 (cmdline_parse_inst_t *) &cmd_arp_dbg,
2112 (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,