/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2016 Intel Corporation.
 * Copyright(c) 2014 6WIND S.A.
 */

#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/queue.h>

#include <rte_common.h>
#include <rte_byteorder.h>
#include <rte_log.h>
#include <rte_debug.h>
#include <rte_cycles.h>
#include <rte_memory.h>
#include <rte_memzone.h>
#include <rte_malloc.h>
#include <rte_launch.h>
#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
#include <rte_branch_prediction.h>
#include <rte_ring.h>
#include <rte_mempool.h>
#include <rte_interrupts.h>
#include <rte_pci.h>
#include <rte_ether.h>
#include <rte_ethdev.h>
#include <rte_string_fns.h>
#include <rte_devargs.h>
#include <rte_flow.h>
#ifdef RTE_LIB_GRO
#include <rte_gro.h>
#endif
#include <rte_mbuf_dyn.h>

#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_parse_num.h>
#include <cmdline_parse_string.h>
#include <cmdline_parse_ipaddr.h>
#include <cmdline_parse_etheraddr.h>
#include <cmdline_socket.h>
#include <cmdline.h>
#ifdef RTE_NET_BOND
#include <rte_eth_bond.h>
#include <rte_eth_bond_8023ad.h>
#endif
#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA
#include <rte_pmd_dpaa.h>
#endif
#ifdef RTE_NET_IXGBE
#include <rte_pmd_ixgbe.h>
#endif
#ifdef RTE_NET_I40E
#include <rte_pmd_i40e.h>
#endif
#ifdef RTE_NET_BNXT
#include <rte_pmd_bnxt.h>
#endif
#include "testpmd.h"
#include "cmdline_mtr.h"
#include "cmdline_tm.h"
#include "bpf_cmd.h"

static struct cmdline *testpmd_cl;

static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue);

/* *** Help command with introduction. *** */
struct cmd_help_brief_result {
        cmdline_fixed_string_t help;
};

static void cmd_help_brief_parsed(__rte_unused void *parsed_result,
                                  struct cmdline *cl,
                                  __rte_unused void *data)
{
        cmdline_printf(
                cl,
                "\n"
                "Help is available for the following sections:\n\n"
                "    help control                    : Start and stop forwarding.\n"
                "    help display                    : Displaying port, stats and config "
                "information.\n"
                "    help config                     : Configuration information.\n"
                "    help ports                      : Configuring ports.\n"
                "    help registers                  : Reading and setting port registers.\n"
                "    help filters                    : Filters configuration help.\n"
                "    help traffic_management         : Traffic Management commands.\n"
                "    help devices                    : Device related cmds.\n"
                "    help all                        : All of the above sections.\n\n"
        );

}

cmdline_parse_token_string_t cmd_help_brief_help =
        TOKEN_STRING_INITIALIZER(struct cmd_help_brief_result, help, "help");

cmdline_parse_inst_t cmd_help_brief = {
        .f = cmd_help_brief_parsed,
        .data = NULL,
        .help_str = "help: Show help",
        .tokens = {
                (void *)&cmd_help_brief_help,
                NULL,
        },
};

/* *** Help command with help sections. *** */
struct cmd_help_long_result {
        cmdline_fixed_string_t help;
        cmdline_fixed_string_t section;
};

static void cmd_help_long_parsed(void *parsed_result,
                                 struct cmdline *cl,
                                 __rte_unused void *data)
{
        int show_all = 0;
        struct cmd_help_long_result *res = parsed_result;

        if (!strcmp(res->section, "all"))
                show_all = 1;

        if (show_all || !strcmp(res->section, "control")) {

                cmdline_printf(
                        cl,
                        "\n"
                        "Control forwarding:\n"
                        "-------------------\n\n"

                        "start\n"
                        "    Start packet forwarding with current configuration.\n\n"

                        "start tx_first\n"
                        "    Start packet forwarding with current config"
                        " after sending one burst of packets.\n\n"

                        "stop\n"
                        "    Stop packet forwarding, and display accumulated"
                        " statistics.\n\n"

                        "quit\n"
                        "    Quit to prompt.\n\n"
                );
        }

        if (show_all || !strcmp(res->section, "display")) {

                cmdline_printf(
                        cl,
                        "\n"
                        "Display:\n"
                        "--------\n\n"

                        "show port (info|stats|summary|xstats|fdir|dcb_tc) (port_id|all)\n"
                        "    Display information for port_id, or all.\n\n"

                        "show port info (port_id) representor\n"
                        "    Show supported representors for a specific port\n\n"

                        "show port port_id (module_eeprom|eeprom)\n"
                        "    Display the module EEPROM or EEPROM information for port_id.\n\n"

                        "show port X rss reta (size) (mask0,mask1,...)\n"
                        "    Display the rss redirection table entry indicated"
                        " by masks on port X. size is used to indicate the"
                        " hardware supported reta size\n\n"

                        "show port (port_id) rss-hash [key]\n"
                        "    Display the RSS hash functions and RSS hash key of port\n\n"

                        "clear port (info|stats|xstats|fdir) (port_id|all)\n"
                        "    Clear information for port_id, or all.\n\n"

                        "show (rxq|txq) info (port_id) (queue_id)\n"
                        "    Display information for configured RX/TX queue.\n\n"

                        "show config (rxtx|cores|fwd|rxoffs|rxpkts|txpkts)\n"
                        "    Display the given configuration.\n\n"

                        "read rxd (port_id) (queue_id) (rxd_id)\n"
                        "    Display an RX descriptor of a port RX queue.\n\n"

                        "read txd (port_id) (queue_id) (txd_id)\n"
                        "    Display a TX descriptor of a port TX queue.\n\n"

                        "ddp get list (port_id)\n"
                        "    Get ddp profile info list\n\n"

                        "ddp get info (profile_path)\n"
                        "    Get ddp profile information.\n\n"

                        "show vf stats (port_id) (vf_id)\n"
                        "    Display a VF's statistics.\n\n"

                        "clear vf stats (port_id) (vf_id)\n"
                        "    Reset a VF's statistics.\n\n"

                        "show port (port_id) pctype mapping\n"
                        "    Get flow ptype to pctype mapping on a port\n\n"

                        "show port meter stats (port_id) (meter_id) (clear)\n"
                        "    Get meter stats on a port\n\n"

                        "show fwd stats all\n"
                        "    Display statistics for all fwd engines.\n\n"

                        "clear fwd stats all\n"
                        "    Clear statistics for all fwd engines.\n\n"

                        "show port (port_id) rx_offload capabilities\n"
                        "    List all per queue and per port Rx offloading"
                        " capabilities of a port\n\n"

                        "show port (port_id) rx_offload configuration\n"
                        "    List port level and all queue level"
                        " Rx offloading configuration\n\n"

                        "show port (port_id) tx_offload capabilities\n"
                        "    List all per queue and per port"
                        " Tx offloading capabilities of a port\n\n"

                        "show port (port_id) tx_offload configuration\n"
                        "    List port level and all queue level"
                        " Tx offloading configuration\n\n"

                        "show port (port_id) tx_metadata\n"
                        "    Show Tx metadata value set"
                        " for a specific port\n\n"

                        "show port (port_id) ptypes\n"
                        "    Show port supported ptypes"
                        " for a specific port\n\n"

                        "show device info (<identifier>|all)"
                        "       Show general information about devices probed.\n\n"

                        "show port (port_id) rxq|txq (queue_id) desc (desc_id) status"
                        "       Show status of rx|tx descriptor.\n\n"

                        "show port (port_id) rxq (queue_id) desc used count\n"
                        "    Show current number of filled receive"
                        " packet descriptors.\n\n"

                        "show port (port_id) macs|mcast_macs"
                        "       Display list of mac addresses added to port.\n\n"

                        "show port (port_id) flow transfer proxy\n"
                        "       Display proxy port to manage transfer flows\n\n"

                        "show port (port_id) fec capabilities"
                        "       Show fec capabilities of a port.\n\n"

                        "show port (port_id) fec_mode"
                        "       Show fec mode of a port.\n\n"

                        "show port (port_id) flow_ctrl"
                        "       Show flow control info of a port.\n\n"
                );
        }

        if (show_all || !strcmp(res->section, "config")) {
                cmdline_printf(
                        cl,
                        "\n"
                        "Configuration:\n"
                        "--------------\n"
                        "Configuration changes only become active when"
                        " forwarding is started/restarted.\n\n"

                        "set default\n"
                        "    Reset forwarding to the default configuration.\n\n"

                        "set verbose (level)\n"
                        "    Set the debug verbosity level X.\n\n"

                        "set log global|(type) (level)\n"
                        "    Set the log level.\n\n"

                        "set nbport (num)\n"
                        "    Set number of ports.\n\n"

                        "set nbcore (num)\n"
                        "    Set number of cores.\n\n"

                        "set coremask (mask)\n"
                        "    Set the forwarding cores hexadecimal mask.\n\n"

                        "set portmask (mask)\n"
                        "    Set the forwarding ports hexadecimal mask.\n\n"

                        "set burst (num)\n"
                        "    Set number of packets per burst.\n\n"

                        "set burst tx delay (microseconds) retry (num)\n"
                        "    Set the transmit delay time and number of retries,"
                        " effective when retry is enabled.\n\n"

                        "set rxoffs (x[,y]*)\n"
                        "    Set the offset of each packet segment on"
                        " receiving if split feature is engaged."
                        " Affects only the queues configured with split"
                        " offloads.\n\n"

                        "set rxpkts (x[,y]*)\n"
                        "    Set the length of each segment to scatter"
                        " packets on receiving if split feature is engaged."
                        " Affects only the queues configured with split"
                        " offloads.\n\n"

                        "set txpkts (x[,y]*)\n"
                        "    Set the length of each segment of TXONLY"
                        " and optionally CSUM packets.\n\n"

                        "set txsplit (off|on|rand)\n"
                        "    Set the split policy for the TX packets."
                        " Right now only applicable for CSUM and TXONLY"
                        " modes\n\n"

                        "set txtimes (x, y)\n"
                        "    Set the scheduling on timestamps"
                        " timings for the TXONLY mode\n\n"

                        "set corelist (x[,y]*)\n"
                        "    Set the list of forwarding cores.\n\n"

                        "set portlist (x[,y]*)\n"
                        "    Set the list of forwarding ports.\n\n"

                        "set port setup on (iterator|event)\n"
                        "    Select how attached port is retrieved for setup.\n\n"

                        "set tx loopback (port_id) (on|off)\n"
                        "    Enable or disable tx loopback.\n\n"

                        "set all queues drop (port_id) (on|off)\n"
                        "    Set drop enable bit for all queues.\n\n"

                        "set vf split drop (port_id) (vf_id) (on|off)\n"
                        "    Set split drop enable bit for a VF from the PF.\n\n"

                        "set vf mac antispoof (port_id) (vf_id) (on|off).\n"
                        "    Set MAC antispoof for a VF from the PF.\n\n"

                        "set macsec offload (port_id) on encrypt (on|off) replay-protect (on|off)\n"
                        "    Enable MACsec offload.\n\n"

                        "set macsec offload (port_id) off\n"
                        "    Disable MACsec offload.\n\n"

                        "set macsec sc (tx|rx) (port_id) (mac) (pi)\n"
                        "    Configure MACsec secure connection (SC).\n\n"

                        "set macsec sa (tx|rx) (port_id) (idx) (an) (pn) (key)\n"
                        "    Configure MACsec secure association (SA).\n\n"

                        "set vf broadcast (port_id) (vf_id) (on|off)\n"
                        "    Set VF broadcast for a VF from the PF.\n\n"

                        "vlan set stripq (on|off) (port_id,queue_id)\n"
                        "    Set the VLAN strip for a queue on a port.\n\n"

                        "set vf vlan stripq (port_id) (vf_id) (on|off)\n"
                        "    Set the VLAN strip for all queues in a pool for a VF from the PF.\n\n"

                        "set vf vlan insert (port_id) (vf_id) (vlan_id)\n"
                        "    Set VLAN insert for a VF from the PF.\n\n"

                        "set vf vlan antispoof (port_id) (vf_id) (on|off)\n"
                        "    Set VLAN antispoof for a VF from the PF.\n\n"

                        "set vf vlan tag (port_id) (vf_id) (on|off)\n"
                        "    Set VLAN tag for a VF from the PF.\n\n"

                        "set vf tx max-bandwidth (port_id) (vf_id) (bandwidth)\n"
                        "    Set a VF's max bandwidth(Mbps).\n\n"

                        "set vf tc tx min-bandwidth (port_id) (vf_id) (bw1, bw2, ...)\n"
                        "    Set all TCs' min bandwidth(%%) on a VF.\n\n"

                        "set vf tc tx max-bandwidth (port_id) (vf_id) (tc_no) (bandwidth)\n"
                        "    Set a TC's max bandwidth(Mbps) on a VF.\n\n"

                        "set tx strict-link-priority (port_id) (tc_bitmap)\n"
                        "    Set some TCs' strict link priority mode on a physical port.\n\n"

                        "set tc tx min-bandwidth (port_id) (bw1, bw2, ...)\n"
                        "    Set all TCs' min bandwidth(%%) for all PF and VFs.\n\n"

                        "vlan set (strip|filter|qinq_strip|extend) (on|off) (port_id)\n"
                        "    Set the VLAN strip or filter or qinq strip or extend\n\n"

                        "vlan set (inner|outer) tpid (value) (port_id)\n"
                        "    Set the VLAN TPID for Packet Filtering on"
                        " a port\n\n"

                        "rx_vlan add (vlan_id|all) (port_id)\n"
                        "    Add a vlan_id, or all identifiers, to the set"
                        " of VLAN identifiers filtered by port_id.\n\n"

                        "rx_vlan rm (vlan_id|all) (port_id)\n"
                        "    Remove a vlan_id, or all identifiers, from the set"
                        " of VLAN identifiers filtered by port_id.\n\n"

                        "rx_vlan add (vlan_id) port (port_id) vf (vf_mask)\n"
                        "    Add a vlan_id, to the set of VLAN identifiers"
                        "filtered for VF(s) from port_id.\n\n"

                        "rx_vlan rm (vlan_id) port (port_id) vf (vf_mask)\n"
                        "    Remove a vlan_id, to the set of VLAN identifiers"
                        "filtered for VF(s) from port_id.\n\n"

                        "rx_vxlan_port add (udp_port) (port_id)\n"
                        "    Add an UDP port for VXLAN packet filter on a port\n\n"

                        "rx_vxlan_port rm (udp_port) (port_id)\n"
                        "    Remove an UDP port for VXLAN packet filter on a port\n\n"

                        "tx_vlan set (port_id) vlan_id[, vlan_id_outer]\n"
                        "    Set hardware insertion of VLAN IDs (single or double VLAN "
                        "depends on the number of VLAN IDs) in packets sent on a port.\n\n"

                        "tx_vlan set pvid port_id vlan_id (on|off)\n"
                        "    Set port based TX VLAN insertion.\n\n"

                        "tx_vlan reset (port_id)\n"
                        "    Disable hardware insertion of a VLAN header in"
                        " packets sent on a port.\n\n"

                        "csum set (ip|udp|tcp|sctp|outer-ip|outer-udp) (hw|sw) (port_id)\n"
                        "    Select hardware or software calculation of the"
                        " checksum when transmitting a packet using the"
                        " csum forward engine.\n"
                        "    ip|udp|tcp|sctp always concern the inner layer.\n"
                        "    outer-ip concerns the outer IP layer in"
                        "    outer-udp concerns the outer UDP layer in"
                        " case the packet is recognized as a tunnel packet by"
                        " the forward engine (vxlan, gre and ipip are supported)\n"
                        "    Please check the NIC datasheet for HW limits.\n\n"

                        "csum parse-tunnel (on|off) (tx_port_id)\n"
                        "    If disabled, treat tunnel packets as non-tunneled"
                        " packets (treat inner headers as payload). The port\n"
                        "    argument is the port used for TX in csum forward"
                        " engine.\n\n"

                        "csum show (port_id)\n"
                        "    Display tx checksum offload configuration\n\n"

                        "tso set (segsize) (portid)\n"
                        "    Enable TCP Segmentation Offload in csum forward"
                        " engine.\n"
                        "    Please check the NIC datasheet for HW limits.\n\n"

                        "tso show (portid)"
                        "    Display the status of TCP Segmentation Offload.\n\n"

#ifdef RTE_LIB_GRO
                        "set port (port_id) gro on|off\n"
                        "    Enable or disable Generic Receive Offload in"
                        " csum forwarding engine.\n\n"

                        "show port (port_id) gro\n"
                        "    Display GRO configuration.\n\n"

                        "set gro flush (cycles)\n"
                        "    Set the cycle to flush GROed packets from"
                        " reassembly tables.\n\n"
#endif

#ifdef RTE_LIB_GSO
                        "set port (port_id) gso (on|off)"
                        "    Enable or disable Generic Segmentation Offload in"
                        " csum forwarding engine.\n\n"

                        "set gso segsz (length)\n"
                        "    Set max packet length for output GSO segments,"
                        " including packet header and payload.\n\n"

                        "show port (port_id) gso\n"
                        "    Show GSO configuration.\n\n"
#endif

                        "set fwd (%s)\n"
                        "    Set packet forwarding mode.\n\n"

                        "mac_addr add (port_id) (XX:XX:XX:XX:XX:XX)\n"
                        "    Add a MAC address on port_id.\n\n"

                        "mac_addr remove (port_id) (XX:XX:XX:XX:XX:XX)\n"
                        "    Remove a MAC address from port_id.\n\n"

                        "mac_addr set (port_id) (XX:XX:XX:XX:XX:XX)\n"
                        "    Set the default MAC address for port_id.\n\n"

                        "mac_addr add port (port_id) vf (vf_id) (mac_address)\n"
                        "    Add a MAC address for a VF on the port.\n\n"

                        "set vf mac addr (port_id) (vf_id) (XX:XX:XX:XX:XX:XX)\n"
                        "    Set the MAC address for a VF from the PF.\n\n"

                        "set eth-peer (port_id) (peer_addr)\n"
                        "    set the peer address for certain port.\n\n"

                        "set port (port_id) uta (mac_address|all) (on|off)\n"
                        "    Add/Remove a or all unicast hash filter(s)"
                        "from port X.\n\n"

                        "set promisc (port_id|all) (on|off)\n"
                        "    Set the promiscuous mode on port_id, or all.\n\n"

                        "set allmulti (port_id|all) (on|off)\n"
                        "    Set the allmulti mode on port_id, or all.\n\n"

                        "set vf promisc (port_id) (vf_id) (on|off)\n"
                        "    Set unicast promiscuous mode for a VF from the PF.\n\n"

                        "set vf allmulti (port_id) (vf_id) (on|off)\n"
                        "    Set multicast promiscuous mode for a VF from the PF.\n\n"

                        "set flow_ctrl rx (on|off) tx (on|off) (high_water)"
                        " (low_water) (pause_time) (send_xon) mac_ctrl_frame_fwd"
                        " (on|off) autoneg (on|off) (port_id)\n"
                        "set flow_ctrl rx (on|off) (portid)\n"
                        "set flow_ctrl tx (on|off) (portid)\n"
                        "set flow_ctrl high_water (high_water) (portid)\n"
                        "set flow_ctrl low_water (low_water) (portid)\n"
                        "set flow_ctrl pause_time (pause_time) (portid)\n"
                        "set flow_ctrl send_xon (send_xon) (portid)\n"
                        "set flow_ctrl mac_ctrl_frame_fwd (on|off) (portid)\n"
                        "set flow_ctrl autoneg (on|off) (port_id)\n"
                        "    Set the link flow control parameter on a port.\n\n"

                        "set pfc_ctrl rx (on|off) tx (on|off) (high_water)"
                        " (low_water) (pause_time) (priority) (port_id)\n"
                        "    Set the priority flow control parameter on a"
                        " port.\n\n"

                        "set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n"
                        "    Set statistics mapping (qmapping 0..15) for RX/TX"
                        " queue on port.\n"
                        "    e.g., 'set stat_qmap rx 0 2 5' sets rx queue 2"
                        " on port 0 to mapping 5.\n\n"

                        "set xstats-hide-zero on|off\n"
                        "    Set the option to hide the zero values"
                        " for xstats display.\n"

                        "set record-core-cycles on|off\n"
                        "    Set the option to enable measurement of CPU cycles.\n"

                        "set record-burst-stats on|off\n"
                        "    Set the option to enable display of RX and TX bursts.\n"

                        "set port (port_id) vf (vf_id) rx|tx on|off\n"
                        "    Enable/Disable a VF receive/tranmit from a port\n\n"

                        "set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM"
                        "|MPE) (on|off)\n"
                        "    AUPE:accepts untagged VLAN;"
                        "ROPE:accept unicast hash\n\n"
                        "    BAM:accepts broadcast packets;"
                        "MPE:accepts all multicast packets\n\n"
                        "    Enable/Disable a VF receive mode of a port\n\n"

                        "set port (port_id) queue (queue_id) rate (rate_num)\n"
                        "    Set rate limit for a queue of a port\n\n"

                        "set port (port_id) vf (vf_id) rate (rate_num) "
                        "queue_mask (queue_mask_value)\n"
                        "    Set rate limit for queues in VF of a port\n\n"

                        "set flush_rx (on|off)\n"
                        "   Flush (default) or don't flush RX streams before"
                        " forwarding. Mainly used with PCAP drivers.\n\n"

                        "set bypass mode (normal|bypass|isolate) (port_id)\n"
                        "   Set the bypass mode for the lowest port on bypass enabled"
                        " NIC.\n\n"

                        "set bypass event (timeout|os_on|os_off|power_on|power_off) "
                        "mode (normal|bypass|isolate) (port_id)\n"
                        "   Set the event required to initiate specified bypass mode for"
                        " the lowest port on a bypass enabled NIC where:\n"
                        "       timeout   = enable bypass after watchdog timeout.\n"
                        "       os_on     = enable bypass when OS/board is powered on.\n"
                        "       os_off    = enable bypass when OS/board is powered off.\n"
                        "       power_on  = enable bypass when power supply is turned on.\n"
                        "       power_off = enable bypass when power supply is turned off."
                        "\n\n"

                        "set bypass timeout (0|1.5|2|3|4|8|16|32)\n"
                        "   Set the bypass watchdog timeout to 'n' seconds"
                        " where 0 = instant.\n\n"

                        "show bypass config (port_id)\n"
                        "   Show the bypass configuration for a bypass enabled NIC"
                        " using the lowest port on the NIC.\n\n"

#ifdef RTE_NET_BOND
                        "create bonded device (mode) (socket)\n"
                        "       Create a new bonded device with specific bonding mode and socket.\n\n"

                        "add bonding slave (slave_id) (port_id)\n"
                        "       Add a slave device to a bonded device.\n\n"

                        "remove bonding slave (slave_id) (port_id)\n"
                        "       Remove a slave device from a bonded device.\n\n"

                        "set bonding mode (value) (port_id)\n"
                        "       Set the bonding mode on a bonded device.\n\n"

                        "set bonding primary (slave_id) (port_id)\n"
                        "       Set the primary slave for a bonded device.\n\n"

                        "show bonding config (port_id)\n"
                        "       Show the bonding config for port_id.\n\n"

                        "show bonding lacp info (port_id)\n"
                        "       Show the bonding lacp information for port_id.\n\n"

                        "set bonding mac_addr (port_id) (address)\n"
                        "       Set the MAC address of a bonded device.\n\n"

                        "set bonding mode IEEE802.3AD aggregator policy (port_id) (agg_name)"
                        "       Set Aggregation mode for IEEE802.3AD (mode 4)"

                        "set bonding balance_xmit_policy (port_id) (l2|l23|l34)\n"
                        "       Set the transmit balance policy for bonded device running in balance mode.\n\n"

                        "set bonding mon_period (port_id) (value)\n"
                        "       Set the bonding link status monitoring polling period in ms.\n\n"

                        "set bonding lacp dedicated_queues <port_id> (enable|disable)\n"
                        "       Enable/disable dedicated queues for LACP control traffic.\n\n"

#endif
                        "set link-up port (port_id)\n"
                        "       Set link up for a port.\n\n"

                        "set link-down port (port_id)\n"
                        "       Set link down for a port.\n\n"

                        "ddp add (port_id) (profile_path[,backup_profile_path])\n"
                        "    Load a profile package on a port\n\n"

                        "ddp del (port_id) (backup_profile_path)\n"
                        "    Delete a profile package from a port\n\n"

                        "ptype mapping get (port_id) (valid_only)\n"
                        "    Get ptype mapping on a port\n\n"

                        "ptype mapping replace (port_id) (target) (mask) (pky_type)\n"
                        "    Replace target with the pkt_type in ptype mapping\n\n"

                        "ptype mapping reset (port_id)\n"
                        "    Reset ptype mapping on a port\n\n"

                        "ptype mapping update (port_id) (hw_ptype) (sw_ptype)\n"
                        "    Update a ptype mapping item on a port\n\n"

                        "set port (port_id) ptype_mask (ptype_mask)\n"
                        "    set packet types classification for a specific port\n\n"

                        "set port (port_id) queue-region region_id (value) "
                        "queue_start_index (value) queue_num (value)\n"
                        "    Set a queue region on a port\n\n"

                        "set port (port_id) queue-region region_id (value) "
                        "flowtype (value)\n"
                        "    Set a flowtype region index on a port\n\n"

                        "set port (port_id) queue-region UP (value) region_id (value)\n"
                        "    Set the mapping of User Priority to "
                        "queue region on a port\n\n"

                        "set port (port_id) queue-region flush (on|off)\n"
                        "    flush all queue region related configuration\n\n"

                        "show port meter cap (port_id)\n"
                        "    Show port meter capability information\n\n"

                        "add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs) (packet_mode)\n"
                        "    meter profile add - srtcm rfc 2697\n\n"

                        "add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs) (packet_mode)\n"
                        "    meter profile add - trtcm rfc 2698\n\n"

                        "add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs) (packet_mode)\n"
                        "    meter profile add - trtcm rfc 4115\n\n"

                        "del port meter profile (port_id) (profile_id)\n"
                        "    meter profile delete\n\n"

                        "create port meter (port_id) (mtr_id) (profile_id) (policy_id) (meter_enable)\n"
                        "(stats_mask) (shared) (use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
                        "(dscp_tbl_entry63)]\n"
                        "    meter create\n\n"

                        "enable port meter (port_id) (mtr_id)\n"
                        "    meter enable\n\n"

                        "disable port meter (port_id) (mtr_id)\n"
                        "    meter disable\n\n"

                        "del port meter (port_id) (mtr_id)\n"
                        "    meter delete\n\n"

                        "add port meter policy (port_id) (policy_id) g_actions (actions)\n"
                        "y_actions (actions) r_actions (actions)\n"
                        "    meter policy add\n\n"

                        "del port meter policy (port_id) (policy_id)\n"
                        "    meter policy delete\n\n"

                        "set port meter profile (port_id) (mtr_id) (profile_id)\n"
                        "    meter update meter profile\n\n"

                        "set port meter dscp table (port_id) (mtr_id) [(dscp_tbl_entry0)\n"
                        "(dscp_tbl_entry1)...(dscp_tbl_entry63)]\n"
                        "    update meter dscp table entries\n\n"

                        "set port meter policer action (port_id) (mtr_id) (action_mask)\n"
                        "(action0) [(action1) (action2)]\n"
                        "    meter update policer action\n\n"

                        "set port meter stats mask (port_id) (mtr_id) (stats_mask)\n"
                        "    meter update stats\n\n"

                        "show port (port_id) queue-region\n"
                        "    show all queue region related configuration info\n\n"

                        "set port (port_id) fec_mode auto|off|rs|baser\n"
                        "    set fec mode for a specific port\n\n"

                        , list_pkt_forwarding_modes()
                );
        }

        if (show_all || !strcmp(res->section, "ports")) {

                cmdline_printf(
                        cl,
                        "\n"
                        "Port Operations:\n"
                        "----------------\n\n"

                        "port start (port_id|all)\n"
                        "    Start all ports or port_id.\n\n"

                        "port stop (port_id|all)\n"
                        "    Stop all ports or port_id.\n\n"

                        "port close (port_id|all)\n"
                        "    Close all ports or port_id.\n\n"

                        "port reset (port_id|all)\n"
                        "    Reset all ports or port_id.\n\n"

                        "port attach (ident)\n"
                        "    Attach physical or virtual dev by pci address or virtual device name\n\n"

                        "port detach (port_id)\n"
                        "    Detach physical or virtual dev by port_id\n\n"

                        "port config (port_id|all)"
                        " speed (10|100|1000|10000|25000|40000|50000|100000|200000|auto)"
                        " duplex (half|full|auto)\n"
                        "    Set speed and duplex for all ports or port_id\n\n"

                        "port config (port_id|all) loopback (mode)\n"
                        "    Set loopback mode for all ports or port_id\n\n"

                        "port config all (rxq|txq|rxd|txd) (value)\n"
                        "    Set number for rxq/txq/rxd/txd.\n\n"

                        "port config all max-pkt-len (value)\n"
                        "    Set the max packet length.\n\n"

                        "port config all max-lro-pkt-size (value)\n"
                        "    Set the max LRO aggregated packet size.\n\n"

                        "port config all drop-en (on|off)\n"
                        "    Enable or disable packet drop on all RX queues of all ports when no "
                        "receive buffers available.\n\n"

                        "port config all rss (all|default|ip|tcp|udp|sctp|"
                        "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|"
                        "level-outer|level-inner|<flowtype_id>)\n"
                        "    Set the RSS mode.\n\n"

                        "port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
                        "    Set the RSS redirection table.\n\n"

                        "port config (port_id) dcb vt (on|off) (traffic_class)"
                        " pfc (on|off)\n"
                        "    Set the DCB mode.\n\n"

                        "port config all burst (value)\n"
                        "    Set the number of packets per burst.\n\n"

                        "port config all (txpt|txht|txwt|rxpt|rxht|rxwt)"
                        " (value)\n"
                        "    Set the ring prefetch/host/writeback threshold"
                        " for tx/rx queue.\n\n"

                        "port config all (txfreet|txrst|rxfreet) (value)\n"
                        "    Set free threshold for rx/tx, or set"
                        " tx rs bit threshold.\n\n"
                        "port config mtu X value\n"
                        "    Set the MTU of port X to a given value\n\n"

                        "port config (port_id) (rxq|txq) (queue_id) ring_size (value)\n"
                        "    Set a rx/tx queue's ring size configuration, the new"
                        " value will take effect after command that (re-)start the port"
                        " or command that setup the specific queue\n\n"

                        "port (port_id) (rxq|txq) (queue_id) (start|stop)\n"
                        "    Start/stop a rx/tx queue of port X. Only take effect"
                        " when port X is started\n\n"

                        "port (port_id) (rxq|txq) (queue_id) deferred_start (on|off)\n"
                        "    Switch on/off a deferred start of port X rx/tx queue. Only"
                        " take effect when port X is stopped.\n\n"

                        "port (port_id) (rxq|txq) (queue_id) setup\n"
                        "    Setup a rx/tx queue of port X.\n\n"

                        "port config (port_id) pctype mapping reset\n"
                        "    Reset flow type to pctype mapping on a port\n\n"

                        "port config (port_id) pctype mapping update"
                        " (pctype_id_0[,pctype_id_1]*) (flow_type_id)\n"
                        "    Update a flow type to pctype mapping item on a port\n\n"

                        "port config (port_id) pctype (pctype_id) hash_inset|"
                        "fdir_inset|fdir_flx_inset get|set|clear field\n"
                        " (field_idx)\n"
                        "    Configure RSS|FDIR|FDIR_FLX input set for some pctype\n\n"

                        "port config (port_id) pctype (pctype_id) hash_inset|"
                        "fdir_inset|fdir_flx_inset clear all"
                        "    Clear RSS|FDIR|FDIR_FLX input set completely for some pctype\n\n"

                        "port config (port_id) udp_tunnel_port add|rm vxlan|geneve|ecpri (udp_port)\n\n"
                        "    Add/remove UDP tunnel port for tunneling offload\n\n"

                        "port config <port_id> rx_offload vlan_strip|"
                        "ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
                        "outer_ipv4_cksum|macsec_strip|header_split|"
                        "vlan_filter|vlan_extend|jumbo_frame|scatter|"
                        "buffer_split|timestamp|security|keep_crc on|off\n"
                        "     Enable or disable a per port Rx offloading"
                        " on all Rx queues of a port\n\n"

                        "port (port_id) rxq (queue_id) rx_offload vlan_strip|"
                        "ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
                        "outer_ipv4_cksum|macsec_strip|header_split|"
                        "vlan_filter|vlan_extend|jumbo_frame|scatter|"
                        "buffer_split|timestamp|security|keep_crc on|off\n"
                        "    Enable or disable a per queue Rx offloading"
                        " only on a specific Rx queue\n\n"

                        "port config (port_id) tx_offload vlan_insert|"
                        "ipv4_cksum|udp_cksum|tcp_cksum|sctp_cksum|tcp_tso|"
                        "udp_tso|outer_ipv4_cksum|qinq_insert|vxlan_tnl_tso|"
                        "gre_tnl_tso|ipip_tnl_tso|geneve_tnl_tso|"
                        "macsec_insert|mt_lockfree|multi_segs|mbuf_fast_free|"
                        "security on|off\n"
                        "    Enable or disable a per port Tx offloading"
                        " on all Tx queues of a port\n\n"

                        "port (port_id) txq (queue_id) tx_offload vlan_insert|"
                        "ipv4_cksum|udp_cksum|tcp_cksum|sctp_cksum|tcp_tso|"
                        "udp_tso|outer_ipv4_cksum|qinq_insert|vxlan_tnl_tso|"
                        "gre_tnl_tso|ipip_tnl_tso|geneve_tnl_tso|macsec_insert"
                        "|mt_lockfree|multi_segs|mbuf_fast_free|security"
                        " on|off\n"
                        "    Enable or disable a per queue Tx offloading"
                        " only on a specific Tx queue\n\n"

                        "bpf-load rx|tx (port) (queue) (J|M|B) (file_name)\n"
                        "    Load an eBPF program as a callback"
                        " for particular RX/TX queue\n\n"

                        "bpf-unload rx|tx (port) (queue)\n"
                        "    Unload previously loaded eBPF program"
                        " for particular RX/TX queue\n\n"

                        "port config (port_id) tx_metadata (value)\n"
                        "    Set Tx metadata value per port. Testpmd will add this value"
                        " to any Tx packet sent from this port\n\n"

                        "port config (port_id) dynf (name) set|clear\n"
                        "    Register a dynf and Set/clear this flag on Tx. "
                        "Testpmd will set this value to any Tx packet "
                        "sent from this port\n\n"

                        "port cleanup (port_id) txq (queue_id) (free_cnt)\n"
                        "    Cleanup txq mbufs for a specific Tx queue\n\n"
                );
        }

        if (show_all || !strcmp(res->section, "registers")) {

                cmdline_printf(
                        cl,
                        "\n"
                        "Registers:\n"
                        "----------\n\n"

                        "read reg (port_id) (address)\n"
                        "    Display value of a port register.\n\n"

                        "read regfield (port_id) (address) (bit_x) (bit_y)\n"
                        "    Display a port register bit field.\n\n"

                        "read regbit (port_id) (address) (bit_x)\n"
                        "    Display a single port register bit.\n\n"

                        "write reg (port_id) (address) (value)\n"
                        "    Set value of a port register.\n\n"

                        "write regfield (port_id) (address) (bit_x) (bit_y)"
                        " (value)\n"
                        "    Set bit field of a port register.\n\n"

                        "write regbit (port_id) (address) (bit_x) (value)\n"
                        "    Set single bit value of a port register.\n\n"
                );
        }
        if (show_all || !strcmp(res->section, "filters")) {

                cmdline_printf(
                        cl,
                        "\n"
                        "filters:\n"
                        "--------\n\n"

#ifdef RTE_NET_I40E
                        "flow_director_filter (port_id) mode raw (add|del|update)"
                        " flow (flow_id) (drop|fwd) queue (queue_id)"
                        " fd_id (fd_id_value) packet (packet file name)\n"
                        "    Add/Del a raw type flow director filter.\n\n"
#endif

                        "flow_director_mask (port_id) mode IP vlan (vlan_value)"
                        " src_mask (ipv4_src) (ipv6_src) (src_port)"
                        " dst_mask (ipv4_dst) (ipv6_dst) (dst_port)\n"
                        "    Set flow director IP mask.\n\n"

                        "flow_director_mask (port_id) mode MAC-VLAN"
                        " vlan (vlan_value)\n"
                        "    Set flow director MAC-VLAN mask.\n\n"

                        "flow_director_mask (port_id) mode Tunnel"
                        " vlan (vlan_value) mac (mac_value)"
                        " tunnel-type (tunnel_type_value)"
                        " tunnel-id (tunnel_id_value)\n"
                        "    Set flow director Tunnel mask.\n\n"

                        "flow_director_flex_payload (port_id)"
                        " (raw|l2|l3|l4) (config)\n"
                        "    Configure flex payload selection.\n\n"

                        "flow validate {port_id}"
                        " [group {group_id}] [priority {level}]"
                        " [ingress] [egress]"
                        " pattern {item} [/ {item} [...]] / end"
                        " actions {action} [/ {action} [...]] / end\n"
                        "    Check whether a flow rule can be created.\n\n"

                        "flow create {port_id}"
                        " [group {group_id}] [priority {level}]"
                        " [ingress] [egress]"
                        " pattern {item} [/ {item} [...]] / end"
                        " actions {action} [/ {action} [...]] / end\n"
                        "    Create a flow rule.\n\n"

                        "flow destroy {port_id} rule {rule_id} [...]\n"
                        "    Destroy specific flow rules.\n\n"

                        "flow flush {port_id}\n"
                        "    Destroy all flow rules.\n\n"

                        "flow query {port_id} {rule_id} {action}\n"
                        "    Query an existing flow rule.\n\n"

                        "flow list {port_id} [group {group_id}] [...]\n"
                        "    List existing flow rules sorted by priority,"
                        " filtered by group identifiers.\n\n"

                        "flow isolate {port_id} {boolean}\n"
                        "    Restrict ingress traffic to the defined"
                        " flow rules\n\n"

                        "flow aged {port_id} [destroy]\n"
                        "    List and destroy aged flows"
                        " flow rules\n\n"

                        "flow indirect_action {port_id} create"
                        " [action_id {indirect_action_id}]"
                        " [ingress] [egress]"
                        " action {action} / end\n"
                        "    Create indirect action.\n\n"

                        "flow indirect_action {port_id} update"
                        " {indirect_action_id} action {action} / end\n"
                        "    Update indirect action.\n\n"

                        "flow indirect_action {port_id} destroy"
                        " action_id {indirect_action_id} [...]\n"
                        "    Destroy specific indirect actions.\n\n"

                        "flow indirect_action {port_id} query"
                        " {indirect_action_id}\n"
                        "    Query an existing indirect action.\n\n"

                        "set vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
                        " (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
                        " (ip-dst) eth-src (eth-src) eth-dst (eth-dst)\n"
                        "       Configure the VXLAN encapsulation for flows.\n\n"

                        "set vxlan-with-vlan ip-version (ipv4|ipv6) vni (vni)"
                        " udp-src (udp-src) udp-dst (udp-dst) ip-src (ip-src)"
                        " ip-dst (ip-dst) vlan-tci (vlan-tci) eth-src (eth-src)"
                        " eth-dst (eth-dst)\n"
                        "       Configure the VXLAN encapsulation for flows.\n\n"

                        "set vxlan-tos-ttl ip-version (ipv4|ipv6) vni (vni) udp-src"
                        " (udp-src) udp-dst (udp-dst) ip-tos (ip-tos) ip-ttl (ip-ttl)"
                        " ip-src (ip-src) ip-dst (ip-dst) eth-src (eth-src)"
                        " eth-dst (eth-dst)\n"
                        "       Configure the VXLAN encapsulation for flows.\n\n"

                        "set nvgre ip-version (ipv4|ipv6) tni (tni) ip-src"
                        " (ip-src) ip-dst (ip-dst) eth-src (eth-src) eth-dst"
                        " (eth-dst)\n"
                        "       Configure the NVGRE encapsulation for flows.\n\n"

                        "set nvgre-with-vlan ip-version (ipv4|ipv6) tni (tni)"
                        " ip-src (ip-src) ip-dst (ip-dst) vlan-tci (vlan-tci)"
                        " eth-src (eth-src) eth-dst (eth-dst)\n"
                        "       Configure the NVGRE encapsulation for flows.\n\n"

                        "set raw_encap {flow items}\n"
                        "       Configure the encapsulation with raw data.\n\n"

                        "set raw_decap {flow items}\n"
                        "       Configure the decapsulation with raw data.\n\n"

                );
        }

        if (show_all || !strcmp(res->section, "traffic_management")) {
                cmdline_printf(
                        cl,
                        "\n"
                        "Traffic Management:\n"
                        "--------------\n"
                        "show port tm cap (port_id)\n"
                        "       Display the port TM capability.\n\n"

                        "show port tm level cap (port_id) (level_id)\n"
                        "       Display the port TM hierarchical level capability.\n\n"

                        "show port tm node cap (port_id) (node_id)\n"
                        "       Display the port TM node capability.\n\n"

                        "show port tm node type (port_id) (node_id)\n"
                        "       Display the port TM node type.\n\n"

                        "show port tm node stats (port_id) (node_id) (clear)\n"
                        "       Display the port TM node stats.\n\n"

                        "add port tm node shaper profile (port_id) (shaper_profile_id)"
                        " (cmit_tb_rate) (cmit_tb_size) (peak_tb_rate) (peak_tb_size)"
                        " (packet_length_adjust) (packet_mode)\n"
                        "       Add port tm node private shaper profile.\n\n"

                        "del port tm node shaper profile (port_id) (shaper_profile_id)\n"
                        "       Delete port tm node private shaper profile.\n\n"

                        "add port tm node shared shaper (port_id) (shared_shaper_id)"
                        " (shaper_profile_id)\n"
                        "       Add/update port tm node shared shaper.\n\n"

                        "del port tm node shared shaper (port_id) (shared_shaper_id)\n"
                        "       Delete port tm node shared shaper.\n\n"

                        "set port tm node shaper profile (port_id) (node_id)"
                        " (shaper_profile_id)\n"
                        "       Set port tm node shaper profile.\n\n"

                        "add port tm node wred profile (port_id) (wred_profile_id)"
                        " (color_g) (min_th_g) (max_th_g) (maxp_inv_g) (wq_log2_g)"
                        " (color_y) (min_th_y) (max_th_y) (maxp_inv_y) (wq_log2_y)"
                        " (color_r) (min_th_r) (max_th_r) (maxp_inv_r) (wq_log2_r)\n"
                        "       Add port tm node wred profile.\n\n"

                        "del port tm node wred profile (port_id) (wred_profile_id)\n"
                        "       Delete port tm node wred profile.\n\n"

                        "add port tm nonleaf node (port_id) (node_id) (parent_node_id)"
                        " (priority) (weight) (level_id) (shaper_profile_id)"
                        " (n_sp_priorities) (stats_mask) (n_shared_shapers)"
                        " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
                        "       Add port tm nonleaf node.\n\n"

                        "add port tm nonleaf node pktmode (port_id) (node_id) (parent_node_id)"
                        " (priority) (weight) (level_id) (shaper_profile_id)"
                        " (n_sp_priorities) (stats_mask) (n_shared_shapers)"
                        " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
                        "       Add port tm nonleaf node with pkt mode enabled.\n\n"

                        "add port tm leaf node (port_id) (node_id) (parent_node_id)"
                        " (priority) (weight) (level_id) (shaper_profile_id)"
                        " (cman_mode) (wred_profile_id) (stats_mask) (n_shared_shapers)"
                        " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
                        "       Add port tm leaf node.\n\n"

                        "del port tm node (port_id) (node_id)\n"
                        "       Delete port tm node.\n\n"

                        "set port tm node parent (port_id) (node_id) (parent_node_id)"
                        " (priority) (weight)\n"
                        "       Set port tm node parent.\n\n"

                        "suspend port tm node (port_id) (node_id)"
                        "       Suspend tm node.\n\n"

                        "resume port tm node (port_id) (node_id)"
                        "       Resume tm node.\n\n"

                        "port tm hierarchy commit (port_id) (clean_on_fail)\n"
                        "       Commit tm hierarchy.\n\n"

                        "set port tm mark ip_ecn (port) (green) (yellow)"
                        " (red)\n"
                        "    Enables/Disables the traffic management marking"
                        " for IP ECN (Explicit Congestion Notification)"
                        " packets on a given port\n\n"

                        "set port tm mark ip_dscp (port) (green) (yellow)"
                        " (red)\n"
                        "    Enables/Disables the traffic management marking"
                        " on the port for IP dscp packets\n\n"

                        "set port tm mark vlan_dei (port) (green) (yellow)"
                        " (red)\n"
                        "    Enables/Disables the traffic management marking"
                        " on the port for VLAN packets with DEI enabled\n\n"
                );
        }

        if (show_all || !strcmp(res->section, "devices")) {
                cmdline_printf(
                        cl,
                        "\n"
                        "Device Operations:\n"
                        "--------------\n"
                        "device detach (identifier)\n"
                        "       Detach device by identifier.\n\n"
                );
        }

}

cmdline_parse_token_string_t cmd_help_long_help =
        TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, help, "help");

cmdline_parse_token_string_t cmd_help_long_section =
        TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, section,
                        "all#control#display#config#"
                        "ports#registers#filters#traffic_management#devices");

cmdline_parse_inst_t cmd_help_long = {
        .f = cmd_help_long_parsed,
        .data = NULL,
        .help_str = "help all|control|display|config|ports|register|"
                "filters|traffic_management|devices: "
                "Show help",
        .tokens = {
                (void *)&cmd_help_long_help,
                (void *)&cmd_help_long_section,
                NULL,
        },
};


/* *** start/stop/close all ports *** */
struct cmd_operate_port_result {
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t name;
        cmdline_fixed_string_t value;
};

static void cmd_operate_port_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_operate_port_result *res = parsed_result;

        if (!strcmp(res->name, "start"))
                start_port(RTE_PORT_ALL);
        else if (!strcmp(res->name, "stop"))
                stop_port(RTE_PORT_ALL);
        else if (!strcmp(res->name, "close"))
                close_port(RTE_PORT_ALL);
        else if (!strcmp(res->name, "reset"))
                reset_port(RTE_PORT_ALL);
        else
                fprintf(stderr, "Unknown parameter\n");
}

cmdline_parse_token_string_t cmd_operate_port_all_cmd =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, keyword,
                                                                "port");
cmdline_parse_token_string_t cmd_operate_port_all_port =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, name,
                                                "start#stop#close#reset");
cmdline_parse_token_string_t cmd_operate_port_all_all =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, value, "all");

cmdline_parse_inst_t cmd_operate_port = {
        .f = cmd_operate_port_parsed,
        .data = NULL,
        .help_str = "port start|stop|close|reset all: Start/Stop/Close/Reset all ports",
        .tokens = {
                (void *)&cmd_operate_port_all_cmd,
                (void *)&cmd_operate_port_all_port,
                (void *)&cmd_operate_port_all_all,
                NULL,
        },
};

/* *** start/stop/close specific port *** */
struct cmd_operate_specific_port_result {
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t name;
        uint8_t value;
};

static void cmd_operate_specific_port_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_operate_specific_port_result *res = parsed_result;

        if (!strcmp(res->name, "start"))
                start_port(res->value);
        else if (!strcmp(res->name, "stop"))
                stop_port(res->value);
        else if (!strcmp(res->name, "close"))
                close_port(res->value);
        else if (!strcmp(res->name, "reset"))
                reset_port(res->value);
        else
                fprintf(stderr, "Unknown parameter\n");
}

cmdline_parse_token_string_t cmd_operate_specific_port_cmd =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
                                                        keyword, "port");
cmdline_parse_token_string_t cmd_operate_specific_port_port =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
                                                name, "start#stop#close#reset");
cmdline_parse_token_num_t cmd_operate_specific_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result,
                                                        value, RTE_UINT8);

cmdline_parse_inst_t cmd_operate_specific_port = {
        .f = cmd_operate_specific_port_parsed,
        .data = NULL,
        .help_str = "port start|stop|close|reset <port_id>: Start/Stop/Close/Reset port_id",
        .tokens = {
                (void *)&cmd_operate_specific_port_cmd,
                (void *)&cmd_operate_specific_port_port,
                (void *)&cmd_operate_specific_port_id,
                NULL,
        },
};

/* *** enable port setup (after attach) via iterator or event *** */
struct cmd_set_port_setup_on_result {
        cmdline_fixed_string_t set;
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t setup;
        cmdline_fixed_string_t on;
        cmdline_fixed_string_t mode;
};

static void cmd_set_port_setup_on_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_set_port_setup_on_result *res = parsed_result;

        if (strcmp(res->mode, "event") == 0)
                setup_on_probe_event = true;
        else if (strcmp(res->mode, "iterator") == 0)
                setup_on_probe_event = false;
        else
                fprintf(stderr, "Unknown mode\n");
}

cmdline_parse_token_string_t cmd_set_port_setup_on_set =
        TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
                        set, "set");
cmdline_parse_token_string_t cmd_set_port_setup_on_port =
        TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
                        port, "port");
cmdline_parse_token_string_t cmd_set_port_setup_on_setup =
        TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
                        setup, "setup");
cmdline_parse_token_string_t cmd_set_port_setup_on_on =
        TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
                        on, "on");
cmdline_parse_token_string_t cmd_set_port_setup_on_mode =
        TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
                        mode, "iterator#event");

cmdline_parse_inst_t cmd_set_port_setup_on = {
        .f = cmd_set_port_setup_on_parsed,
        .data = NULL,
        .help_str = "set port setup on iterator|event",
        .tokens = {
                (void *)&cmd_set_port_setup_on_set,
                (void *)&cmd_set_port_setup_on_port,
                (void *)&cmd_set_port_setup_on_setup,
                (void *)&cmd_set_port_setup_on_on,
                (void *)&cmd_set_port_setup_on_mode,
                NULL,
        },
};

/* *** attach a specified port *** */
struct cmd_operate_attach_port_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_multi_string_t identifier;
};

static void cmd_operate_attach_port_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_operate_attach_port_result *res = parsed_result;

        if (!strcmp(res->keyword, "attach"))
                attach_port(res->identifier);
        else
                fprintf(stderr, "Unknown parameter\n");
}

cmdline_parse_token_string_t cmd_operate_attach_port_port =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
                        port, "port");
cmdline_parse_token_string_t cmd_operate_attach_port_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
                        keyword, "attach");
cmdline_parse_token_string_t cmd_operate_attach_port_identifier =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
                        identifier, TOKEN_STRING_MULTI);

cmdline_parse_inst_t cmd_operate_attach_port = {
        .f = cmd_operate_attach_port_parsed,
        .data = NULL,
        .help_str = "port attach <identifier>: "
                "(identifier: pci address or virtual dev name)",
        .tokens = {
                (void *)&cmd_operate_attach_port_port,
                (void *)&cmd_operate_attach_port_keyword,
                (void *)&cmd_operate_attach_port_identifier,
                NULL,
        },
};

/* *** detach a specified port *** */
struct cmd_operate_detach_port_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        portid_t port_id;
};

static void cmd_operate_detach_port_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_operate_detach_port_result *res = parsed_result;

        if (!strcmp(res->keyword, "detach")) {
                RTE_ETH_VALID_PORTID_OR_RET(res->port_id);
                detach_port_device(res->port_id);
        } else {
                fprintf(stderr, "Unknown parameter\n");
        }
}

cmdline_parse_token_string_t cmd_operate_detach_port_port =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_port_result,
                        port, "port");
cmdline_parse_token_string_t cmd_operate_detach_port_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_port_result,
                        keyword, "detach");
cmdline_parse_token_num_t cmd_operate_detach_port_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_operate_detach_port_result,
                        port_id, RTE_UINT16);

cmdline_parse_inst_t cmd_operate_detach_port = {
        .f = cmd_operate_detach_port_parsed,
        .data = NULL,
        .help_str = "port detach <port_id>",
        .tokens = {
                (void *)&cmd_operate_detach_port_port,
                (void *)&cmd_operate_detach_port_keyword,
                (void *)&cmd_operate_detach_port_port_id,
                NULL,
        },
};

/* *** detach device by identifier *** */
struct cmd_operate_detach_device_result {
        cmdline_fixed_string_t device;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t identifier;
};

static void cmd_operate_detach_device_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_operate_detach_device_result *res = parsed_result;

        if (!strcmp(res->keyword, "detach"))
                detach_devargs(res->identifier);
        else
                fprintf(stderr, "Unknown parameter\n");
}

cmdline_parse_token_string_t cmd_operate_detach_device_device =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
                        device, "device");
cmdline_parse_token_string_t cmd_operate_detach_device_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
                        keyword, "detach");
cmdline_parse_token_string_t cmd_operate_detach_device_identifier =
        TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
                        identifier, NULL);

cmdline_parse_inst_t cmd_operate_detach_device = {
        .f = cmd_operate_detach_device_parsed,
        .data = NULL,
        .help_str = "device detach <identifier>:"
                "(identifier: pci address or virtual dev name)",
        .tokens = {
                (void *)&cmd_operate_detach_device_device,
                (void *)&cmd_operate_detach_device_keyword,
                (void *)&cmd_operate_detach_device_identifier,
                NULL,
        },
};
/* *** configure speed for all ports *** */
struct cmd_config_speed_all {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t item1;
        cmdline_fixed_string_t item2;
        cmdline_fixed_string_t value1;
        cmdline_fixed_string_t value2;
};

static int
parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint32_t *speed)
{

        int duplex;

        if (!strcmp(duplexstr, "half")) {
                duplex = RTE_ETH_LINK_HALF_DUPLEX;
        } else if (!strcmp(duplexstr, "full")) {
                duplex = RTE_ETH_LINK_FULL_DUPLEX;
        } else if (!strcmp(duplexstr, "auto")) {
                duplex = RTE_ETH_LINK_FULL_DUPLEX;
        } else {
                fprintf(stderr, "Unknown duplex parameter\n");
                return -1;
        }

        if (!strcmp(speedstr, "10")) {
                *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ?
                                RTE_ETH_LINK_SPEED_10M_HD : RTE_ETH_LINK_SPEED_10M;
        } else if (!strcmp(speedstr, "100")) {
                *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ?
                                RTE_ETH_LINK_SPEED_100M_HD : RTE_ETH_LINK_SPEED_100M;
        } else {
                if (duplex != RTE_ETH_LINK_FULL_DUPLEX) {
                        fprintf(stderr, "Invalid speed/duplex parameters\n");
                        return -1;
                }
                if (!strcmp(speedstr, "1000")) {
                        *speed = RTE_ETH_LINK_SPEED_1G;
                } else if (!strcmp(speedstr, "10000")) {
                        *speed = RTE_ETH_LINK_SPEED_10G;
                } else if (!strcmp(speedstr, "25000")) {
                        *speed = RTE_ETH_LINK_SPEED_25G;
                } else if (!strcmp(speedstr, "40000")) {
                        *speed = RTE_ETH_LINK_SPEED_40G;
                } else if (!strcmp(speedstr, "50000")) {
                        *speed = RTE_ETH_LINK_SPEED_50G;
                } else if (!strcmp(speedstr, "100000")) {
                        *speed = RTE_ETH_LINK_SPEED_100G;
                } else if (!strcmp(speedstr, "200000")) {
                        *speed = RTE_ETH_LINK_SPEED_200G;
                } else if (!strcmp(speedstr, "auto")) {
                        *speed = RTE_ETH_LINK_SPEED_AUTONEG;
                } else {
                        fprintf(stderr, "Unknown speed parameter\n");
                        return -1;
                }
        }

        if (*speed != RTE_ETH_LINK_SPEED_AUTONEG)
                *speed |= RTE_ETH_LINK_SPEED_FIXED;

        return 0;
}

static void
cmd_config_speed_all_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_speed_all *res = parsed_result;
        uint32_t link_speed;
        portid_t pid;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        if (parse_and_check_speed_duplex(res->value1, res->value2,
                        &link_speed) < 0)
                return;

        RTE_ETH_FOREACH_DEV(pid) {
                ports[pid].dev_conf.link_speeds = link_speed;
        }

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_speed_all_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, port, "port");
cmdline_parse_token_string_t cmd_config_speed_all_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, keyword,
                                                        "config");
cmdline_parse_token_string_t cmd_config_speed_all_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, all, "all");
cmdline_parse_token_string_t cmd_config_speed_all_item1 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item1, "speed");
cmdline_parse_token_string_t cmd_config_speed_all_value1 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value1,
                                "10#100#1000#10000#25000#40000#50000#100000#200000#auto");
cmdline_parse_token_string_t cmd_config_speed_all_item2 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item2, "duplex");
cmdline_parse_token_string_t cmd_config_speed_all_value2 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value2,
                                                "half#full#auto");

cmdline_parse_inst_t cmd_config_speed_all = {
        .f = cmd_config_speed_all_parsed,
        .data = NULL,
        .help_str = "port config all speed "
                "10|100|1000|10000|25000|40000|50000|100000|200000|auto duplex "
                                                        "half|full|auto",
        .tokens = {
                (void *)&cmd_config_speed_all_port,
                (void *)&cmd_config_speed_all_keyword,
                (void *)&cmd_config_speed_all_all,
                (void *)&cmd_config_speed_all_item1,
                (void *)&cmd_config_speed_all_value1,
                (void *)&cmd_config_speed_all_item2,
                (void *)&cmd_config_speed_all_value2,
                NULL,
        },
};

/* *** configure speed for specific port *** */
struct cmd_config_speed_specific {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        portid_t id;
        cmdline_fixed_string_t item1;
        cmdline_fixed_string_t item2;
        cmdline_fixed_string_t value1;
        cmdline_fixed_string_t value2;
};

static void
cmd_config_speed_specific_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_config_speed_specific *res = parsed_result;
        uint32_t link_speed;

        if (port_id_is_invalid(res->id, ENABLED_WARN))
                return;

        if (!port_is_stopped(res->id)) {
                fprintf(stderr, "Please stop port %d first\n", res->id);
                return;
        }

        if (parse_and_check_speed_duplex(res->value1, res->value2,
                        &link_speed) < 0)
                return;

        ports[res->id].dev_conf.link_speeds = link_speed;

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}


cmdline_parse_token_string_t cmd_config_speed_specific_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, port,
                                                                "port");
cmdline_parse_token_string_t cmd_config_speed_specific_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword,
                                                                "config");
cmdline_parse_token_num_t cmd_config_speed_specific_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_speed_specific_item1 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1,
                                                                "speed");
cmdline_parse_token_string_t cmd_config_speed_specific_value1 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value1,
                                "10#100#1000#10000#25000#40000#50000#100000#200000#auto");
cmdline_parse_token_string_t cmd_config_speed_specific_item2 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2,
                                                                "duplex");
cmdline_parse_token_string_t cmd_config_speed_specific_value2 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value2,
                                                        "half#full#auto");

cmdline_parse_inst_t cmd_config_speed_specific = {
        .f = cmd_config_speed_specific_parsed,
        .data = NULL,
        .help_str = "port config <port_id> speed "
                "10|100|1000|10000|25000|40000|50000|100000|200000|auto duplex "
                                                        "half|full|auto",
        .tokens = {
                (void *)&cmd_config_speed_specific_port,
                (void *)&cmd_config_speed_specific_keyword,
                (void *)&cmd_config_speed_specific_id,
                (void *)&cmd_config_speed_specific_item1,
                (void *)&cmd_config_speed_specific_value1,
                (void *)&cmd_config_speed_specific_item2,
                (void *)&cmd_config_speed_specific_value2,
                NULL,
        },
};

/* *** configure loopback for all ports *** */
struct cmd_config_loopback_all {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t item;
        uint32_t mode;
};

static void
cmd_config_loopback_all_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_loopback_all *res = parsed_result;
        portid_t pid;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        RTE_ETH_FOREACH_DEV(pid) {
                ports[pid].dev_conf.lpbk_mode = res->mode;
        }

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_loopback_all_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, port, "port");
cmdline_parse_token_string_t cmd_config_loopback_all_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, keyword,
                                                        "config");
cmdline_parse_token_string_t cmd_config_loopback_all_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, all, "all");
cmdline_parse_token_string_t cmd_config_loopback_all_item =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, item,
                                                        "loopback");
cmdline_parse_token_num_t cmd_config_loopback_all_mode =
        TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, RTE_UINT32);

cmdline_parse_inst_t cmd_config_loopback_all = {
        .f = cmd_config_loopback_all_parsed,
        .data = NULL,
        .help_str = "port config all loopback <mode>",
        .tokens = {
                (void *)&cmd_config_loopback_all_port,
                (void *)&cmd_config_loopback_all_keyword,
                (void *)&cmd_config_loopback_all_all,
                (void *)&cmd_config_loopback_all_item,
                (void *)&cmd_config_loopback_all_mode,
                NULL,
        },
};

/* *** configure loopback for specific port *** */
struct cmd_config_loopback_specific {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        uint16_t port_id;
        cmdline_fixed_string_t item;
        uint32_t mode;
};

static void
cmd_config_loopback_specific_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_config_loopback_specific *res = parsed_result;

        if (port_id_is_invalid(res->port_id, ENABLED_WARN))
                return;

        if (!port_is_stopped(res->port_id)) {
                fprintf(stderr, "Please stop port %u first\n", res->port_id);
                return;
        }

        ports[res->port_id].dev_conf.lpbk_mode = res->mode;

        cmd_reconfig_device_queue(res->port_id, 1, 1);
}


cmdline_parse_token_string_t cmd_config_loopback_specific_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, port,
                                                                "port");
cmdline_parse_token_string_t cmd_config_loopback_specific_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, keyword,
                                                                "config");
cmdline_parse_token_num_t cmd_config_loopback_specific_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, port_id,
                                                                RTE_UINT16);
cmdline_parse_token_string_t cmd_config_loopback_specific_item =
        TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, item,
                                                                "loopback");
cmdline_parse_token_num_t cmd_config_loopback_specific_mode =
        TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, mode,
                              RTE_UINT32);

cmdline_parse_inst_t cmd_config_loopback_specific = {
        .f = cmd_config_loopback_specific_parsed,
        .data = NULL,
        .help_str = "port config <port_id> loopback <mode>",
        .tokens = {
                (void *)&cmd_config_loopback_specific_port,
                (void *)&cmd_config_loopback_specific_keyword,
                (void *)&cmd_config_loopback_specific_id,
                (void *)&cmd_config_loopback_specific_item,
                (void *)&cmd_config_loopback_specific_mode,
                NULL,
        },
};

/* *** configure txq/rxq, txd/rxd *** */
struct cmd_config_rx_tx {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint16_t value;
};

static void
cmd_config_rx_tx_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_rx_tx *res = parsed_result;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }
        if (!strcmp(res->name, "rxq")) {
                if (!res->value && !nb_txq) {
                        fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n");
                        return;
                }
                if (check_nb_rxq(res->value) != 0)
                        return;
                nb_rxq = res->value;
        }
        else if (!strcmp(res->name, "txq")) {
                if (!res->value && !nb_rxq) {
                        fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n");
                        return;
                }
                if (check_nb_txq(res->value) != 0)
                        return;
                nb_txq = res->value;
        }
        else if (!strcmp(res->name, "rxd")) {
                if (check_nb_rxd(res->value) != 0)
                        return;
                nb_rxd = res->value;
        } else if (!strcmp(res->name, "txd")) {
                if (check_nb_txd(res->value) != 0)
                        return;

                nb_txd = res->value;
        } else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        fwd_config_setup();

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_rx_tx_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, port, "port");
cmdline_parse_token_string_t cmd_config_rx_tx_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, keyword, "config");
cmdline_parse_token_string_t cmd_config_rx_tx_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, all, "all");
cmdline_parse_token_string_t cmd_config_rx_tx_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name,
                                                "rxq#txq#rxd#txd");
cmdline_parse_token_num_t cmd_config_rx_tx_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, RTE_UINT16);

cmdline_parse_inst_t cmd_config_rx_tx = {
        .f = cmd_config_rx_tx_parsed,
        .data = NULL,
        .help_str = "port config all rxq|txq|rxd|txd <value>",
        .tokens = {
                (void *)&cmd_config_rx_tx_port,
                (void *)&cmd_config_rx_tx_keyword,
                (void *)&cmd_config_rx_tx_all,
                (void *)&cmd_config_rx_tx_name,
                (void *)&cmd_config_rx_tx_value,
                NULL,
        },
};

/* *** config max packet length *** */
struct cmd_config_max_pkt_len_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint32_t value;
};

static void
cmd_config_max_pkt_len_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_config_max_pkt_len_result *res = parsed_result;
        portid_t port_id;
        int ret;

        if (strcmp(res->name, "max-pkt-len") != 0) {
                printf("Unknown parameter\n");
                return;
        }

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        RTE_ETH_FOREACH_DEV(port_id) {
                struct rte_port *port = &ports[port_id];

                if (res->value < RTE_ETHER_MIN_LEN) {
                        fprintf(stderr,
                                "max-pkt-len can not be less than %d\n",
                                RTE_ETHER_MIN_LEN);
                        return;
                }

                ret = eth_dev_info_get_print_err(port_id, &port->dev_info);
                if (ret != 0) {
                        fprintf(stderr,
                                "rte_eth_dev_info_get() failed for port %u\n",
                                port_id);
                        return;
                }

                update_mtu_from_frame_size(port_id, res->value);
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_max_pkt_len_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, port,
                                                                "port");
cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, keyword,
                                                                "config");
cmdline_parse_token_string_t cmd_config_max_pkt_len_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, all,
                                                                "all");
cmdline_parse_token_string_t cmd_config_max_pkt_len_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, name,
                                                                "max-pkt-len");
cmdline_parse_token_num_t cmd_config_max_pkt_len_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value,
                                                                RTE_UINT32);

cmdline_parse_inst_t cmd_config_max_pkt_len = {
        .f = cmd_config_max_pkt_len_parsed,
        .data = NULL,
        .help_str = "port config all max-pkt-len <value>",
        .tokens = {
                (void *)&cmd_config_max_pkt_len_port,
                (void *)&cmd_config_max_pkt_len_keyword,
                (void *)&cmd_config_max_pkt_len_all,
                (void *)&cmd_config_max_pkt_len_name,
                (void *)&cmd_config_max_pkt_len_value,
                NULL,
        },
};

/* *** config max LRO aggregated packet size *** */
struct cmd_config_max_lro_pkt_size_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint32_t value;
};

static void
cmd_config_max_lro_pkt_size_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_config_max_lro_pkt_size_result *res = parsed_result;
        portid_t pid;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        RTE_ETH_FOREACH_DEV(pid) {
                struct rte_port *port = &ports[pid];

                if (!strcmp(res->name, "max-lro-pkt-size")) {
                        if (res->value ==
                                        port->dev_conf.rxmode.max_lro_pkt_size)
                                return;

                        port->dev_conf.rxmode.max_lro_pkt_size = res->value;
                } else {
                        fprintf(stderr, "Unknown parameter\n");
                        return;
                }
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
                                 port, "port");
cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
                                 keyword, "config");
cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
                                 all, "all");
cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
                                 name, "max-lro-pkt-size");
cmdline_parse_token_num_t cmd_config_max_lro_pkt_size_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
                              value, RTE_UINT32);

cmdline_parse_inst_t cmd_config_max_lro_pkt_size = {
        .f = cmd_config_max_lro_pkt_size_parsed,
        .data = NULL,
        .help_str = "port config all max-lro-pkt-size <value>",
        .tokens = {
                (void *)&cmd_config_max_lro_pkt_size_port,
                (void *)&cmd_config_max_lro_pkt_size_keyword,
                (void *)&cmd_config_max_lro_pkt_size_all,
                (void *)&cmd_config_max_lro_pkt_size_name,
                (void *)&cmd_config_max_lro_pkt_size_value,
                NULL,
        },
};

/* *** configure port MTU *** */
struct cmd_config_mtu_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t mtu;
        portid_t port_id;
        uint16_t value;
};

static void
cmd_config_mtu_parsed(void *parsed_result,
                      __rte_unused struct cmdline *cl,
                      __rte_unused void *data)
{
        struct cmd_config_mtu_result *res = parsed_result;

        if (res->value < RTE_ETHER_MIN_LEN) {
                fprintf(stderr, "mtu cannot be less than %d\n", RTE_ETHER_MIN_LEN);
                return;
        }
        port_mtu_set(res->port_id, res->value);
}

cmdline_parse_token_string_t cmd_config_mtu_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, port,
                                 "port");
cmdline_parse_token_string_t cmd_config_mtu_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, keyword,
                                 "config");
cmdline_parse_token_string_t cmd_config_mtu_mtu =
        TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, keyword,
                                 "mtu");
cmdline_parse_token_num_t cmd_config_mtu_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id,
                                 RTE_UINT16);
cmdline_parse_token_num_t cmd_config_mtu_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value,
                                 RTE_UINT16);

cmdline_parse_inst_t cmd_config_mtu = {
        .f = cmd_config_mtu_parsed,
        .data = NULL,
        .help_str = "port config mtu <port_id> <value>",
        .tokens = {
                (void *)&cmd_config_mtu_port,
                (void *)&cmd_config_mtu_keyword,
                (void *)&cmd_config_mtu_mtu,
                (void *)&cmd_config_mtu_port_id,
                (void *)&cmd_config_mtu_value,
                NULL,
        },
};

/* *** configure rx mode *** */
struct cmd_config_rx_mode_flag {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        cmdline_fixed_string_t value;
};

static void
cmd_config_rx_mode_flag_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_config_rx_mode_flag *res = parsed_result;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        if (!strcmp(res->name, "drop-en")) {
                if (!strcmp(res->value, "on"))
                        rx_drop_en = 1;
                else if (!strcmp(res->value, "off"))
                        rx_drop_en = 0;
                else {
                        fprintf(stderr, "Unknown parameter\n");
                        return;
                }
        } else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_rx_mode_flag_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, port, "port");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, keyword,
                                                                "config");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name,
                                        "drop-en");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
                                                        "on#off");

cmdline_parse_inst_t cmd_config_rx_mode_flag = {
        .f = cmd_config_rx_mode_flag_parsed,
        .data = NULL,
        .help_str = "port config all drop-en on|off",
        .tokens = {
                (void *)&cmd_config_rx_mode_flag_port,
                (void *)&cmd_config_rx_mode_flag_keyword,
                (void *)&cmd_config_rx_mode_flag_all,
                (void *)&cmd_config_rx_mode_flag_name,
                (void *)&cmd_config_rx_mode_flag_value,
                NULL,
        },
};

/* *** configure rss *** */
struct cmd_config_rss {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        cmdline_fixed_string_t value;
};

static void
cmd_config_rss_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_rss *res = parsed_result;
        struct rte_eth_rss_conf rss_conf = { .rss_key_len = 0, };
        struct rte_eth_dev_info dev_info = { .flow_type_rss_offloads = 0, };
        int use_default = 0;
        int all_updated = 1;
        int diag;
        uint16_t i;
        int ret;

        if (!strcmp(res->value, "all"))
                rss_conf.rss_hf = RTE_ETH_RSS_ETH | RTE_ETH_RSS_VLAN | RTE_ETH_RSS_IP |
                        RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP | RTE_ETH_RSS_SCTP |
                        RTE_ETH_RSS_L2_PAYLOAD | RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_ESP |
                        RTE_ETH_RSS_AH | RTE_ETH_RSS_PFCP | RTE_ETH_RSS_GTPU |
                        RTE_ETH_RSS_ECPRI;
        else if (!strcmp(res->value, "eth"))
                rss_conf.rss_hf = RTE_ETH_RSS_ETH;
        else if (!strcmp(res->value, "vlan"))
                rss_conf.rss_hf = RTE_ETH_RSS_VLAN;
        else if (!strcmp(res->value, "ip"))
                rss_conf.rss_hf = RTE_ETH_RSS_IP;
        else if (!strcmp(res->value, "udp"))
                rss_conf.rss_hf = RTE_ETH_RSS_UDP;
        else if (!strcmp(res->value, "tcp"))
                rss_conf.rss_hf = RTE_ETH_RSS_TCP;
        else if (!strcmp(res->value, "sctp"))
                rss_conf.rss_hf = RTE_ETH_RSS_SCTP;
        else if (!strcmp(res->value, "ether"))
                rss_conf.rss_hf = RTE_ETH_RSS_L2_PAYLOAD;
        else if (!strcmp(res->value, "port"))
                rss_conf.rss_hf = RTE_ETH_RSS_PORT;
        else if (!strcmp(res->value, "vxlan"))
                rss_conf.rss_hf = RTE_ETH_RSS_VXLAN;
        else if (!strcmp(res->value, "geneve"))
                rss_conf.rss_hf = RTE_ETH_RSS_GENEVE;
        else if (!strcmp(res->value, "nvgre"))
                rss_conf.rss_hf = RTE_ETH_RSS_NVGRE;
        else if (!strcmp(res->value, "l3-pre32"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE32;
        else if (!strcmp(res->value, "l3-pre40"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE40;
        else if (!strcmp(res->value, "l3-pre48"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE48;
        else if (!strcmp(res->value, "l3-pre56"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE56;
        else if (!strcmp(res->value, "l3-pre64"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE64;
        else if (!strcmp(res->value, "l3-pre96"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE96;
        else if (!strcmp(res->value, "l3-src-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_SRC_ONLY;
        else if (!strcmp(res->value, "l3-dst-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L3_DST_ONLY;
        else if (!strcmp(res->value, "l4-src-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L4_SRC_ONLY;
        else if (!strcmp(res->value, "l4-dst-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L4_DST_ONLY;
        else if (!strcmp(res->value, "l2-src-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L2_SRC_ONLY;
        else if (!strcmp(res->value, "l2-dst-only"))
                rss_conf.rss_hf = RTE_ETH_RSS_L2_DST_ONLY;
        else if (!strcmp(res->value, "l2tpv3"))
                rss_conf.rss_hf = RTE_ETH_RSS_L2TPV3;
        else if (!strcmp(res->value, "esp"))
                rss_conf.rss_hf = RTE_ETH_RSS_ESP;
        else if (!strcmp(res->value, "ah"))
                rss_conf.rss_hf = RTE_ETH_RSS_AH;
        else if (!strcmp(res->value, "pfcp"))
                rss_conf.rss_hf = RTE_ETH_RSS_PFCP;
        else if (!strcmp(res->value, "pppoe"))
                rss_conf.rss_hf = RTE_ETH_RSS_PPPOE;
        else if (!strcmp(res->value, "gtpu"))
                rss_conf.rss_hf = RTE_ETH_RSS_GTPU;
        else if (!strcmp(res->value, "ecpri"))
                rss_conf.rss_hf = RTE_ETH_RSS_ECPRI;
        else if (!strcmp(res->value, "mpls"))
                rss_conf.rss_hf = RTE_ETH_RSS_MPLS;
        else if (!strcmp(res->value, "ipv4-chksum"))
                rss_conf.rss_hf = RTE_ETH_RSS_IPV4_CHKSUM;
        else if (!strcmp(res->value, "none"))
                rss_conf.rss_hf = 0;
        else if (!strcmp(res->value, "level-default")) {
                rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK);
                rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_PMD_DEFAULT);
        } else if (!strcmp(res->value, "level-outer")) {
                rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK);
                rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_OUTERMOST);
        } else if (!strcmp(res->value, "level-inner")) {
                rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK);
                rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_INNERMOST);
        } else if (!strcmp(res->value, "default"))
                use_default = 1;
        else if (isdigit(res->value[0]) && atoi(res->value) > 0 &&
                                                atoi(res->value) < 64)
                rss_conf.rss_hf = 1ULL << atoi(res->value);
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }
        rss_conf.rss_key = NULL;
        /* Update global configuration for RSS types. */
        RTE_ETH_FOREACH_DEV(i) {
                struct rte_eth_rss_conf local_rss_conf;

                ret = eth_dev_info_get_print_err(i, &dev_info);
                if (ret != 0)
                        return;

                if (use_default)
                        rss_conf.rss_hf = dev_info.flow_type_rss_offloads;

                local_rss_conf = rss_conf;
                local_rss_conf.rss_hf = rss_conf.rss_hf &
                        dev_info.flow_type_rss_offloads;
                if (local_rss_conf.rss_hf != rss_conf.rss_hf) {
                        printf("Port %u modified RSS hash function based on hardware support,"
                                "requested:%#"PRIx64" configured:%#"PRIx64"\n",
                                i, rss_conf.rss_hf, local_rss_conf.rss_hf);
                }
                diag = rte_eth_dev_rss_hash_update(i, &local_rss_conf);
                if (diag < 0) {
                        all_updated = 0;
                        fprintf(stderr,
                                "Configuration of RSS hash at ethernet port %d failed with error (%d): %s.\n",
                                i, -diag, strerror(-diag));
                }
        }
        if (all_updated && !use_default) {
                rss_hf = rss_conf.rss_hf;
                printf("rss_hf %#"PRIx64"\n", rss_hf);
        }
}

cmdline_parse_token_string_t cmd_config_rss_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss, port, "port");
cmdline_parse_token_string_t cmd_config_rss_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss, keyword, "config");
cmdline_parse_token_string_t cmd_config_rss_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss, all, "all");
cmdline_parse_token_string_t cmd_config_rss_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss, name, "rss");
cmdline_parse_token_string_t cmd_config_rss_value =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss, value, NULL);

cmdline_parse_inst_t cmd_config_rss = {
        .f = cmd_config_rss_parsed,
        .data = NULL,
        .help_str = "port config all rss "
                "all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
                "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|"
                "level-outer|level-inner|ipv4-chksum|<flowtype_id>",
        .tokens = {
                (void *)&cmd_config_rss_port,
                (void *)&cmd_config_rss_keyword,
                (void *)&cmd_config_rss_all,
                (void *)&cmd_config_rss_name,
                (void *)&cmd_config_rss_value,
                NULL,
        },
};

/* *** configure rss hash key *** */
struct cmd_config_rss_hash_key {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t config;
        portid_t port_id;
        cmdline_fixed_string_t rss_hash_key;
        cmdline_fixed_string_t rss_type;
        cmdline_fixed_string_t key;
};

static uint8_t
hexa_digit_to_value(char hexa_digit)
{
        if ((hexa_digit >= '0') && (hexa_digit <= '9'))
                return (uint8_t) (hexa_digit - '0');
        if ((hexa_digit >= 'a') && (hexa_digit <= 'f'))
                return (uint8_t) ((hexa_digit - 'a') + 10);
        if ((hexa_digit >= 'A') && (hexa_digit <= 'F'))
                return (uint8_t) ((hexa_digit - 'A') + 10);
        /* Invalid hexa digit */
        return 0xFF;
}

static uint8_t
parse_and_check_key_hexa_digit(char *key, int idx)
{
        uint8_t hexa_v;

        hexa_v = hexa_digit_to_value(key[idx]);
        if (hexa_v == 0xFF)
                fprintf(stderr,
                        "invalid key: character %c at position %d is not a valid hexa digit\n",
                        key[idx], idx);
        return hexa_v;
}

static void
cmd_config_rss_hash_key_parsed(void *parsed_result,
                               __rte_unused struct cmdline *cl,
                               __rte_unused void *data)
{
        struct cmd_config_rss_hash_key *res = parsed_result;
        uint8_t hash_key[RSS_HASH_KEY_LENGTH];
        uint8_t xdgt0;
        uint8_t xdgt1;
        int i;
        struct rte_eth_dev_info dev_info;
        uint8_t hash_key_size;
        uint32_t key_len;
        int ret;

        ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
        if (ret != 0)
                return;

        if (dev_info.hash_key_size > 0 &&
                        dev_info.hash_key_size <= sizeof(hash_key))
                hash_key_size = dev_info.hash_key_size;
        else {
                fprintf(stderr,
                        "dev_info did not provide a valid hash key size\n");
                return;
        }
        /* Check the length of the RSS hash key */
        key_len = strlen(res->key);
        if (key_len != (hash_key_size * 2)) {
                fprintf(stderr,
                        "key length: %d invalid - key must be a string of %d hexa-decimal numbers\n",
                        (int)key_len, hash_key_size * 2);
                return;
        }
        /* Translate RSS hash key into binary representation */
        for (i = 0; i < hash_key_size; i++) {
                xdgt0 = parse_and_check_key_hexa_digit(res->key, (i * 2));
                if (xdgt0 == 0xFF)
                        return;
                xdgt1 = parse_and_check_key_hexa_digit(res->key, (i * 2) + 1);
                if (xdgt1 == 0xFF)
                        return;
                hash_key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1);
        }
        port_rss_hash_key_update(res->port_id, res->rss_type, hash_key,
                        hash_key_size);
}

cmdline_parse_token_string_t cmd_config_rss_hash_key_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, port, "port");
cmdline_parse_token_string_t cmd_config_rss_hash_key_config =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, config,
                                 "config");
cmdline_parse_token_num_t cmd_config_rss_hash_key_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id,
                                 RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key,
                                 rss_hash_key, "rss-hash-key");
cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, rss_type,
                                 "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
                                 "ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#"
                                 "ipv6-sctp#ipv6-other#l2-payload#ipv6-ex#"
                                 "ipv6-tcp-ex#ipv6-udp-ex#"
                                 "l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#"
                                 "l2-src-only#l2-dst-only#s-vlan#c-vlan#"
                                 "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls");
cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);

cmdline_parse_inst_t cmd_config_rss_hash_key = {
        .f = cmd_config_rss_hash_key_parsed,
        .data = NULL,
        .help_str = "port config <port_id> rss-hash-key "
                "ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
                "ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
                "l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|"
                "l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|"
                "l2-src-only|l2-dst-only|s-vlan|c-vlan|"
                "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls "
                "<string of hex digits (variable length, NIC dependent)>",
        .tokens = {
                (void *)&cmd_config_rss_hash_key_port,
                (void *)&cmd_config_rss_hash_key_config,
                (void *)&cmd_config_rss_hash_key_port_id,
                (void *)&cmd_config_rss_hash_key_rss_hash_key,
                (void *)&cmd_config_rss_hash_key_rss_type,
                (void *)&cmd_config_rss_hash_key_value,
                NULL,
        },
};

/* *** cleanup txq mbufs *** */
struct cmd_cleanup_txq_mbufs_result {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t name;
        uint16_t port_id;
        uint16_t queue_id;
        uint32_t free_cnt;
};

static void
cmd_cleanup_txq_mbufs_parsed(void *parsed_result,
                             __rte_unused struct cmdline *cl,
                             __rte_unused void *data)
{
        struct cmd_cleanup_txq_mbufs_result *res = parsed_result;
        uint16_t port_id = res->port_id;
        uint16_t queue_id = res->queue_id;
        uint32_t free_cnt = res->free_cnt;
        struct rte_eth_txq_info qinfo;
        int ret;

        if (test_done == 0) {
                fprintf(stderr, "Please stop forwarding first\n");
                return;
        }

        if (rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo)) {
                fprintf(stderr, "Failed to get port %u Tx queue %u info\n",
                        port_id, queue_id);
                return;
        }

        if (qinfo.queue_state != RTE_ETH_QUEUE_STATE_STARTED) {
                fprintf(stderr, "Tx queue %u not started\n", queue_id);
                return;
        }

        ret = rte_eth_tx_done_cleanup(port_id, queue_id, free_cnt);
        if (ret < 0) {
                fprintf(stderr,
                        "Failed to cleanup mbuf for port %u Tx queue %u error desc: %s(%d)\n",
                        port_id, queue_id, strerror(-ret), ret);
                return;
        }

        printf("Cleanup port %u Tx queue %u mbuf nums: %u\n",
               port_id, queue_id, ret);
}

cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_port =
        TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port,
                                 "port");
cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_cleanup =
        TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, keyword,
                                 "cleanup");
cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port_id,
                              RTE_UINT16);
cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_txq =
        TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, name,
                                 "txq");
cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_queue_id =
        TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, queue_id,
                              RTE_UINT16);
cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_free_cnt =
        TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, free_cnt,
                              RTE_UINT32);

cmdline_parse_inst_t cmd_cleanup_txq_mbufs = {
        .f = cmd_cleanup_txq_mbufs_parsed,
        .data = NULL,
        .help_str = "port cleanup <port_id> txq <queue_id> <free_cnt>",
        .tokens = {
                (void *)&cmd_cleanup_txq_mbufs_port,
                (void *)&cmd_cleanup_txq_mbufs_cleanup,
                (void *)&cmd_cleanup_txq_mbufs_port_id,
                (void *)&cmd_cleanup_txq_mbufs_txq,
                (void *)&cmd_cleanup_txq_mbufs_queue_id,
                (void *)&cmd_cleanup_txq_mbufs_free_cnt,
                NULL,
        },
};

/* *** configure port rxq/txq ring size *** */
struct cmd_config_rxtx_ring_size {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t config;
        portid_t portid;
        cmdline_fixed_string_t rxtxq;
        uint16_t qid;
        cmdline_fixed_string_t rsize;
        uint16_t size;
};

static void
cmd_config_rxtx_ring_size_parsed(void *parsed_result,
                                 __rte_unused struct cmdline *cl,
                                 __rte_unused void *data)
{
        struct cmd_config_rxtx_ring_size *res = parsed_result;
        struct rte_port *port;
        uint8_t isrx;

        if (port_id_is_invalid(res->portid, ENABLED_WARN))
                return;

        if (res->portid == (portid_t)RTE_PORT_ALL) {
                fprintf(stderr, "Invalid port id\n");
                return;
        }

        port = &ports[res->portid];

        if (!strcmp(res->rxtxq, "rxq"))
                isrx = 1;
        else if (!strcmp(res->rxtxq, "txq"))
                isrx = 0;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        if (isrx && rx_queue_id_is_invalid(res->qid))
                return;
        else if (!isrx && tx_queue_id_is_invalid(res->qid))
                return;

        if (isrx && res->size != 0 && res->size <= rx_free_thresh) {
                fprintf(stderr,
                        "Invalid rx ring_size, must > rx_free_thresh: %d\n",
                        rx_free_thresh);
                return;
        }

        if (isrx)
                port->nb_rx_desc[res->qid] = res->size;
        else
                port->nb_tx_desc[res->qid] = res->size;

        cmd_reconfig_device_queue(res->portid, 0, 1);
}

cmdline_parse_token_string_t cmd_config_rxtx_ring_size_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
                                 port, "port");
cmdline_parse_token_string_t cmd_config_rxtx_ring_size_config =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
                                 config, "config");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_portid =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
                                 portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rxtxq =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
                                 rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_qid =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
                              qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rsize =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
                                 rsize, "ring_size");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_size =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
                              size, RTE_UINT16);

cmdline_parse_inst_t cmd_config_rxtx_ring_size = {
        .f = cmd_config_rxtx_ring_size_parsed,
        .data = NULL,
        .help_str = "port config <port_id> rxq|txq <queue_id> ring_size <value>",
        .tokens = {
                (void *)&cmd_config_rxtx_ring_size_port,
                (void *)&cmd_config_rxtx_ring_size_config,
                (void *)&cmd_config_rxtx_ring_size_portid,
                (void *)&cmd_config_rxtx_ring_size_rxtxq,
                (void *)&cmd_config_rxtx_ring_size_qid,
                (void *)&cmd_config_rxtx_ring_size_rsize,
                (void *)&cmd_config_rxtx_ring_size_size,
                NULL,
        },
};

/* *** configure port rxq/txq start/stop *** */
struct cmd_config_rxtx_queue {
        cmdline_fixed_string_t port;
        portid_t portid;
        cmdline_fixed_string_t rxtxq;
        uint16_t qid;
        cmdline_fixed_string_t opname;
};

static void
cmd_config_rxtx_queue_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_rxtx_queue *res = parsed_result;
        uint8_t isrx;
        uint8_t isstart;
        int ret = 0;

        if (test_done == 0) {
                fprintf(stderr, "Please stop forwarding first\n");
                return;
        }

        if (port_id_is_invalid(res->portid, ENABLED_WARN))
                return;

        if (port_is_started(res->portid) != 1) {
                fprintf(stderr, "Please start port %u first\n", res->portid);
                return;
        }

        if (!strcmp(res->rxtxq, "rxq"))
                isrx = 1;
        else if (!strcmp(res->rxtxq, "txq"))
                isrx = 0;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        if (isrx && rx_queue_id_is_invalid(res->qid))
                return;
        else if (!isrx && tx_queue_id_is_invalid(res->qid))
                return;

        if (!strcmp(res->opname, "start"))
                isstart = 1;
        else if (!strcmp(res->opname, "stop"))
                isstart = 0;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        if (isstart && isrx)
                ret = rte_eth_dev_rx_queue_start(res->portid, res->qid);
        else if (!isstart && isrx)
                ret = rte_eth_dev_rx_queue_stop(res->portid, res->qid);
        else if (isstart && !isrx)
                ret = rte_eth_dev_tx_queue_start(res->portid, res->qid);
        else
                ret = rte_eth_dev_tx_queue_stop(res->portid, res->qid);

        if (ret == -ENOTSUP)
                fprintf(stderr, "Function not supported in PMD\n");
}

cmdline_parse_token_string_t cmd_config_rxtx_queue_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, port, "port");
cmdline_parse_token_num_t cmd_config_rxtx_queue_portid =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_queue_rxtxq =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_rxtx_queue_qid =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_queue_opname =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, opname,
                                                "start#stop");

cmdline_parse_inst_t cmd_config_rxtx_queue = {
        .f = cmd_config_rxtx_queue_parsed,
        .data = NULL,
        .help_str = "port <port_id> rxq|txq <queue_id> start|stop",
        .tokens = {
                (void *)&cmd_config_rxtx_queue_port,
                (void *)&cmd_config_rxtx_queue_portid,
                (void *)&cmd_config_rxtx_queue_rxtxq,
                (void *)&cmd_config_rxtx_queue_qid,
                (void *)&cmd_config_rxtx_queue_opname,
                NULL,
        },
};

/* *** configure port rxq/txq deferred start on/off *** */
struct cmd_config_deferred_start_rxtx_queue {
        cmdline_fixed_string_t port;
        portid_t port_id;
        cmdline_fixed_string_t rxtxq;
        uint16_t qid;
        cmdline_fixed_string_t opname;
        cmdline_fixed_string_t state;
};

static void
cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_deferred_start_rxtx_queue *res = parsed_result;
        struct rte_port *port;
        uint8_t isrx;
        uint8_t ison;
        uint8_t needreconfig = 0;

        if (port_id_is_invalid(res->port_id, ENABLED_WARN))
                return;

        if (port_is_started(res->port_id) != 0) {
                fprintf(stderr, "Please stop port %u first\n", res->port_id);
                return;
        }

        port = &ports[res->port_id];

        isrx = !strcmp(res->rxtxq, "rxq");

        if (isrx && rx_queue_id_is_invalid(res->qid))
                return;
        else if (!isrx && tx_queue_id_is_invalid(res->qid))
                return;

        ison = !strcmp(res->state, "on");

        if (isrx && port->rx_conf[res->qid].rx_deferred_start != ison) {
                port->rx_conf[res->qid].rx_deferred_start = ison;
                needreconfig = 1;
        } else if (!isrx && port->tx_conf[res->qid].tx_deferred_start != ison) {
                port->tx_conf[res->qid].tx_deferred_start = ison;
                needreconfig = 1;
        }

        if (needreconfig)
                cmd_reconfig_device_queue(res->port_id, 0, 1);
}

cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                port, "port");
cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_rxtxq =
        TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_qid =
        TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_opname =
        TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                opname, "deferred_start");
cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_state =
        TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
                                                state, "on#off");

cmdline_parse_inst_t cmd_config_deferred_start_rxtx_queue = {
        .f = cmd_config_deferred_start_rxtx_queue_parsed,
        .data = NULL,
        .help_str = "port <port_id> rxq|txq <queue_id> deferred_start on|off",
        .tokens = {
                (void *)&cmd_config_deferred_start_rxtx_queue_port,
                (void *)&cmd_config_deferred_start_rxtx_queue_port_id,
                (void *)&cmd_config_deferred_start_rxtx_queue_rxtxq,
                (void *)&cmd_config_deferred_start_rxtx_queue_qid,
                (void *)&cmd_config_deferred_start_rxtx_queue_opname,
                (void *)&cmd_config_deferred_start_rxtx_queue_state,
                NULL,
        },
};

/* *** configure port rxq/txq setup *** */
struct cmd_setup_rxtx_queue {
        cmdline_fixed_string_t port;
        portid_t portid;
        cmdline_fixed_string_t rxtxq;
        uint16_t qid;
        cmdline_fixed_string_t setup;
};

/* Common CLI fields for queue setup */
cmdline_parse_token_string_t cmd_setup_rxtx_queue_port =
        TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, port, "port");
cmdline_parse_token_num_t cmd_setup_rxtx_queue_portid =
        TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_setup_rxtx_queue_rxtxq =
        TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_setup_rxtx_queue_qid =
        TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_setup_rxtx_queue_setup =
        TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, setup, "setup");

static void
cmd_setup_rxtx_queue_parsed(
        void *parsed_result,
        __rte_unused struct cmdline *cl,
        __rte_unused void *data)
{
        struct cmd_setup_rxtx_queue *res = parsed_result;
        struct rte_port *port;
        struct rte_mempool *mp;
        unsigned int socket_id;
        uint8_t isrx = 0;
        int ret;

        if (port_id_is_invalid(res->portid, ENABLED_WARN))
                return;

        if (res->portid == (portid_t)RTE_PORT_ALL) {
                fprintf(stderr, "Invalid port id\n");
                return;
        }

        if (!strcmp(res->rxtxq, "rxq"))
                isrx = 1;
        else if (!strcmp(res->rxtxq, "txq"))
                isrx = 0;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        if (isrx && rx_queue_id_is_invalid(res->qid)) {
                fprintf(stderr, "Invalid rx queue\n");
                return;
        } else if (!isrx && tx_queue_id_is_invalid(res->qid)) {
                fprintf(stderr, "Invalid tx queue\n");
                return;
        }

        port = &ports[res->portid];
        if (isrx) {
                socket_id = rxring_numa[res->portid];
                if (!numa_support || socket_id == NUMA_NO_CONFIG)
                        socket_id = port->socket_id;

                mp = mbuf_pool_find(socket_id, 0);
                if (mp == NULL) {
                        fprintf(stderr,
                                "Failed to setup RX queue: No mempool allocation on the socket %d\n",
                                rxring_numa[res->portid]);
                        return;
                }
                ret = rx_queue_setup(res->portid,
                                     res->qid,
                                     port->nb_rx_desc[res->qid],
                                     socket_id,
                                     &port->rx_conf[res->qid],
                                     mp);
                if (ret)
                        fprintf(stderr, "Failed to setup RX queue\n");
        } else {
                socket_id = txring_numa[res->portid];
                if (!numa_support || socket_id == NUMA_NO_CONFIG)
                        socket_id = port->socket_id;

                if (port->nb_tx_desc[res->qid] < tx_pkt_nb_segs) {
                        fprintf(stderr,
                                "Failed to setup TX queue: not enough descriptors\n");
                        return;
                }
                ret = rte_eth_tx_queue_setup(res->portid,
                                             res->qid,
                                             port->nb_tx_desc[res->qid],
                                             socket_id,
                                             &port->tx_conf[res->qid]);
                if (ret)
                        fprintf(stderr, "Failed to setup TX queue\n");
        }
}

cmdline_parse_inst_t cmd_setup_rxtx_queue = {
        .f = cmd_setup_rxtx_queue_parsed,
        .data = NULL,
        .help_str = "port <port_id> rxq|txq <queue_idx> setup",
        .tokens = {
                (void *)&cmd_setup_rxtx_queue_port,
                (void *)&cmd_setup_rxtx_queue_portid,
                (void *)&cmd_setup_rxtx_queue_rxtxq,
                (void *)&cmd_setup_rxtx_queue_qid,
                (void *)&cmd_setup_rxtx_queue_setup,
                NULL,
        },
};


/* *** Configure RSS RETA *** */
struct cmd_config_rss_reta {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        portid_t port_id;
        cmdline_fixed_string_t name;
        cmdline_fixed_string_t list_name;
        cmdline_fixed_string_t list_of_items;
};

static int
parse_reta_config(const char *str,
                  struct rte_eth_rss_reta_entry64 *reta_conf,
                  uint16_t nb_entries)
{
        int i;
        unsigned size;
        uint16_t hash_index, idx, shift;
        uint16_t nb_queue;
        char s[256];
        const char *p, *p0 = str;
        char *end;
        enum fieldnames {
                FLD_HASH_INDEX = 0,
                FLD_QUEUE,
                _NUM_FLD
        };
        unsigned long int_fld[_NUM_FLD];
        char *str_fld[_NUM_FLD];

        while ((p = strchr(p0,'(')) != NULL) {
                ++p;
                if((p0 = strchr(p,')')) == NULL)
                        return -1;

                size = p0 - p;
                if(size >= sizeof(s))
                        return -1;

                snprintf(s, sizeof(s), "%.*s", size, p);
                if (rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ',') != _NUM_FLD)
                        return -1;
                for (i = 0; i < _NUM_FLD; i++) {
                        errno = 0;
                        int_fld[i] = strtoul(str_fld[i], &end, 0);
                        if (errno != 0 || end == str_fld[i] ||
                                        int_fld[i] > 65535)
                                return -1;
                }

                hash_index = (uint16_t)int_fld[FLD_HASH_INDEX];
                nb_queue = (uint16_t)int_fld[FLD_QUEUE];

                if (hash_index >= nb_entries) {
                        fprintf(stderr, "Invalid RETA hash index=%d\n",
                                hash_index);
                        return -1;
                }

                idx = hash_index / RTE_ETH_RETA_GROUP_SIZE;
                shift = hash_index % RTE_ETH_RETA_GROUP_SIZE;
                reta_conf[idx].mask |= (1ULL << shift);
                reta_conf[idx].reta[shift] = nb_queue;
        }

        return 0;
}

static void
cmd_set_rss_reta_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        int ret;
        struct rte_eth_dev_info dev_info;
        struct rte_eth_rss_reta_entry64 reta_conf[8];
        struct cmd_config_rss_reta *res = parsed_result;

        ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
        if (ret != 0)
                return;

        if (dev_info.reta_size == 0) {
                fprintf(stderr,
                        "Redirection table size is 0 which is invalid for RSS\n");
                return;
        } else
                printf("The reta size of port %d is %u\n",
                        res->port_id, dev_info.reta_size);
        if (dev_info.reta_size > RTE_ETH_RSS_RETA_SIZE_512) {
                fprintf(stderr,
                        "Currently do not support more than %u entries of redirection table\n",
                        RTE_ETH_RSS_RETA_SIZE_512);
                return;
        }

        memset(reta_conf, 0, sizeof(reta_conf));
        if (!strcmp(res->list_name, "reta")) {
                if (parse_reta_config(res->list_of_items, reta_conf,
                                                dev_info.reta_size)) {
                        fprintf(stderr,
                                "Invalid RSS Redirection Table config entered\n");
                        return;
                }
                ret = rte_eth_dev_rss_reta_update(res->port_id,
                                reta_conf, dev_info.reta_size);
                if (ret != 0)
                        fprintf(stderr,
                                "Bad redirection table parameter, return code = %d\n",
                                ret);
        }
}

cmdline_parse_token_string_t cmd_config_rss_reta_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, port, "port");
cmdline_parse_token_string_t cmd_config_rss_reta_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, keyword, "config");
cmdline_parse_token_num_t cmd_config_rss_reta_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rss_reta_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, name, "rss");
cmdline_parse_token_string_t cmd_config_rss_reta_list_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_name, "reta");
cmdline_parse_token_string_t cmd_config_rss_reta_list_of_items =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_of_items,
                                 NULL);
cmdline_parse_inst_t cmd_config_rss_reta = {
        .f = cmd_set_rss_reta_parsed,
        .data = NULL,
        .help_str = "port config <port_id> rss reta <hash,queue[,hash,queue]*>",
        .tokens = {
                (void *)&cmd_config_rss_reta_port,
                (void *)&cmd_config_rss_reta_keyword,
                (void *)&cmd_config_rss_reta_port_id,
                (void *)&cmd_config_rss_reta_name,
                (void *)&cmd_config_rss_reta_list_name,
                (void *)&cmd_config_rss_reta_list_of_items,
                NULL,
        },
};

/* *** SHOW PORT RETA INFO *** */
struct cmd_showport_reta {
        cmdline_fixed_string_t show;
        cmdline_fixed_string_t port;
        portid_t port_id;
        cmdline_fixed_string_t rss;
        cmdline_fixed_string_t reta;
        uint16_t size;
        cmdline_fixed_string_t list_of_items;
};

static int
showport_parse_reta_config(struct rte_eth_rss_reta_entry64 *conf,
                           uint16_t nb_entries,
                           char *str)
{
        uint32_t size;
        const char *p, *p0 = str;
        char s[256];
        char *end;
        char *str_fld[8];
        uint16_t i;
        uint16_t num = (nb_entries + RTE_ETH_RETA_GROUP_SIZE - 1) /
                        RTE_ETH_RETA_GROUP_SIZE;
        int ret;

        p = strchr(p0, '(');
        if (p == NULL)
                return -1;
        p++;
        p0 = strchr(p, ')');
        if (p0 == NULL)
                return -1;
        size = p0 - p;
        if (size >= sizeof(s)) {
                fprintf(stderr,
                        "The string size exceeds the internal buffer size\n");
                return -1;
        }
        snprintf(s, sizeof(s), "%.*s", size, p);
        ret = rte_strsplit(s, sizeof(s), str_fld, num, ',');
        if (ret <= 0 || ret != num) {
                fprintf(stderr,
                        "The bits of masks do not match the number of reta entries: %u\n",
                        num);
                return -1;
        }
        for (i = 0; i < ret; i++)
                conf[i].mask = (uint64_t)strtoul(str_fld[i], &end, 0);

        return 0;
}

static void
cmd_showport_reta_parsed(void *parsed_result,
                         __rte_unused struct cmdline *cl,
                         __rte_unused void *data)
{
        struct cmd_showport_reta *res = parsed_result;
        struct rte_eth_rss_reta_entry64 reta_conf[8];
        struct rte_eth_dev_info dev_info;
        uint16_t max_reta_size;
        int ret;

        ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
        if (ret != 0)
                return;

        max_reta_size = RTE_MIN(dev_info.reta_size, RTE_ETH_RSS_RETA_SIZE_512);
        if (res->size == 0 || res->size > max_reta_size) {
                fprintf(stderr, "Invalid redirection table size: %u (1-%u)\n",
                        res->size, max_reta_size);
                return;
        }

        memset(reta_conf, 0, sizeof(reta_conf));
        if (showport_parse_reta_config(reta_conf, res->size,
                                res->list_of_items) < 0) {
                fprintf(stderr, "Invalid string: %s for reta masks\n",
                        res->list_of_items);
                return;
        }
        port_rss_reta_info(res->port_id, reta_conf, res->size);
}

cmdline_parse_token_string_t cmd_showport_reta_show =
        TOKEN_STRING_INITIALIZER(struct  cmd_showport_reta, show, "show");
cmdline_parse_token_string_t cmd_showport_reta_port =
        TOKEN_STRING_INITIALIZER(struct  cmd_showport_reta, port, "port");
cmdline_parse_token_num_t cmd_showport_reta_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_reta_rss =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, rss, "rss");
cmdline_parse_token_string_t cmd_showport_reta_reta =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, reta, "reta");
cmdline_parse_token_num_t cmd_showport_reta_size =
        TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_reta_list_of_items =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_reta,
                                        list_of_items, NULL);

cmdline_parse_inst_t cmd_showport_reta = {
        .f = cmd_showport_reta_parsed,
        .data = NULL,
        .help_str = "show port <port_id> rss reta <size> <mask0[,mask1]*>",
        .tokens = {
                (void *)&cmd_showport_reta_show,
                (void *)&cmd_showport_reta_port,
                (void *)&cmd_showport_reta_port_id,
                (void *)&cmd_showport_reta_rss,
                (void *)&cmd_showport_reta_reta,
                (void *)&cmd_showport_reta_size,
                (void *)&cmd_showport_reta_list_of_items,
                NULL,
        },
};

/* *** Show RSS hash configuration *** */
struct cmd_showport_rss_hash {
        cmdline_fixed_string_t show;
        cmdline_fixed_string_t port;
        portid_t port_id;
        cmdline_fixed_string_t rss_hash;
        cmdline_fixed_string_t rss_type;
        cmdline_fixed_string_t key; /* optional argument */
};

static void cmd_showport_rss_hash_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                void *show_rss_key)
{
        struct cmd_showport_rss_hash *res = parsed_result;

        port_rss_hash_conf_show(res->port_id, show_rss_key != NULL);
}

cmdline_parse_token_string_t cmd_showport_rss_hash_show =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, show, "show");
cmdline_parse_token_string_t cmd_showport_rss_hash_port =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, port, "port");
cmdline_parse_token_num_t cmd_showport_rss_hash_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id,
                                 RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash,
                                 "rss-hash");
cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key =
        TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key");

cmdline_parse_inst_t cmd_showport_rss_hash = {
        .f = cmd_showport_rss_hash_parsed,
        .data = NULL,
        .help_str = "show port <port_id> rss-hash",
        .tokens = {
                (void *)&cmd_showport_rss_hash_show,
                (void *)&cmd_showport_rss_hash_port,
                (void *)&cmd_showport_rss_hash_port_id,
                (void *)&cmd_showport_rss_hash_rss_hash,
                NULL,
        },
};

cmdline_parse_inst_t cmd_showport_rss_hash_key = {
        .f = cmd_showport_rss_hash_parsed,
        .data = (void *)1,
        .help_str = "show port <port_id> rss-hash key",
        .tokens = {
                (void *)&cmd_showport_rss_hash_show,
                (void *)&cmd_showport_rss_hash_port,
                (void *)&cmd_showport_rss_hash_port_id,
                (void *)&cmd_showport_rss_hash_rss_hash,
                (void *)&cmd_showport_rss_hash_rss_key,
                NULL,
        },
};

/* *** Configure DCB *** */
struct cmd_config_dcb {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t config;
        portid_t port_id;
        cmdline_fixed_string_t dcb;
        cmdline_fixed_string_t vt;
        cmdline_fixed_string_t vt_en;
        uint8_t num_tcs;
        cmdline_fixed_string_t pfc;
        cmdline_fixed_string_t pfc_en;
};

static void
cmd_config_dcb_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_dcb *res = parsed_result;
        struct rte_eth_dcb_info dcb_info;
        portid_t port_id = res->port_id;
        struct rte_port *port;
        uint8_t pfc_en;
        int ret;

        port = &ports[port_id];
        /** Check if the port is not started **/
        if (port->port_status != RTE_PORT_STOPPED) {
                fprintf(stderr, "Please stop port %d first\n", port_id);
                return;
        }

        if ((res->num_tcs != RTE_ETH_4_TCS) && (res->num_tcs != RTE_ETH_8_TCS)) {
                fprintf(stderr,
                        "The invalid number of traffic class, only 4 or 8 allowed.\n");
                return;
        }

        if (nb_fwd_lcores < res->num_tcs) {
                fprintf(stderr,
                        "nb_cores shouldn't be less than number of TCs.\n");
                return;
        }

        /* Check whether the port supports the report of DCB info. */
        ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info);
        if (ret == -ENOTSUP) {
                fprintf(stderr, "rte_eth_dev_get_dcb_info not supported.\n");
                return;
        }

        if (!strncmp(res->pfc_en, "on", 2))
                pfc_en = 1;
        else
                pfc_en = 0;

        /* DCB in VT mode */
        if (!strncmp(res->vt_en, "on", 2))
                ret = init_port_dcb_config(port_id, DCB_VT_ENABLED,
                                (enum rte_eth_nb_tcs)res->num_tcs,
                                pfc_en);
        else
                ret = init_port_dcb_config(port_id, DCB_ENABLED,
                                (enum rte_eth_nb_tcs)res->num_tcs,
                                pfc_en);
        if (ret != 0) {
                fprintf(stderr, "Cannot initialize network ports.\n");
                return;
        }

        fwd_config_setup();

        cmd_reconfig_device_queue(port_id, 1, 1);
}

cmdline_parse_token_string_t cmd_config_dcb_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, port, "port");
cmdline_parse_token_string_t cmd_config_dcb_config =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config");
cmdline_parse_token_num_t cmd_config_dcb_port_id =
        TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_dcb_dcb =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb");
cmdline_parse_token_string_t cmd_config_dcb_vt =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt, "vt");
cmdline_parse_token_string_t cmd_config_dcb_vt_en =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off");
cmdline_parse_token_num_t cmd_config_dcb_num_tcs =
        TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, RTE_UINT8);
cmdline_parse_token_string_t cmd_config_dcb_pfc=
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc");
cmdline_parse_token_string_t cmd_config_dcb_pfc_en =
        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc_en, "on#off");

cmdline_parse_inst_t cmd_config_dcb = {
        .f = cmd_config_dcb_parsed,
        .data = NULL,
        .help_str = "port config <port-id> dcb vt on|off <num_tcs> pfc on|off",
        .tokens = {
                (void *)&cmd_config_dcb_port,
                (void *)&cmd_config_dcb_config,
                (void *)&cmd_config_dcb_port_id,
                (void *)&cmd_config_dcb_dcb,
                (void *)&cmd_config_dcb_vt,
                (void *)&cmd_config_dcb_vt_en,
                (void *)&cmd_config_dcb_num_tcs,
                (void *)&cmd_config_dcb_pfc,
                (void *)&cmd_config_dcb_pfc_en,
                NULL,
        },
};

/* *** configure number of packets per burst *** */
struct cmd_config_burst {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint16_t value;
};

static void
cmd_config_burst_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_burst *res = parsed_result;
        struct rte_eth_dev_info dev_info;
        uint16_t rec_nb_pkts;
        int ret;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        if (!strcmp(res->name, "burst")) {
                if (res->value == 0) {
                        /* If user gives a value of zero, query the PMD for
                         * its recommended Rx burst size. Testpmd uses a single
                         * size for all ports, so assume all ports are the same
                         * NIC model and use the values from Port 0.
                         */
                        ret = eth_dev_info_get_print_err(0, &dev_info);
                        if (ret != 0)
                                return;

                        rec_nb_pkts = dev_info.default_rxportconf.burst_size;

                        if (rec_nb_pkts == 0) {
                                printf("PMD does not recommend a burst size.\n"
                                        "User provided value must be between"
                                        " 1 and %d\n", MAX_PKT_BURST);
                                return;
                        } else if (rec_nb_pkts > MAX_PKT_BURST) {
                                printf("PMD recommended burst size of %d"
                                        " exceeds maximum value of %d\n",
                                        rec_nb_pkts, MAX_PKT_BURST);
                                return;
                        }
                        printf("Using PMD-provided burst value of %d\n",
                                rec_nb_pkts);
                        nb_pkt_per_burst = rec_nb_pkts;
                } else if (res->value > MAX_PKT_BURST) {
                        fprintf(stderr, "burst must be >= 1 && <= %d\n",
                                MAX_PKT_BURST);
                        return;
                } else
                        nb_pkt_per_burst = res->value;
        } else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_burst_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_burst, port, "port");
cmdline_parse_token_string_t cmd_config_burst_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_burst, keyword, "config");
cmdline_parse_token_string_t cmd_config_burst_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_burst, all, "all");
cmdline_parse_token_string_t cmd_config_burst_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst");
cmdline_parse_token_num_t cmd_config_burst_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, RTE_UINT16);

cmdline_parse_inst_t cmd_config_burst = {
        .f = cmd_config_burst_parsed,
        .data = NULL,
        .help_str = "port config all burst <value>",
        .tokens = {
                (void *)&cmd_config_burst_port,
                (void *)&cmd_config_burst_keyword,
                (void *)&cmd_config_burst_all,
                (void *)&cmd_config_burst_name,
                (void *)&cmd_config_burst_value,
                NULL,
        },
};

/* *** configure rx/tx queues *** */
struct cmd_config_thresh {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint8_t value;
};

static void
cmd_config_thresh_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_thresh *res = parsed_result;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        if (!strcmp(res->name, "txpt"))
                tx_pthresh = res->value;
        else if(!strcmp(res->name, "txht"))
                tx_hthresh = res->value;
        else if(!strcmp(res->name, "txwt"))
                tx_wthresh = res->value;
        else if(!strcmp(res->name, "rxpt"))
                rx_pthresh = res->value;
        else if(!strcmp(res->name, "rxht"))
                rx_hthresh = res->value;
        else if(!strcmp(res->name, "rxwt"))
                rx_wthresh = res->value;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_thresh_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, port, "port");
cmdline_parse_token_string_t cmd_config_thresh_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, keyword, "config");
cmdline_parse_token_string_t cmd_config_thresh_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, all, "all");
cmdline_parse_token_string_t cmd_config_thresh_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name,
                                "txpt#txht#txwt#rxpt#rxht#rxwt");
cmdline_parse_token_num_t cmd_config_thresh_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, RTE_UINT8);

cmdline_parse_inst_t cmd_config_thresh = {
        .f = cmd_config_thresh_parsed,
        .data = NULL,
        .help_str = "port config all txpt|txht|txwt|rxpt|rxht|rxwt <value>",
        .tokens = {
                (void *)&cmd_config_thresh_port,
                (void *)&cmd_config_thresh_keyword,
                (void *)&cmd_config_thresh_all,
                (void *)&cmd_config_thresh_name,
                (void *)&cmd_config_thresh_value,
                NULL,
        },
};

/* *** configure free/rs threshold *** */
struct cmd_config_threshold {
        cmdline_fixed_string_t port;
        cmdline_fixed_string_t keyword;
        cmdline_fixed_string_t all;
        cmdline_fixed_string_t name;
        uint16_t value;
};

static void
cmd_config_threshold_parsed(void *parsed_result,
                        __rte_unused struct cmdline *cl,
                        __rte_unused void *data)
{
        struct cmd_config_threshold *res = parsed_result;

        if (!all_ports_stopped()) {
                fprintf(stderr, "Please stop all ports first\n");
                return;
        }

        if (!strcmp(res->name, "txfreet"))
                tx_free_thresh = res->value;
        else if (!strcmp(res->name, "txrst"))
                tx_rs_thresh = res->value;
        else if (!strcmp(res->name, "rxfreet"))
                rx_free_thresh = res->value;
        else {
                fprintf(stderr, "Unknown parameter\n");
                return;
        }

        init_port_config();

        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}

cmdline_parse_token_string_t cmd_config_threshold_port =
        TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, port, "port");
cmdline_parse_token_string_t cmd_config_threshold_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, keyword,
                                                                "config");
cmdline_parse_token_string_t cmd_config_threshold_all =
        TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, all, "all");
cmdline_parse_token_string_t cmd_config_threshold_name =
        TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name,
                                                "txfreet#txrst#rxfreet");
cmdline_parse_token_num_t cmd_config_threshold_value =
        TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, RTE_UINT16);

cmdline_parse_inst_t cmd_config_threshold = {
        .f = cmd_config_threshold_parsed,
        .data = NULL,
        .help_str = "port config all txfreet|txrst|rxfreet <value>",
        .tokens = {
                (void *)&cmd_config_threshold_port,
                (void *)&cmd_config_threshold_keyword,
                (void *)&cmd_config_threshold_all,
                (void *)&cmd_config_threshold_name,
                (void *)&cmd_config_threshold_value,
                NULL,
        },
};

/* *** stop *** */
struct cmd_stop_result {
        cmdline_fixed_string_t stop;
};

static void cmd_stop_parsed(__rte_unused void *parsed_result,
                            __rte_unused struct cmdline *cl,
                            __rte_unused void *data)
{
        stop_packet_forwarding();
}

cmdline_parse_token_string_t cmd_stop_stop =
        TOKEN_STRING_INITIALIZER(struct cmd_stop_result, stop, "stop");

cmdline_parse_inst_t cmd_stop = {
        .f = cmd_stop_parsed,
        .data = NULL,
        .help_str = "stop: Stop packet forwarding",
        .tokens = {
                (void *)&cmd_stop_stop,
                NULL,
        },
};

/* *** SET CORELIST and PORTLIST CONFIGURATION *** */

unsigned int
parse_item_list(const char *str, const char *item_name, unsigned int max_items,
                unsigned int *parsed_items, int check_unique_values)
{
        unsigned int nb_item;
        unsigned int value;
        unsigned int i;
        unsigned int j;
        int value_ok;
        char c;

        /*
         * First parse all items in the list and store their value.
         */
        value = 0;
        nb_item = 0;
        value_ok = 0;
        for (i = 0; i < strnlen(str, STR_TOKEN_SIZE); i++) {
                c = str[i];
                if ((c >= '0') && (c <= '9')) {
                        value = (unsigned int) (value * 10 + (c - '0'));
                        value_ok = 1;
                        continue;
                }
                if (c != ',') {
                        fprintf(stderr, "character %c is not a decimal digit\n", c);
                        return 0;
                }
                if (! value_ok) {
                        fprintf(stderr, "No valid value before comma\n");
                        return 0;
                }
                if (nb_item < max_items) {
                        parsed_items[nb_item] = value;
                        value_ok = 0;
                        value = 0;
                }
                nb_item++;
        }
        if (nb_item >= max_items) {
                fprintf(stderr, "Number of %s = %u > %u (maximum items)\n",
                        item_name, nb_item + 1, max_items);
                return 0;
        }
        parsed_items[nb_item++] = value;
        if (! check_unique_values)
                return nb_item;

        /*
         * Then, check that all values in the list are different.
         * No optimization here...
         */
        for (i = 0; i < nb_item; i++) {
                for (j = i + 1; j < nb_item; j++) {
                        if (parsed_items[j] == parsed_items[i]) {
                                fprintf(stderr,
                                        "duplicated %s %u at index %u and %u\n",
                                        item_name, parsed_items[i], i, j);
                                return 0;
                        }
                }
        }
        return nb_item;
}

struct cmd_set_list_result {
        cmdline_fixed_string_t cmd_keyword;
        cmdline_fixed_string_t list_name;
        cmdline_fixed_string_t list_of_items;
};

static void cmd_set_list_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_set_list_result *res;
        union {
                unsigned int lcorelist[RTE_MAX_LCORE];
                unsigned int portlist[RTE_MAX_ETHPORTS];
        } parsed_items;
        unsigned int nb_item;

        if (test_done == 0) {
                fprintf(stderr, "Please stop forwarding first\n");
                return;
        }

        res = parsed_result;
        if (!strcmp(res->list_name, "corelist")) {
                nb_item = parse_item_list(res->list_of_items, "core",
                                          RTE_MAX_LCORE,
                                          parsed_items.lcorelist, 1);
                if (nb_item > 0) {
                        set_fwd_lcores_list(parsed_items.lcorelist, nb_item);
                        fwd_config_setup();
                }
                return;
        }
        if (!strcmp(res->list_name, "portlist")) {
                nb_item = parse_item_list(res->list_of_items, "port",
                                          RTE_MAX_ETHPORTS,
                                          parsed_items.portlist, 1);
                if (nb_item > 0) {
                        set_fwd_ports_list(parsed_items.portlist, nb_item);
                        fwd_config_setup();
                }
        }
}

cmdline_parse_token_string_t cmd_set_list_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, cmd_keyword,
                                 "set");
cmdline_parse_token_string_t cmd_set_list_name =
        TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_name,
                                 "corelist#portlist");
cmdline_parse_token_string_t cmd_set_list_of_items =
        TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_of_items,
                                 NULL);

cmdline_parse_inst_t cmd_set_fwd_list = {
        .f = cmd_set_list_parsed,
        .data = NULL,
        .help_str = "set corelist|portlist <list0[,list1]*>",
        .tokens = {
                (void *)&cmd_set_list_keyword,
                (void *)&cmd_set_list_name,
                (void *)&cmd_set_list_of_items,
                NULL,
        },
};

/* *** SET COREMASK and PORTMASK CONFIGURATION *** */

struct cmd_setmask_result {
        cmdline_fixed_string_t set;
        cmdline_fixed_string_t mask;
        uint64_t hexavalue;
};

static void cmd_set_mask_parsed(void *parsed_result,
                                __rte_unused struct cmdline *cl,
                                __rte_unused void *data)
{
        struct cmd_setmask_result *res = parsed_result;

        if (test_done == 0) {
                fprintf(stderr, "Please stop forwarding first\n");
                return;
        }
        if (!strcmp(res->mask, "coremask")) {
                set_fwd_lcores_mask(res->hexavalue);
                fwd_config_setup();
        } else if (!strcmp(res->mask, "portmask")) {
                set_fwd_ports_mask(res->hexavalue);
                fwd_config_setup();
        }
}

cmdline_parse_token_string_t cmd_setmask_set =
        TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, set, "set");
cmdline_parse_token_string_t cmd_setmask_mask =
        TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, mask,
                                 "coremask#portmask");
cmdline_parse_token_num_t cmd_setmask_value =
        TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, RTE_UINT64);

cmdline_parse_inst_t cmd_set_fwd_mask = {
        .f = cmd_set_mask_parsed,
        .data = NULL,
        .help_str = "set coremask|portmask <hexadecimal value>",
        .tokens = {
                (void *)&cmd_setmask_set,
                (void *)&cmd_setmask_mask,
                (void *)&cmd_setmask_value,
                NULL,
        },
};

/*
 * SET NBPORT, NBCORE, PACKET BURST, and VERBOSE LEVEL CONFIGURATION
 */
struct cmd_set_result {
        cmdline_fixed_string_t set;
        cmdline_fixed_string_t what;
        uint16_t value;
};

static void cmd_set_parsed(void *parsed_result,
                           __rte_unused struct cmdline *cl,
                           __rte_unused void *data)
{
        struct cmd_set_result *res = parsed_result;
        if (!strcmp(res->what, "nbport")) {
                set_fwd_ports_number(res->value);
                fwd_config_setup();
        } else if (!strcmp(res->what, "nbcore")) {
                set_fwd_lcores_number(res->value);
                fwd_config_setup();
        } else if (!strcmp(res->what, "burst"))
                set_nb_pkt_per_burst(res->value);
        else if (!strcmp(res->what, "verbose"))
                set_verbose_level(res->value);
}

cmdline_parse_token_string_t cmd_set_set =
        TOKEN_STRING_INITIALIZER(struct cmd_set_result, set, "set");
cmdline_parse_token_string_t cmd_set_what =
        TOKEN_STRING_INITIALIZER(struct cmd_set_result, what,
                                 "nbport#nbcore#burst#verbose");
cmdline_parse_token_num_t cmd_set_value =
        TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, RTE_UINT16);

cmdline_parse_inst_t cmd_set_numbers = {
        .f = cmd_set_parsed,
        .data = NULL,
        .help_str = "set nbport|nbcore|burst|verbose <value>",
        .tokens = {
                (void *)&cmd_set_set,
                (void *)&cmd_set_what,
                (void *)&cmd_set_value,
                NULL,
        },
};

/* *** SET LOG LEVEL CONFIGURATION *** */

struct cmd_set_log_result {
        cmdline_fixed_string_t set;
        cmdline_fixed_string_t log;
        cmdline_fixed_string_t type;
        uint32_t level;
};

static void
cmd_set_log_parsed(void *parsed_result,
                   __rte_unused struct cmdline *cl,
                   __rte_unused void *data)
{
        struct cmd_set_log_result *res;
        int ret;

        res = parsed_result;
        if (!strcmp(res->type, "global"))
                rte_log_set_global_level(res->level);
        else {
                ret = rte_log_set_level_regexp(res->type, res->level);
                if (ret < 0)
                        fprintf(stderr, "Unable to set log level\n");
        }
}

cmdline_parse_token_string_t cmd_set_log_set =
        TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, set, "set");
cmdline_parse_token_string_t cmd_set_log_log =
        TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, log, "log");
cmdline_parse_token_string_t cmd_set_log_type =
        TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, type, NULL);
cmdline_parse_token_num_t cmd_set_log_level =
        TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, RTE_UINT32);

cmdline_parse_inst_t cmd_set_log = {
        .f = cmd_set_log_parsed,
        .data = NULL,
        .help_str = "set log global|<type> <level>",
        .tokens = {
                (void *)&cmd_set_log_set,
                (void *)&cmd_set_log_log,
                (void *)&cmd_set_log_type,
                (void *)&cmd_set_log_level,
                NULL,
        },
};

/* *** SET SEGMENT OFFSETS OF RX PACKETS SPLIT *** */

struct cmd_set_rxoffs_result {
        cmdline_fixed_string_t cmd_keyword;
        cmdline_fixed_string_t rxoffs;
        cmdline_fixed_string_t seg_offsets;
};

static void
cmd_set_rxoffs_parsed(void *parsed_result,
                      __rte_unused struct cmdline *cl,
                      __rte_unused void *data)
{
        struct cmd_set_rxoffs_result *res;
        unsigned int seg_offsets[MAX_SEGS_BUFFER_SPLIT];
        unsigned int nb_segs;

        res = parsed_result;
        nb_segs = parse_item_list(res->seg_offsets, "segment offsets",
                                  MAX_SEGS_BUFFER_SPLIT, seg_offsets, 0);
        if (nb_segs > 0)
                set_rx_pkt_offsets(seg_offsets, nb_segs);
        cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
}

cmdline_parse_token_string_t cmd_set_rxoffs_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
                                 cmd_keyword, "set");
cmdline_parse_token_string_t cmd_set_rxoffs_name =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
                                 rxoffs, "rxoffs");
cmdline_parse_token_string_t cmd_set_rxoffs_offsets =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
                                 seg_offsets, NULL);

cmdline_parse_inst_t cmd_set_rxoffs = {
        .f = cmd_set_rxoffs_parsed,
        .data = NULL,
        .help_str = "set rxoffs <len0[,len1]*>",
        .tokens = {
                (void *)&cmd_set_rxoffs_keyword,
                (void *)&cmd_set_rxoffs_name,
                (void *)&cmd_set_rxoffs_offsets,
                NULL,
        },
};

/* *** SET SEGMENT LENGTHS OF RX PACKETS SPLIT *** */

struct cmd_set_rxpkts_result {
        cmdline_fixed_string_t cmd_keyword;
        cmdline_fixed_string_t rxpkts;
        cmdline_fixed_string_t seg_lengths;
};

static void
cmd_set_rxpkts_parsed(void *parsed_result,
                      __rte_unused struct cmdline *cl,
                      __rte_unused void *data)
{
        struct cmd_set_rxpkts_result *res;
        unsigned int seg_lengths[MAX_SEGS_BUFFER_SPLIT];
        unsigned int nb_segs;

        res = parsed_result;
        nb_segs = parse_item_list(res->seg_lengths, "segment lengths",
                                  MAX_SEGS_BUFFER_SPLIT, seg_lengths, 0);
        if (nb_segs > 0)
                set_rx_pkt_segments(seg_lengths, nb_segs);
        cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
}

cmdline_parse_token_string_t cmd_set_rxpkts_keyword =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
                                 cmd_keyword, "set");
cmdline_parse_token_string_t cmd_set_rxpkts_name =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
                                 rxpkts, "rxpkts");
cmdline_parse_token_string_t cmd_set_rxpkts_lengths =
        TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
                                 seg_lengths, NULL);

cmdline_parse_inst_t cmd_set_rxpkts = {
        .f = cmd_set_rxpkts_parsed,
        .data = NULL,
        .help_str = "set rxpkts <len0[,len1]*>",
        .tokens = {
                (void *)&cmd_set_rxpkts_keyword,
                (void *)&cmd_set_rxpkts_name,
                (void *)&cmd_set_rxpkts_lengths,
                NULL,
        },
};

/* *** SET SEGMENT LENGTHS OF TXONLY PACKETS *** */

struct cmd_set_txpkts_result {
        cmdline_fixed_string_t cmd_keyword;
        cmdline_fixed_string_t txpkts;
        cmdline_fixed_string_t seg_lengths;
};

static void
cmd_set_txpkts_parsed(void *parsed_result,
                      __rte_unused struct cmdline *cl,
                      __rte_unused void *data)
{
        struct cmd_set_txpkts_result *res;
        unsigned seg_lengths[RTE_MAX_SEGS_PER_PKT];
        unsigned int nb_segs;

        res = parsed_result;
        nb_segs = parse_item_list(res->seg_lengths, "segment lengths",