app/testpmd: fix flow director mask
[dpdk.git] / app / test-pmd / cmdline.c
index eb7bbb4..a82b4cc 100644 (file)
 #ifdef RTE_LIBRTE_PMD_BOND
 #include <rte_eth_bond.h>
 #endif
-
+#ifdef RTE_LIBRTE_IXGBE_PMD
+#include <rte_pmd_ixgbe.h>
+#endif
 #include "testpmd.h"
 
 static struct cmdline *testpmd_cl;
 
 static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue);
 
-#ifdef RTE_NIC_BYPASS
-uint8_t bypass_is_supported(portid_t port_id);
-#endif
-
 /* *** Help command with introduction. *** */
 struct cmd_help_brief_result {
        cmdline_fixed_string_t help;
@@ -246,8 +244,8 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "    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"
-                       " in mac_retry forwarding mode.\n\n"
+                       "    Set the transmit delay time and number of retries,"
+                       " effective when retry is enabled.\n\n"
 
                        "set txpkts (x[,y]*)\n"
                        "    Set the length of each segment of TXONLY"
@@ -264,12 +262,37 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "set portlist (x[,y]*)\n"
                        "    Set the list of forwarding ports.\n\n"
 
+#ifdef RTE_LIBRTE_IXGBE_PMD
+                       "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"
+#endif
+
                        "vlan set strip (on|off) (port_id)\n"
                        "    Set the VLAN strip on a port.\n\n"
 
                        "vlan set stripq (on|off) (port_id,queue_id)\n"
                        "    Set the VLAN strip for a queue on a port.\n\n"
 
+#ifdef RTE_LIBRTE_IXGBE_PMD
+                       "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) (on|off)\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"
+#endif
+
                        "vlan set filter (on|off) (port_id)\n"
                        "    Set the VLAN filter on a port.\n\n"
 
@@ -363,6 +386,11 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "mac_addr add port (port_id) vf (vf_id) (mac_address)\n"
                        "    Add a MAC address for a VF on the port.\n\n"
 
+#ifdef RTE_LIBRTE_IXGBE_PMD
+                       "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"
+#endif
+
                        "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"
@@ -549,7 +577,7 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "    Detach physical or virtual dev by port_id\n\n"
 
                        "port config (port_id|all)"
-                       " speed (10|100|1000|10000|40000|auto)"
+                       " speed (10|100|1000|10000|25000|40000|50000|100000|auto)"
                        " duplex (half|full|auto)\n"
                        "    Set speed and duplex for all ports or port_id\n\n"
 
@@ -559,13 +587,13 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "port config all max-pkt-len (value)\n"
                        "    Set the max packet length.\n\n"
 
-                       "port config all (crc-strip|rx-cksum|hw-vlan|hw-vlan-filter|"
+                       "port config all (crc-strip|scatter|rx-cksum|hw-vlan|hw-vlan-filter|"
                        "hw-vlan-strip|hw-vlan-extend|drop-en)"
                        " (on|off)\n"
-                       "    Set crc-strip/rx-checksum/hardware-vlan/drop_en"
+                       "    Set crc-strip/scatter/rx-checksum/hardware-vlan/drop_en"
                        " for ports.\n\n"
 
-                       "port config all rss (all|ip|tcp|udp|sctp|ether|none)\n"
+                       "port config all rss (all|ip|tcp|udp|sctp|ether|port|vxlan|geneve|nvgre|none)\n"
                        "    Set the RSS mode.\n\n"
 
                        "port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
@@ -724,7 +752,7 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "    Set flow director IP mask.\n\n"
 
                        "flow_director_mask (port_id) mode MAC-VLAN"
-                       " vlan (vlan_value) mac (mac_value)\n"
+                       " vlan (vlan_value)\n"
                        "    Set flow director MAC-VLAN mask.\n\n"
 
                        "flow_director_mask (port_id) mode Tunnel"
@@ -989,7 +1017,7 @@ struct cmd_config_speed_all {
 };
 
 static int
-parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint16_t *speed)
+parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint32_t *speed)
 {
 
        int duplex;
@@ -1006,20 +1034,28 @@ parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint16_t *speed)
        }
 
        if (!strcmp(speedstr, "10")) {
-               *speed = ETH_LINK_SPEED_10;
+               *speed = (duplex == ETH_LINK_HALF_DUPLEX) ?
+                               ETH_LINK_SPEED_10M_HD : ETH_LINK_SPEED_10M;
        } else if (!strcmp(speedstr, "100")) {
-               *speed = ETH_LINK_SPEED_100;
+               *speed = (duplex == ETH_LINK_HALF_DUPLEX) ?
+                               ETH_LINK_SPEED_100M_HD : ETH_LINK_SPEED_100M;
        } else {
                if (duplex != ETH_LINK_FULL_DUPLEX) {
                        printf("Invalid speed/duplex parameters\n");
                        return -1;
                }
                if (!strcmp(speedstr, "1000")) {
-                       *speed = ETH_LINK_SPEED_1000;
+                       *speed = ETH_LINK_SPEED_1G;
                } else if (!strcmp(speedstr, "10000")) {
                        *speed = ETH_LINK_SPEED_10G;
+               } else if (!strcmp(speedstr, "25000")) {
+                       *speed = ETH_LINK_SPEED_25G;
                } else if (!strcmp(speedstr, "40000")) {
                        *speed = ETH_LINK_SPEED_40G;
+               } else if (!strcmp(speedstr, "50000")) {
+                       *speed = ETH_LINK_SPEED_50G;
+               } else if (!strcmp(speedstr, "100000")) {
+                       *speed = ETH_LINK_SPEED_100G;
                } else if (!strcmp(speedstr, "auto")) {
                        *speed = ETH_LINK_SPEED_AUTONEG;
                } else {
@@ -1037,8 +1073,7 @@ cmd_config_speed_all_parsed(void *parsed_result,
                        __attribute__((unused)) void *data)
 {
        struct cmd_config_speed_all *res = parsed_result;
-       uint16_t link_speed = ETH_LINK_SPEED_AUTONEG;
-       uint16_t link_duplex = 0;
+       uint32_t link_speed;
        portid_t pid;
 
        if (!all_ports_stopped()) {
@@ -1051,8 +1086,7 @@ cmd_config_speed_all_parsed(void *parsed_result,
                return;
 
        FOREACH_PORT(pid, ports) {
-               ports[pid].dev_conf.link_speed = link_speed;
-               ports[pid].dev_conf.link_duplex = link_duplex;
+               ports[pid].dev_conf.link_speeds = link_speed;
        }
 
        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
@@ -1069,7 +1103,7 @@ 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#40000#auto");
+                               "10#100#1000#10000#25000#40000#50000#100000#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 =
@@ -1079,7 +1113,8 @@ cmdline_parse_token_string_t cmd_config_speed_all_value2 =
 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|40000|auto duplex "
+       .help_str = "port config all speed "
+               "10|100|1000|10000|25000|40000|50000|100000|auto duplex "
                                                        "half|full|auto",
        .tokens = {
                (void *)&cmd_config_speed_all_port,
@@ -1110,8 +1145,7 @@ cmd_config_speed_specific_parsed(void *parsed_result,
                                __attribute__((unused)) void *data)
 {
        struct cmd_config_speed_specific *res = parsed_result;
-       uint16_t link_speed = ETH_LINK_SPEED_AUTONEG;
-       uint16_t link_duplex = 0;
+       uint32_t link_speed;
 
        if (!all_ports_stopped()) {
                printf("Please stop all ports first\n");
@@ -1125,8 +1159,7 @@ cmd_config_speed_specific_parsed(void *parsed_result,
                        &link_speed) < 0)
                return;
 
-       ports[res->id].dev_conf.link_speed = link_speed;
-       ports[res->id].dev_conf.link_duplex = link_duplex;
+       ports[res->id].dev_conf.link_speeds = link_speed;
 
        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
 }
@@ -1145,7 +1178,7 @@ cmdline_parse_token_string_t 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#40000#auto");
+                               "10#100#1000#10000#25000#40000#50000#100000#auto");
 cmdline_parse_token_string_t cmd_config_speed_specific_item2 =
        TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2,
                                                                "duplex");
@@ -1156,7 +1189,8 @@ cmdline_parse_token_string_t cmd_config_speed_specific_value2 =
 cmdline_parse_inst_t cmd_config_speed_specific = {
        .f = cmd_config_speed_specific_parsed,
        .data = NULL,
-       .help_str = "port config X speed 10|100|1000|10000|40000|auto duplex "
+       .help_str = "port config X speed "
+               "10|100|1000|10000|25000|40000|50000|100000|auto duplex "
                                                        "half|full|auto",
        .tokens = {
                (void *)&cmd_config_speed_specific_port,
@@ -1223,6 +1257,8 @@ cmd_config_rx_tx_parsed(void *parsed_result,
                return;
        }
 
+       fwd_config_setup();
+
        init_port_config();
 
        cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
@@ -1369,7 +1405,7 @@ cmdline_parse_token_num_t cmd_config_mtu_value =
 cmdline_parse_inst_t cmd_config_mtu = {
        .f = cmd_config_mtu_parsed,
        .data = NULL,
-       .help_str = "port config mtu value",
+       .help_str = "port config mtu port_id value",
        .tokens = {
                (void *)&cmd_config_mtu_port,
                (void *)&cmd_config_mtu_keyword,
@@ -1410,6 +1446,15 @@ cmd_config_rx_mode_flag_parsed(void *parsed_result,
                        printf("Unknown parameter\n");
                        return;
                }
+       } else if (!strcmp(res->name, "scatter")) {
+               if (!strcmp(res->value, "on"))
+                       rx_mode.enable_scatter = 1;
+               else if (!strcmp(res->value, "off"))
+                       rx_mode.enable_scatter = 0;
+               else {
+                       printf("Unknown parameter\n");
+                       return;
+               }
        } else if (!strcmp(res->name, "rx-cksum")) {
                if (!strcmp(res->value, "on"))
                        rx_mode.hw_ip_checksum = 1;
@@ -1487,7 +1532,7 @@ 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,
-                                       "crc-strip#rx-cksum#hw-vlan#"
+                                       "crc-strip#scatter#rx-cksum#hw-vlan#"
                                        "hw-vlan-filter#hw-vlan-strip#hw-vlan-extend");
 cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
        TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
@@ -1496,7 +1541,7 @@ cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
 cmdline_parse_inst_t cmd_config_rx_mode_flag = {
        .f = cmd_config_rx_mode_flag_parsed,
        .data = NULL,
-       .help_str = "port config all crc-strip|rx-cksum|hw-vlan|"
+       .help_str = "port config all crc-strip|scatter|rx-cksum|hw-vlan|"
                "hw-vlan-filter|hw-vlan-strip|hw-vlan-extend on|off",
        .tokens = {
                (void *)&cmd_config_rx_mode_flag_port,
@@ -1524,6 +1569,7 @@ cmd_config_rss_parsed(void *parsed_result,
 {
        struct cmd_config_rss *res = parsed_result;
        struct rte_eth_rss_conf rss_conf;
+       int diag;
        uint8_t i;
 
        if (!strcmp(res->value, "all"))
@@ -1540,6 +1586,14 @@ cmd_config_rss_parsed(void *parsed_result,
                rss_conf.rss_hf = ETH_RSS_SCTP;
        else if (!strcmp(res->value, "ether"))
                rss_conf.rss_hf = ETH_RSS_L2_PAYLOAD;
+       else if (!strcmp(res->value, "port"))
+               rss_conf.rss_hf = ETH_RSS_PORT;
+       else if (!strcmp(res->value, "vxlan"))
+               rss_conf.rss_hf = ETH_RSS_VXLAN;
+       else if (!strcmp(res->value, "geneve"))
+               rss_conf.rss_hf = ETH_RSS_GENEVE;
+       else if (!strcmp(res->value, "nvgre"))
+               rss_conf.rss_hf = ETH_RSS_NVGRE;
        else if (!strcmp(res->value, "none"))
                rss_conf.rss_hf = 0;
        else {
@@ -1547,8 +1601,13 @@ cmd_config_rss_parsed(void *parsed_result,
                return;
        }
        rss_conf.rss_key = NULL;
-       for (i = 0; i < rte_eth_dev_count(); i++)
-               rte_eth_dev_rss_hash_update(i, &rss_conf);
+       for (i = 0; i < rte_eth_dev_count(); i++) {
+               diag = rte_eth_dev_rss_hash_update(i, &rss_conf);
+               if (diag < 0)
+                       printf("Configuration of RSS hash at ethernet port %d "
+                               "failed with error (%d): %s.\n",
+                               i, -diag, strerror(-diag));
+       }
 }
 
 cmdline_parse_token_string_t cmd_config_rss_port =
@@ -1561,12 +1620,12 @@ 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,
-               "all#ip#tcp#udp#sctp#ether#none");
+               "all#ip#tcp#udp#sctp#ether#port#vxlan#geneve#nvgre#none");
 
 cmdline_parse_inst_t cmd_config_rss = {
        .f = cmd_config_rss_parsed,
        .data = NULL,
-       .help_str = "port config all rss all|ip|tcp|udp|sctp|ether|none",
+       .help_str = "port config all rss all|ip|tcp|udp|sctp|ether|port|vxlan|geneve|nvgre|none",
        .tokens = {
                (void *)&cmd_config_rss_port,
                (void *)&cmd_config_rss_keyword,
@@ -1587,7 +1646,6 @@ struct cmd_config_rss_hash_key {
        cmdline_fixed_string_t key;
 };
 
-#define RSS_HASH_KEY_LENGTH 40
 static uint8_t
 hexa_digit_to_value(char hexa_digit)
 {
@@ -1623,16 +1681,29 @@ cmd_config_rss_hash_key_parsed(void *parsed_result,
        uint8_t xdgt0;
        uint8_t xdgt1;
        int i;
+       struct rte_eth_dev_info dev_info;
+       uint8_t hash_key_size;
+       uint32_t key_len;
 
+       memset(&dev_info, 0, sizeof(dev_info));
+       rte_eth_dev_info_get(res->port_id, &dev_info);
+       if (dev_info.hash_key_size > 0 &&
+                       dev_info.hash_key_size <= sizeof(hash_key))
+               hash_key_size = dev_info.hash_key_size;
+       else {
+               printf("dev_info did not provide a valid hash key size\n");
+               return;
+       }
        /* Check the length of the RSS hash key */
-       if (strlen(res->key) != (RSS_HASH_KEY_LENGTH * 2)) {
+       key_len = strlen(res->key);
+       if (key_len != (hash_key_size * 2)) {
                printf("key length: %d invalid - key must be a string of %d"
-                      "hexa-decimal numbers\n", (int) strlen(res->key),
-                      RSS_HASH_KEY_LENGTH * 2);
+                          " hexa-decimal numbers\n",
+                          (int) key_len, hash_key_size * 2);
                return;
        }
        /* Translate RSS hash key into binary representation */
-       for (i = 0; i < RSS_HASH_KEY_LENGTH; i++) {
+       for (i = 0; i < hash_key_size; i++) {
                xdgt0 = parse_and_check_key_hexa_digit(res->key, (i * 2));
                if (xdgt0 == 0xFF)
                        return;
@@ -1642,7 +1713,7 @@ cmd_config_rss_hash_key_parsed(void *parsed_result,
                hash_key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1);
        }
        port_rss_hash_key_update(res->port_id, res->rss_type, hash_key,
-                                RSS_HASH_KEY_LENGTH);
+                       hash_key_size);
 }
 
 cmdline_parse_token_string_t cmd_config_rss_hash_key_port =
@@ -1671,7 +1742,8 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = {
                "port config X 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 80 hexa digits\n",
+               "ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex "
+               "<string of hexa digits (variable length, NIC dependent)>\n",
        .tokens = {
                (void *)&cmd_config_rss_hash_key_port,
                (void *)&cmd_config_rss_hash_key_config,
@@ -2511,16 +2583,20 @@ static void cmd_set_list_parsed(void *parsed_result,
                nb_item = parse_item_list(res->list_of_items, "core",
                                          RTE_MAX_LCORE,
                                          parsed_items.lcorelist, 1);
-               if (nb_item > 0)
+               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)
+               if (nb_item > 0) {
                        set_fwd_ports_list(parsed_items.portlist, nb_item);
+                       fwd_config_setup();
+               }
        }
 }
 
@@ -2564,10 +2640,13 @@ static void cmd_set_mask_parsed(void *parsed_result,
                printf("Please stop forwarding first\n");
                return;
        }
-       if (!strcmp(res->mask, "coremask"))
+       if (!strcmp(res->mask, "coremask")) {
                set_fwd_lcores_mask(res->hexavalue);
-       else if (!strcmp(res->mask, "portmask"))
+               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 =
@@ -2604,11 +2683,13 @@ static void cmd_set_parsed(void *parsed_result,
                           __attribute__((unused)) void *data)
 {
        struct cmd_set_result *res = parsed_result;
-       if (!strcmp(res->what, "nbport"))
+       if (!strcmp(res->what, "nbport")) {
                set_fwd_ports_number(res->value);
-       else if (!strcmp(res->what, "nbcore"))
+               fwd_config_setup();
+       } else if (!strcmp(res->what, "nbcore")) {
                set_fwd_lcores_number(res->value);
-       else if (!strcmp(res->what, "burst"))
+               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);
@@ -2721,6 +2802,74 @@ cmdline_parse_inst_t cmd_set_txsplit = {
        },
 };
 
+/* *** CONFIG TX QUEUE FLAGS *** */
+
+struct cmd_config_txqflags_result {
+       cmdline_fixed_string_t port;
+       cmdline_fixed_string_t config;
+       cmdline_fixed_string_t all;
+       cmdline_fixed_string_t what;
+       int32_t hexvalue;
+};
+
+static void cmd_config_txqflags_parsed(void *parsed_result,
+                               __attribute__((unused)) struct cmdline *cl,
+                               __attribute__((unused)) void *data)
+{
+       struct cmd_config_txqflags_result *res = parsed_result;
+
+       if (!all_ports_stopped()) {
+               printf("Please stop all ports first\n");
+               return;
+       }
+
+       if (strcmp(res->what, "txqflags")) {
+               printf("Unknown parameter\n");
+               return;
+       }
+
+       if (res->hexvalue >= 0) {
+               txq_flags = res->hexvalue;
+       } else {
+               printf("txqflags must be >= 0\n");
+               return;
+       }
+
+       init_port_config();
+
+       cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_txqflags_port =
+       TOKEN_STRING_INITIALIZER(struct cmd_config_txqflags_result, port,
+                                "port");
+cmdline_parse_token_string_t cmd_config_txqflags_config =
+       TOKEN_STRING_INITIALIZER(struct cmd_config_txqflags_result, config,
+                                "config");
+cmdline_parse_token_string_t cmd_config_txqflags_all =
+       TOKEN_STRING_INITIALIZER(struct cmd_config_txqflags_result, all,
+                                "all");
+cmdline_parse_token_string_t cmd_config_txqflags_what =
+       TOKEN_STRING_INITIALIZER(struct cmd_config_txqflags_result, what,
+                                "txqflags");
+cmdline_parse_token_num_t cmd_config_txqflags_value =
+       TOKEN_NUM_INITIALIZER(struct cmd_config_txqflags_result,
+                               hexvalue, INT32);
+
+cmdline_parse_inst_t cmd_config_txqflags = {
+       .f = cmd_config_txqflags_parsed,
+       .data = NULL,
+       .help_str = "port config all txqflags value",
+       .tokens = {
+               (void *)&cmd_config_txqflags_port,
+               (void *)&cmd_config_txqflags_config,
+               (void *)&cmd_config_txqflags_all,
+               (void *)&cmd_config_txqflags_what,
+               (void *)&cmd_config_txqflags_value,
+               NULL,
+       },
+};
+
 /* *** ADD/REMOVE ALL VLAN IDENTIFIERS TO/FROM A PORT VLAN RX FILTER *** */
 struct cmd_rx_vlan_filter_all_result {
        cmdline_fixed_string_t rx_vlan;
@@ -3374,7 +3523,7 @@ cmdline_parse_inst_t cmd_csum_tunnel = {
        },
 };
 
-/* *** ENABLE HARDWARE SEGMENTATION IN TX PACKETS *** */
+/* *** ENABLE HARDWARE SEGMENTATION IN TX NON-TUNNELED PACKETS *** */
 struct cmd_tso_set_result {
        cmdline_fixed_string_t tso;
        cmdline_fixed_string_t mode;
@@ -3397,9 +3546,9 @@ cmd_tso_set_parsed(void *parsed_result,
                ports[res->port_id].tso_segsz = res->tso_segsz;
 
        if (ports[res->port_id].tso_segsz == 0)
-               printf("TSO is disabled\n");
+               printf("TSO for non-tunneled packets is disabled\n");
        else
-               printf("TSO segment size is %d\n",
+               printf("TSO segment size for non-tunneled packets is %d\n",
                        ports[res->port_id].tso_segsz);
 
        /* display warnings if configuration is not supported by the NIC */
@@ -3427,8 +3576,8 @@ cmdline_parse_token_num_t cmd_tso_set_portid =
 cmdline_parse_inst_t cmd_tso_set = {
        .f = cmd_tso_set_parsed,
        .data = NULL,
-       .help_str = "Set TSO segment size for csum engine (0 to disable): "
-       "tso set <tso_segsz> <port>",
+       .help_str = "Set TSO segment size of non-tunneled packets "
+       "for csum engine (0 to disable): tso set <tso_segsz> <port>",
        .tokens = {
                (void *)&cmd_tso_set_tso,
                (void *)&cmd_tso_set_mode,
@@ -3446,8 +3595,8 @@ cmdline_parse_token_string_t cmd_tso_show_mode =
 cmdline_parse_inst_t cmd_tso_show = {
        .f = cmd_tso_set_parsed,
        .data = NULL,
-       .help_str = "Show TSO segment size for csum engine: "
-       "tso show <port>",
+       .help_str = "Show TSO segment size of non-tunneled packets "
+       "for csum engine: tso show <port>",
        .tokens = {
                (void *)&cmd_tso_set_tso,
                (void *)&cmd_tso_show_mode,
@@ -3456,6 +3605,122 @@ cmdline_parse_inst_t cmd_tso_show = {
        },
 };
 
+/* *** ENABLE HARDWARE SEGMENTATION IN TX TUNNELED PACKETS *** */
+struct cmd_tunnel_tso_set_result {
+       cmdline_fixed_string_t tso;
+       cmdline_fixed_string_t mode;
+       uint16_t tso_segsz;
+       uint8_t port_id;
+};
+
+static void
+check_tunnel_tso_nic_support(uint8_t port_id)
+{
+       struct rte_eth_dev_info dev_info;
+
+       rte_eth_dev_info_get(port_id, &dev_info);
+       if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO))
+               printf("Warning: TSO enabled but VXLAN TUNNEL TSO not "
+                      "supported by port %d\n", port_id);
+       if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GRE_TNL_TSO))
+               printf("Warning: TSO enabled but GRE TUNNEL TSO not "
+                       "supported by port %d\n", port_id);
+       if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPIP_TNL_TSO))
+               printf("Warning: TSO enabled but IPIP TUNNEL TSO not "
+                      "supported by port %d\n", port_id);
+       if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GENEVE_TNL_TSO))
+               printf("Warning: TSO enabled but GENEVE TUNNEL TSO not "
+                      "supported by port %d\n", port_id);
+}
+
+static void
+cmd_tunnel_tso_set_parsed(void *parsed_result,
+                         __attribute__((unused)) struct cmdline *cl,
+                         __attribute__((unused)) void *data)
+{
+       struct cmd_tunnel_tso_set_result *res = parsed_result;
+
+       if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+               return;
+
+       if (!strcmp(res->mode, "set"))
+               ports[res->port_id].tunnel_tso_segsz = res->tso_segsz;
+
+       if (ports[res->port_id].tunnel_tso_segsz == 0)
+               printf("TSO for tunneled packets is disabled\n");
+       else {
+               printf("TSO segment size for tunneled packets is %d\n",
+                       ports[res->port_id].tunnel_tso_segsz);
+
+               /* Below conditions are needed to make it work:
+                * (1) tunnel TSO is supported by the NIC;
+                * (2) "csum parse_tunnel" must be set so that tunneled pkts
+                * are recognized;
+                * (3) for tunneled pkts with outer L3 of IPv4,
+                * "csum set outer-ip" must be set to hw, because after tso,
+                * total_len of outer IP header is changed, and the checksum
+                * of outer IP header calculated by sw should be wrong; that
+                * is not necessary for IPv6 tunneled pkts because there's no
+                * checksum in IP header anymore.
+                */
+               check_tunnel_tso_nic_support(res->port_id);
+
+               if (!(ports[res->port_id].tx_ol_flags &
+                     TESTPMD_TX_OFFLOAD_PARSE_TUNNEL))
+                       printf("Warning: csum parse_tunnel must be set "
+                               "so that tunneled packets are recognized\n");
+               if (!(ports[res->port_id].tx_ol_flags &
+                     TESTPMD_TX_OFFLOAD_OUTER_IP_CKSUM))
+                       printf("Warning: csum set outer-ip must be set to hw "
+                               "if outer L3 is IPv4; not necessary for IPv6\n");
+       }
+}
+
+cmdline_parse_token_string_t cmd_tunnel_tso_set_tso =
+       TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
+                               tso, "tunnel_tso");
+cmdline_parse_token_string_t cmd_tunnel_tso_set_mode =
+       TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
+                               mode, "set");
+cmdline_parse_token_num_t cmd_tunnel_tso_set_tso_segsz =
+       TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
+                               tso_segsz, UINT16);
+cmdline_parse_token_num_t cmd_tunnel_tso_set_portid =
+       TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
+                               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_tunnel_tso_set = {
+       .f = cmd_tunnel_tso_set_parsed,
+       .data = NULL,
+       .help_str = "Set TSO segment size of tunneled packets for csum engine "
+       "(0 to disable): tunnel_tso set <tso_segsz> <port>",
+       .tokens = {
+               (void *)&cmd_tunnel_tso_set_tso,
+               (void *)&cmd_tunnel_tso_set_mode,
+               (void *)&cmd_tunnel_tso_set_tso_segsz,
+               (void *)&cmd_tunnel_tso_set_portid,
+               NULL,
+       },
+};
+
+cmdline_parse_token_string_t cmd_tunnel_tso_show_mode =
+       TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
+                               mode, "show");
+
+
+cmdline_parse_inst_t cmd_tunnel_tso_show = {
+       .f = cmd_tunnel_tso_set_parsed,
+       .data = NULL,
+       .help_str = "Show TSO segment size of tunneled packets "
+       "for csum engine: tunnel_tso show <port>",
+       .tokens = {
+               (void *)&cmd_tunnel_tso_set_tso,
+               (void *)&cmd_tunnel_tso_show_mode,
+               (void *)&cmd_tunnel_tso_set_portid,
+               NULL,
+       },
+};
+
 /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */
 struct cmd_set_flush_rx {
        cmdline_fixed_string_t set;
@@ -3554,9 +3819,6 @@ cmd_set_bypass_mode_parsed(void *parsed_result,
        portid_t port_id = res->port_id;
        uint32_t bypass_mode = RTE_BYPASS_MODE_NORMAL;
 
-       if (!bypass_is_supported(port_id))
-               return;
-
        if (!strcmp(res->value, "bypass"))
                bypass_mode = RTE_BYPASS_MODE_BYPASS;
        else if (!strcmp(res->value, "isolate"))
@@ -3623,9 +3885,6 @@ cmd_set_bypass_event_parsed(void *parsed_result,
        uint32_t bypass_event = RTE_BYPASS_EVENT_NONE;
        uint32_t bypass_mode = RTE_BYPASS_MODE_NORMAL;
 
-       if (!bypass_is_supported(port_id))
-               return;
-
        if (!strcmp(res->event_value, "timeout"))
                bypass_event = RTE_BYPASS_EVENT_TIMEOUT;
        else if (!strcmp(res->event_value, "os_on"))
@@ -3801,9 +4060,6 @@ cmd_show_bypass_config_parsed(void *parsed_result,
                "timeout"};
        int num_events = (sizeof events) / (sizeof events[0]);
 
-       if (!bypass_is_supported(port_id))
-               return;
-
        /* Display the bypass mode.*/
        if (0 != rte_eth_dev_bypass_state_show(port_id, &bypass_mode)) {
                printf("\tFailed to get bypass mode for port = %d\n", port_id);
@@ -4302,7 +4558,7 @@ static void cmd_create_bonded_device_parsed(void *parsed_result,
                return;
        }
 
-       snprintf(ethdev_name, RTE_ETH_NAME_MAX_LEN, "eth_bond_testpmd_%d",
+       snprintf(ethdev_name, RTE_ETH_NAME_MAX_LEN, "net_bond_testpmd_%d",
                        bond_dev_num++);
 
        /* Create a new bonded device. */
@@ -4480,6 +4736,7 @@ static void cmd_set_fwd_mode_parsed(void *parsed_result,
 {
        struct cmd_set_fwd_mode_result *res = parsed_result;
 
+       retry_enabled = 0;
        set_pkt_forwarding_mode(res->mode);
 }
 
@@ -4525,6 +4782,74 @@ static void cmd_set_fwd_mode_init(void)
        token_struct->string_data.str = token;
 }
 
+/* *** SET RETRY FORWARDING MODE *** */
+struct cmd_set_fwd_retry_mode_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t fwd;
+       cmdline_fixed_string_t mode;
+       cmdline_fixed_string_t retry;
+};
+
+static void cmd_set_fwd_retry_mode_parsed(void *parsed_result,
+                           __attribute__((unused)) struct cmdline *cl,
+                           __attribute__((unused)) void *data)
+{
+       struct cmd_set_fwd_retry_mode_result *res = parsed_result;
+
+       retry_enabled = 1;
+       set_pkt_forwarding_mode(res->mode);
+}
+
+cmdline_parse_token_string_t cmd_setfwd_retry_set =
+       TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
+                       set, "set");
+cmdline_parse_token_string_t cmd_setfwd_retry_fwd =
+       TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
+                       fwd, "fwd");
+cmdline_parse_token_string_t cmd_setfwd_retry_mode =
+       TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
+                       mode,
+               "" /* defined at init */);
+cmdline_parse_token_string_t cmd_setfwd_retry_retry =
+       TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
+                       retry, "retry");
+
+cmdline_parse_inst_t cmd_set_fwd_retry_mode = {
+       .f = cmd_set_fwd_retry_mode_parsed,
+       .data = NULL,
+       .help_str = NULL, /* defined at init */
+       .tokens = {
+               (void *)&cmd_setfwd_retry_set,
+               (void *)&cmd_setfwd_retry_fwd,
+               (void *)&cmd_setfwd_retry_mode,
+               (void *)&cmd_setfwd_retry_retry,
+               NULL,
+       },
+};
+
+static void cmd_set_fwd_retry_mode_init(void)
+{
+       char *modes, *c;
+       static char token[128];
+       static char help[256];
+       cmdline_parse_token_string_t *token_struct;
+
+       modes = list_pkt_forwarding_retry_modes();
+       snprintf(help, sizeof(help), "set fwd %s retry - "
+               "set packet forwarding mode with retry", modes);
+       cmd_set_fwd_retry_mode.help_str = help;
+
+       /* string token separator is # */
+       for (c = token; *modes != '\0'; modes++)
+               if (*modes == '|')
+                       *c++ = '#';
+               else
+                       *c++ = *modes;
+       token_struct = (cmdline_parse_token_string_t *)
+               cmd_set_fwd_retry_mode.tokens[2];
+       token_struct->string_data.str = token;
+}
+
 /* *** SET BURST TX DELAY TIME RETRY NUMBER *** */
 struct cmd_set_burst_tx_retry_result {
        cmdline_fixed_string_t set;
@@ -5240,6 +5565,46 @@ cmdline_parse_inst_t cmd_start_tx_first = {
        },
 };
 
+/* *** START FORWARDING WITH N TX BURST FIRST *** */
+struct cmd_start_tx_first_n_result {
+       cmdline_fixed_string_t start;
+       cmdline_fixed_string_t tx_first;
+       uint32_t tx_num;
+};
+
+static void
+cmd_start_tx_first_n_parsed(void *parsed_result,
+                         __attribute__((unused)) struct cmdline *cl,
+                         __attribute__((unused)) void *data)
+{
+       struct cmd_start_tx_first_n_result *res = parsed_result;
+
+       start_packet_forwarding(res->tx_num);
+}
+
+cmdline_parse_token_string_t cmd_start_tx_first_n_start =
+       TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_n_result,
+                       start, "start");
+cmdline_parse_token_string_t cmd_start_tx_first_n_tx_first =
+       TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_n_result,
+                       tx_first, "tx_first");
+cmdline_parse_token_num_t cmd_start_tx_first_n_tx_num =
+       TOKEN_NUM_INITIALIZER(struct cmd_start_tx_first_n_result,
+                       tx_num, UINT32);
+
+cmdline_parse_inst_t cmd_start_tx_first_n = {
+       .f = cmd_start_tx_first_n_parsed,
+       .data = NULL,
+       .help_str = "start packet forwarding, after sending <num> "
+               "bursts of packets",
+       .tokens = {
+               (void *)&cmd_start_tx_first_n_start,
+               (void *)&cmd_start_tx_first_n_tx_first,
+               (void *)&cmd_start_tx_first_n_tx_num,
+               NULL,
+       },
+};
+
 /* *** SET LINK UP *** */
 struct cmd_set_link_up_result {
        cmdline_fixed_string_t set;
@@ -5336,7 +5701,7 @@ static void cmd_showcfg_parsed(void *parsed_result,
        else if (!strcmp(res->what, "cores"))
                fwd_lcores_config_display();
        else if (!strcmp(res->what, "fwd"))
-               fwd_config_display();
+               pkt_fwd_config_display(&cur_fwd_config);
        else if (!strcmp(res->what, "txpkts"))
                show_tx_pkt_segments();
 }
@@ -7191,8 +7556,6 @@ static void cmd_dump_parsed(void *parsed_result,
                rte_dump_physmem_layout(stdout);
        else if (!strcmp(res->dump, "dump_memzone"))
                rte_memzone_dump(stdout);
-       else if (!strcmp(res->dump, "dump_log_history"))
-               rte_log_dump_history(stdout);
        else if (!strcmp(res->dump, "dump_struct_sizes"))
                dump_struct_sizes();
        else if (!strcmp(res->dump, "dump_ring"))
@@ -7207,7 +7570,6 @@ cmdline_parse_token_string_t cmd_dump_dump =
        TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump,
                "dump_physmem#"
                "dump_memzone#"
-               "dump_log_history#"
                "dump_struct_sizes#"
                "dump_ring#"
                "dump_mempool#"
@@ -8307,24 +8669,28 @@ cmd_flow_director_filter_parsed(void *parsed_result,
        else
                entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
 
-       if (!strcmp(res->pf_vf, "pf"))
-               entry.input.flow_ext.is_vf = 0;
-       else if (!strncmp(res->pf_vf, "vf", 2)) {
-               struct rte_eth_dev_info dev_info;
+       if (fdir_conf.mode !=  RTE_FDIR_MODE_PERFECT_MAC_VLAN &&
+           fdir_conf.mode !=  RTE_FDIR_MODE_PERFECT_TUNNEL) {
+               if (!strcmp(res->pf_vf, "pf"))
+                       entry.input.flow_ext.is_vf = 0;
+               else if (!strncmp(res->pf_vf, "vf", 2)) {
+                       struct rte_eth_dev_info dev_info;
 
-               memset(&dev_info, 0, sizeof(dev_info));
-               rte_eth_dev_info_get(res->port_id, &dev_info);
-               errno = 0;
-               vf_id = strtoul(res->pf_vf + 2, &end, 10);
-               if (errno != 0 || *end != '\0' || vf_id >= dev_info.max_vfs) {
+                       memset(&dev_info, 0, sizeof(dev_info));
+                       rte_eth_dev_info_get(res->port_id, &dev_info);
+                       errno = 0;
+                       vf_id = strtoul(res->pf_vf + 2, &end, 10);
+                       if (errno != 0 || *end != '\0' ||
+                           vf_id >= dev_info.max_vfs) {
+                               printf("invalid parameter %s.\n", res->pf_vf);
+                               return;
+                       }
+                       entry.input.flow_ext.is_vf = 1;
+                       entry.input.flow_ext.dst_id = (uint16_t)vf_id;
+               } else {
                        printf("invalid parameter %s.\n", res->pf_vf);
                        return;
                }
-               entry.input.flow_ext.is_vf = 1;
-               entry.input.flow_ext.dst_id = (uint16_t)vf_id;
-       } else {
-               printf("invalid parameter %s.\n", res->pf_vf);
-               return;
        }
 
        /* set to report FD ID by default */
@@ -8760,7 +9126,6 @@ cmd_flow_director_mask_parsed(void *parsed_result,
                }
 
                mask->vlan_tci_mask = res->vlan_mask;
-               mask->mac_addr_byte_mask = res->mac_addr_byte_mask;
        } else if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
                if (strcmp(res->mode_value, "Tunnel")) {
                        printf("Please set mode to Tunnel.\n");
@@ -8891,8 +9256,6 @@ cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = {
                (void *)&cmd_flow_director_mask_mode_mac_vlan,
                (void *)&cmd_flow_director_mask_vlan,
                (void *)&cmd_flow_director_mask_vlan_value,
-               (void *)&cmd_flow_director_mask_mac,
-               (void *)&cmd_flow_director_mask_mac_value,
                NULL,
        },
 };
@@ -9299,6 +9662,10 @@ flowtype_to_str(uint16_t ftype)
                {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
                {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
                {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
+               {"port", RTE_ETH_FLOW_PORT},
+               {"vxlan", RTE_ETH_FLOW_VXLAN},
+               {"geneve", RTE_ETH_FLOW_GENEVE},
+               {"nvgre", RTE_ETH_FLOW_NVGRE},
        };
 
        for (i = 0; i < RTE_DIM(ftype_table); i++) {
@@ -10385,76 +10752,739 @@ cmdline_parse_inst_t cmd_config_e_tag_filter_del = {
                NULL,
        },
 };
+#ifdef RTE_LIBRTE_IXGBE_PMD
 
-/* ******************************************************************************** */
+/* vf vlan anti spoof configuration */
 
-/* list of instructions */
-cmdline_parse_ctx_t main_ctx[] = {
-       (cmdline_parse_inst_t *)&cmd_help_brief,
-       (cmdline_parse_inst_t *)&cmd_help_long,
-       (cmdline_parse_inst_t *)&cmd_quit,
-       (cmdline_parse_inst_t *)&cmd_showport,
-       (cmdline_parse_inst_t *)&cmd_showqueue,
-       (cmdline_parse_inst_t *)&cmd_showportall,
-       (cmdline_parse_inst_t *)&cmd_showcfg,
-       (cmdline_parse_inst_t *)&cmd_start,
-       (cmdline_parse_inst_t *)&cmd_start_tx_first,
-       (cmdline_parse_inst_t *)&cmd_set_link_up,
-       (cmdline_parse_inst_t *)&cmd_set_link_down,
-       (cmdline_parse_inst_t *)&cmd_reset,
-       (cmdline_parse_inst_t *)&cmd_set_numbers,
-       (cmdline_parse_inst_t *)&cmd_set_txpkts,
-       (cmdline_parse_inst_t *)&cmd_set_txsplit,
-       (cmdline_parse_inst_t *)&cmd_set_fwd_list,
-       (cmdline_parse_inst_t *)&cmd_set_fwd_mask,
-       (cmdline_parse_inst_t *)&cmd_set_fwd_mode,
-       (cmdline_parse_inst_t *)&cmd_set_burst_tx_retry,
-       (cmdline_parse_inst_t *)&cmd_set_promisc_mode_one,
-       (cmdline_parse_inst_t *)&cmd_set_promisc_mode_all,
-       (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_one,
-       (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_all,
-       (cmdline_parse_inst_t *)&cmd_set_flush_rx,
-       (cmdline_parse_inst_t *)&cmd_set_link_check,
-#ifdef RTE_NIC_BYPASS
-       (cmdline_parse_inst_t *)&cmd_set_bypass_mode,
-       (cmdline_parse_inst_t *)&cmd_set_bypass_event,
-       (cmdline_parse_inst_t *)&cmd_set_bypass_timeout,
-       (cmdline_parse_inst_t *)&cmd_show_bypass_config,
-#endif
-#ifdef RTE_LIBRTE_PMD_BOND
-       (cmdline_parse_inst_t *) &cmd_set_bonding_mode,
-       (cmdline_parse_inst_t *) &cmd_show_bonding_config,
-       (cmdline_parse_inst_t *) &cmd_set_bonding_primary,
-       (cmdline_parse_inst_t *) &cmd_add_bonding_slave,
-       (cmdline_parse_inst_t *) &cmd_remove_bonding_slave,
-       (cmdline_parse_inst_t *) &cmd_create_bonded_device,
-       (cmdline_parse_inst_t *) &cmd_set_bond_mac_addr,
-       (cmdline_parse_inst_t *) &cmd_set_balance_xmit_policy,
-       (cmdline_parse_inst_t *) &cmd_set_bond_mon_period,
-#endif
-       (cmdline_parse_inst_t *)&cmd_vlan_offload,
-       (cmdline_parse_inst_t *)&cmd_vlan_tpid,
-       (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all,
-       (cmdline_parse_inst_t *)&cmd_rx_vlan_filter,
-       (cmdline_parse_inst_t *)&cmd_tx_vlan_set,
-       (cmdline_parse_inst_t *)&cmd_tx_vlan_set_qinq,
-       (cmdline_parse_inst_t *)&cmd_tx_vlan_reset,
-       (cmdline_parse_inst_t *)&cmd_tx_vlan_set_pvid,
-       (cmdline_parse_inst_t *)&cmd_csum_set,
-       (cmdline_parse_inst_t *)&cmd_csum_show,
-       (cmdline_parse_inst_t *)&cmd_csum_tunnel,
-       (cmdline_parse_inst_t *)&cmd_tso_set,
-       (cmdline_parse_inst_t *)&cmd_tso_show,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_hw,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_lw,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_pt,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_xon,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_macfwd,
-       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg,
-       (cmdline_parse_inst_t *)&cmd_priority_flow_control_set,
+/* Common result structure for vf vlan anti spoof */
+struct cmd_vf_vlan_anti_spoof_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t vlan;
+       cmdline_fixed_string_t antispoof;
+       uint8_t port_id;
+       uint32_t vf_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf vlan anti spoof enable disable */
+cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vlan =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                vlan, "vlan");
+cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_antispoof =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                antispoof, "antispoof");
+cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                vf_id, UINT32);
+cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_anti_spoof_result,
+                on_off, "on#off");
+
+static void
+cmd_set_vf_vlan_anti_spoof_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_vf_vlan_anti_spoof_result *res = parsed_result;
+       int ret = 0;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_vf_vlan_anti_spoof(res->port_id, res->vf_id,
+                       is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d\n", res->vf_id);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_vlan_anti_spoof = {
+       .f = cmd_set_vf_vlan_anti_spoof_parsed,
+       .data = NULL,
+       .help_str = "set vf vlan antispoof port_id vf_id on|off",
+       .tokens = {
+               (void *)&cmd_vf_vlan_anti_spoof_set,
+               (void *)&cmd_vf_vlan_anti_spoof_vf,
+               (void *)&cmd_vf_vlan_anti_spoof_vlan,
+               (void *)&cmd_vf_vlan_anti_spoof_antispoof,
+               (void *)&cmd_vf_vlan_anti_spoof_port_id,
+               (void *)&cmd_vf_vlan_anti_spoof_vf_id,
+               (void *)&cmd_vf_vlan_anti_spoof_on_off,
+               NULL,
+       },
+};
+
+/* vf mac anti spoof configuration */
+
+/* Common result structure for vf mac anti spoof */
+struct cmd_vf_mac_anti_spoof_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t mac;
+       cmdline_fixed_string_t antispoof;
+       uint8_t port_id;
+       uint32_t vf_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf mac anti spoof enable disable */
+cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_mac =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                mac, "mac");
+cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_antispoof =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                antispoof, "antispoof");
+cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                vf_id, UINT32);
+cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_mac_anti_spoof_result,
+                on_off, "on#off");
+
+static void
+cmd_set_vf_mac_anti_spoof_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_vf_mac_anti_spoof_result *res = parsed_result;
+       int ret;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_vf_mac_anti_spoof(res->port_id, res->vf_id,
+                       is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_mac_anti_spoof = {
+       .f = cmd_set_vf_mac_anti_spoof_parsed,
+       .data = NULL,
+       .help_str = "set vf mac antispoof port_id vf_id on|off",
+       .tokens = {
+               (void *)&cmd_vf_mac_anti_spoof_set,
+               (void *)&cmd_vf_mac_anti_spoof_vf,
+               (void *)&cmd_vf_mac_anti_spoof_mac,
+               (void *)&cmd_vf_mac_anti_spoof_antispoof,
+               (void *)&cmd_vf_mac_anti_spoof_port_id,
+               (void *)&cmd_vf_mac_anti_spoof_vf_id,
+               (void *)&cmd_vf_mac_anti_spoof_on_off,
+               NULL,
+       },
+};
+
+/* vf vlan strip queue configuration */
+
+/* Common result structure for vf mac anti spoof */
+struct cmd_vf_vlan_stripq_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t vlan;
+       cmdline_fixed_string_t stripq;
+       uint8_t port_id;
+       uint16_t vf_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf vlan strip enable disable */
+cmdline_parse_token_string_t cmd_vf_vlan_stripq_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_vf_vlan_stripq_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_vf_vlan_stripq_vlan =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                vlan, "vlan");
+cmdline_parse_token_string_t cmd_vf_vlan_stripq_stripq =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                stripq, "stripq");
+cmdline_parse_token_num_t cmd_vf_vlan_stripq_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_vf_vlan_stripq_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                vf_id, UINT16);
+cmdline_parse_token_string_t cmd_vf_vlan_stripq_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_stripq_result,
+                on_off, "on#off");
+
+static void
+cmd_set_vf_vlan_stripq_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_vf_vlan_stripq_result *res = parsed_result;
+       int ret = 0;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_vf_vlan_stripq(res->port_id, res->vf_id, is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_vlan_stripq = {
+       .f = cmd_set_vf_vlan_stripq_parsed,
+       .data = NULL,
+       .help_str = "set vf vlan stripq port_id vf_id on|off",
+       .tokens = {
+               (void *)&cmd_vf_vlan_stripq_set,
+               (void *)&cmd_vf_vlan_stripq_vf,
+               (void *)&cmd_vf_vlan_stripq_vlan,
+               (void *)&cmd_vf_vlan_stripq_stripq,
+               (void *)&cmd_vf_vlan_stripq_port_id,
+               (void *)&cmd_vf_vlan_stripq_vf_id,
+               (void *)&cmd_vf_vlan_stripq_on_off,
+               NULL,
+       },
+};
+
+/* vf vlan insert configuration */
+
+/* Common result structure for vf vlan insert */
+struct cmd_vf_vlan_insert_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t vlan;
+       cmdline_fixed_string_t insert;
+       uint8_t port_id;
+       uint16_t vf_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf vlan insert enable disable */
+cmdline_parse_token_string_t cmd_vf_vlan_insert_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_vf_vlan_insert_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_vf_vlan_insert_vlan =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                vlan, "vlan");
+cmdline_parse_token_string_t cmd_vf_vlan_insert_insert =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                insert, "insert");
+cmdline_parse_token_num_t cmd_vf_vlan_insert_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_vf_vlan_insert_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                vf_id, UINT16);
+cmdline_parse_token_string_t cmd_vf_vlan_insert_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_vlan_insert_result,
+                on_off, "on#off");
+
+static void
+cmd_set_vf_vlan_insert_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_vf_vlan_insert_result *res = parsed_result;
+       int ret;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_vf_vlan_insert(res->port_id, res->vf_id, is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_vlan_insert = {
+       .f = cmd_set_vf_vlan_insert_parsed,
+       .data = NULL,
+       .help_str = "set vf vlan insert port_id vf_id on|off",
+       .tokens = {
+               (void *)&cmd_vf_vlan_insert_set,
+               (void *)&cmd_vf_vlan_insert_vf,
+               (void *)&cmd_vf_vlan_insert_vlan,
+               (void *)&cmd_vf_vlan_insert_insert,
+               (void *)&cmd_vf_vlan_insert_port_id,
+               (void *)&cmd_vf_vlan_insert_vf_id,
+               (void *)&cmd_vf_vlan_insert_on_off,
+               NULL,
+       },
+};
+
+/* tx loopback configuration */
+
+/* Common result structure for tx loopback */
+struct cmd_tx_loopback_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t tx;
+       cmdline_fixed_string_t loopback;
+       uint8_t port_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for tx loopback enable disable */
+cmdline_parse_token_string_t cmd_tx_loopback_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_tx_loopback_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_tx_loopback_tx =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_tx_loopback_result,
+                tx, "tx");
+cmdline_parse_token_string_t cmd_tx_loopback_loopback =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_tx_loopback_result,
+                loopback, "loopback");
+cmdline_parse_token_num_t cmd_tx_loopback_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_tx_loopback_result,
+                port_id, UINT8);
+cmdline_parse_token_string_t cmd_tx_loopback_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_tx_loopback_result,
+                on_off, "on#off");
+
+static void
+cmd_set_tx_loopback_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_tx_loopback_result *res = parsed_result;
+       int ret;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_tx_loopback(res->port_id, is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid is_on %d\n", is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_tx_loopback = {
+       .f = cmd_set_tx_loopback_parsed,
+       .data = NULL,
+       .help_str = "set tx loopback port_id on|off",
+       .tokens = {
+               (void *)&cmd_tx_loopback_set,
+               (void *)&cmd_tx_loopback_tx,
+               (void *)&cmd_tx_loopback_loopback,
+               (void *)&cmd_tx_loopback_port_id,
+               (void *)&cmd_tx_loopback_on_off,
+               NULL,
+       },
+};
+
+/* all queues drop enable configuration */
+
+/* Common result structure for all queues drop enable */
+struct cmd_all_queues_drop_en_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t all;
+       cmdline_fixed_string_t queues;
+       cmdline_fixed_string_t drop;
+       uint8_t port_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for tx loopback enable disable */
+cmdline_parse_token_string_t cmd_all_queues_drop_en_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_all_queues_drop_en_all =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                all, "all");
+cmdline_parse_token_string_t cmd_all_queues_drop_en_queues =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                queues, "queues");
+cmdline_parse_token_string_t cmd_all_queues_drop_en_drop =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                drop, "drop");
+cmdline_parse_token_num_t cmd_all_queues_drop_en_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                port_id, UINT8);
+cmdline_parse_token_string_t cmd_all_queues_drop_en_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_all_queues_drop_en_result,
+                on_off, "on#off");
+
+static void
+cmd_set_all_queues_drop_en_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_all_queues_drop_en_result *res = parsed_result;
+       int ret = 0;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_all_queues_drop_en(res->port_id, is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid is_on %d\n", is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_all_queues_drop_en = {
+       .f = cmd_set_all_queues_drop_en_parsed,
+       .data = NULL,
+       .help_str = "set all queues drop port_id on|off",
+       .tokens = {
+               (void *)&cmd_all_queues_drop_en_set,
+               (void *)&cmd_all_queues_drop_en_all,
+               (void *)&cmd_all_queues_drop_en_queues,
+               (void *)&cmd_all_queues_drop_en_drop,
+               (void *)&cmd_all_queues_drop_en_port_id,
+               (void *)&cmd_all_queues_drop_en_on_off,
+               NULL,
+       },
+};
+
+/* vf split drop enable configuration */
+
+/* Common result structure for vf split drop enable */
+struct cmd_vf_split_drop_en_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t split;
+       cmdline_fixed_string_t drop;
+       uint8_t port_id;
+       uint16_t vf_id;
+       cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf split drop enable disable */
+cmdline_parse_token_string_t cmd_vf_split_drop_en_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_vf_split_drop_en_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_vf_split_drop_en_split =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                split, "split");
+cmdline_parse_token_string_t cmd_vf_split_drop_en_drop =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                drop, "drop");
+cmdline_parse_token_num_t cmd_vf_split_drop_en_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_vf_split_drop_en_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                vf_id, UINT16);
+cmdline_parse_token_string_t cmd_vf_split_drop_en_on_off =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_vf_split_drop_en_result,
+                on_off, "on#off");
+
+static void
+cmd_set_vf_split_drop_en_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_vf_split_drop_en_result *res = parsed_result;
+       int ret;
+       int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+       ret = rte_pmd_ixgbe_set_vf_split_drop_en(res->port_id, res->vf_id,
+                       is_on);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_split_drop_en = {
+       .f = cmd_set_vf_split_drop_en_parsed,
+       .data = NULL,
+       .help_str = "set vf split drop port_id vf_id on|off",
+       .tokens = {
+               (void *)&cmd_vf_split_drop_en_set,
+               (void *)&cmd_vf_split_drop_en_vf,
+               (void *)&cmd_vf_split_drop_en_split,
+               (void *)&cmd_vf_split_drop_en_drop,
+               (void *)&cmd_vf_split_drop_en_port_id,
+               (void *)&cmd_vf_split_drop_en_vf_id,
+               (void *)&cmd_vf_split_drop_en_on_off,
+               NULL,
+       },
+};
+
+/* vf mac address configuration */
+
+/* Common result structure for vf mac address */
+struct cmd_set_vf_mac_addr_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t vf;
+       cmdline_fixed_string_t mac;
+       cmdline_fixed_string_t addr;
+       uint8_t port_id;
+       uint16_t vf_id;
+       struct ether_addr mac_addr;
+
+};
+
+/* Common CLI fields for vf split drop enable disable */
+cmdline_parse_token_string_t cmd_set_vf_mac_addr_set =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                set, "set");
+cmdline_parse_token_string_t cmd_set_vf_mac_addr_vf =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                vf, "vf");
+cmdline_parse_token_string_t cmd_set_vf_mac_addr_mac =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                mac, "mac");
+cmdline_parse_token_string_t cmd_set_vf_mac_addr_addr =
+       TOKEN_STRING_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                addr, "addr");
+cmdline_parse_token_num_t cmd_set_vf_mac_addr_port_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                port_id, UINT8);
+cmdline_parse_token_num_t cmd_set_vf_mac_addr_vf_id =
+       TOKEN_NUM_INITIALIZER
+               (struct cmd_set_vf_mac_addr_result,
+                vf_id, UINT16);
+cmdline_parse_token_etheraddr_t cmd_set_vf_mac_addr_mac_addr =
+       TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_mac_addr_result,
+                mac_addr);
+
+static void
+cmd_set_vf_mac_addr_parsed(
+       void *parsed_result,
+       __attribute__((unused)) struct cmdline *cl,
+       __attribute__((unused)) void *data)
+{
+       struct cmd_set_vf_mac_addr_result *res = parsed_result;
+       int ret;
+
+       ret = rte_pmd_ixgbe_set_vf_mac_addr(res->port_id, res->vf_id,
+                       &res->mac_addr);
+       switch (ret) {
+       case 0:
+               break;
+       case -EINVAL:
+               printf("invalid vf_id %d or mac_addr\n", res->vf_id);
+               break;
+       case -ENODEV:
+               printf("invalid port_id %d\n", res->port_id);
+               break;
+       default:
+               printf("programming error: (%s)\n", strerror(-ret));
+       }
+}
+
+cmdline_parse_inst_t cmd_set_vf_mac_addr = {
+       .f = cmd_set_vf_mac_addr_parsed,
+       .data = NULL,
+       .help_str = "set vf mac addr port_id vf_id xx:xx:xx:xx:xx:xx",
+       .tokens = {
+               (void *)&cmd_set_vf_mac_addr_set,
+               (void *)&cmd_set_vf_mac_addr_vf,
+               (void *)&cmd_set_vf_mac_addr_mac,
+               (void *)&cmd_set_vf_mac_addr_addr,
+               (void *)&cmd_set_vf_mac_addr_port_id,
+               (void *)&cmd_set_vf_mac_addr_vf_id,
+               (void *)&cmd_set_vf_mac_addr_mac_addr,
+               NULL,
+       },
+};
+#endif
+
+/* ******************************************************************************** */
+
+/* list of instructions */
+cmdline_parse_ctx_t main_ctx[] = {
+       (cmdline_parse_inst_t *)&cmd_help_brief,
+       (cmdline_parse_inst_t *)&cmd_help_long,
+       (cmdline_parse_inst_t *)&cmd_quit,
+       (cmdline_parse_inst_t *)&cmd_showport,
+       (cmdline_parse_inst_t *)&cmd_showqueue,
+       (cmdline_parse_inst_t *)&cmd_showportall,
+       (cmdline_parse_inst_t *)&cmd_showcfg,
+       (cmdline_parse_inst_t *)&cmd_start,
+       (cmdline_parse_inst_t *)&cmd_start_tx_first,
+       (cmdline_parse_inst_t *)&cmd_start_tx_first_n,
+       (cmdline_parse_inst_t *)&cmd_set_link_up,
+       (cmdline_parse_inst_t *)&cmd_set_link_down,
+       (cmdline_parse_inst_t *)&cmd_reset,
+       (cmdline_parse_inst_t *)&cmd_set_numbers,
+       (cmdline_parse_inst_t *)&cmd_set_txpkts,
+       (cmdline_parse_inst_t *)&cmd_set_txsplit,
+       (cmdline_parse_inst_t *)&cmd_set_fwd_list,
+       (cmdline_parse_inst_t *)&cmd_set_fwd_mask,
+       (cmdline_parse_inst_t *)&cmd_set_fwd_mode,
+       (cmdline_parse_inst_t *)&cmd_set_fwd_retry_mode,
+       (cmdline_parse_inst_t *)&cmd_set_burst_tx_retry,
+       (cmdline_parse_inst_t *)&cmd_set_promisc_mode_one,
+       (cmdline_parse_inst_t *)&cmd_set_promisc_mode_all,
+       (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_one,
+       (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_all,
+       (cmdline_parse_inst_t *)&cmd_set_flush_rx,
+       (cmdline_parse_inst_t *)&cmd_set_link_check,
+#ifdef RTE_NIC_BYPASS
+       (cmdline_parse_inst_t *)&cmd_set_bypass_mode,
+       (cmdline_parse_inst_t *)&cmd_set_bypass_event,
+       (cmdline_parse_inst_t *)&cmd_set_bypass_timeout,
+       (cmdline_parse_inst_t *)&cmd_show_bypass_config,
+#endif
+#ifdef RTE_LIBRTE_PMD_BOND
+       (cmdline_parse_inst_t *) &cmd_set_bonding_mode,
+       (cmdline_parse_inst_t *) &cmd_show_bonding_config,
+       (cmdline_parse_inst_t *) &cmd_set_bonding_primary,
+       (cmdline_parse_inst_t *) &cmd_add_bonding_slave,
+       (cmdline_parse_inst_t *) &cmd_remove_bonding_slave,
+       (cmdline_parse_inst_t *) &cmd_create_bonded_device,
+       (cmdline_parse_inst_t *) &cmd_set_bond_mac_addr,
+       (cmdline_parse_inst_t *) &cmd_set_balance_xmit_policy,
+       (cmdline_parse_inst_t *) &cmd_set_bond_mon_period,
+#endif
+       (cmdline_parse_inst_t *)&cmd_vlan_offload,
+       (cmdline_parse_inst_t *)&cmd_vlan_tpid,
+       (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all,
+       (cmdline_parse_inst_t *)&cmd_rx_vlan_filter,
+       (cmdline_parse_inst_t *)&cmd_tx_vlan_set,
+       (cmdline_parse_inst_t *)&cmd_tx_vlan_set_qinq,
+       (cmdline_parse_inst_t *)&cmd_tx_vlan_reset,
+       (cmdline_parse_inst_t *)&cmd_tx_vlan_set_pvid,
+       (cmdline_parse_inst_t *)&cmd_csum_set,
+       (cmdline_parse_inst_t *)&cmd_csum_show,
+       (cmdline_parse_inst_t *)&cmd_csum_tunnel,
+       (cmdline_parse_inst_t *)&cmd_tso_set,
+       (cmdline_parse_inst_t *)&cmd_tso_show,
+       (cmdline_parse_inst_t *)&cmd_tunnel_tso_set,
+       (cmdline_parse_inst_t *)&cmd_tunnel_tso_show,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_hw,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_lw,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_pt,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_xon,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_macfwd,
+       (cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg,
+       (cmdline_parse_inst_t *)&cmd_priority_flow_control_set,
        (cmdline_parse_inst_t *)&cmd_config_dcb,
        (cmdline_parse_inst_t *)&cmd_read_reg,
        (cmdline_parse_inst_t *)&cmd_read_reg_bit_field,
@@ -10478,6 +11508,7 @@ cmdline_parse_ctx_t main_ctx[] = {
        (cmdline_parse_inst_t *)&cmd_config_rx_mode_flag,
        (cmdline_parse_inst_t *)&cmd_config_rss,
        (cmdline_parse_inst_t *)&cmd_config_rxtx_queue,
+       (cmdline_parse_inst_t *)&cmd_config_txqflags,
        (cmdline_parse_inst_t *)&cmd_config_rss_reta,
        (cmdline_parse_inst_t *)&cmd_showport_reta,
        (cmdline_parse_inst_t *)&cmd_config_burst,
@@ -10537,6 +11568,16 @@ cmdline_parse_ctx_t main_ctx[] = {
        (cmdline_parse_inst_t *)&cmd_config_e_tag_forwarding_en_dis,
        (cmdline_parse_inst_t *)&cmd_config_e_tag_filter_add,
        (cmdline_parse_inst_t *)&cmd_config_e_tag_filter_del,
+#ifdef RTE_LIBRTE_IXGBE_PMD
+       (cmdline_parse_inst_t *)&cmd_set_vf_vlan_anti_spoof,
+       (cmdline_parse_inst_t *)&cmd_set_vf_mac_anti_spoof,
+       (cmdline_parse_inst_t *)&cmd_set_vf_vlan_stripq,
+       (cmdline_parse_inst_t *)&cmd_set_vf_vlan_insert,
+       (cmdline_parse_inst_t *)&cmd_set_tx_loopback,
+       (cmdline_parse_inst_t *)&cmd_set_all_queues_drop_en,
+       (cmdline_parse_inst_t *)&cmd_set_vf_split_drop_en,
+       (cmdline_parse_inst_t *)&cmd_set_vf_mac_addr,
+#endif
        NULL,
 };
 
@@ -10546,6 +11587,7 @@ prompt(void)
 {
        /* initialize non-constant commands */
        cmd_set_fwd_mode_init();
+       cmd_set_fwd_retry_mode_init();
 
        testpmd_cl = cmdline_stdin_new(main_ctx, "testpmd> ");
        if (testpmd_cl == NULL)
@@ -10584,29 +11626,3 @@ cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue)
                        ports[id].need_reconfig_queues = queue;
        }
 }
-
-#ifdef RTE_NIC_BYPASS
-#include <rte_pci_dev_ids.h>
-uint8_t
-bypass_is_supported(portid_t port_id)
-{
-       struct rte_port   *port;
-       struct rte_pci_id *pci_id;
-
-       if (port_id_is_invalid(port_id, ENABLED_WARN))
-               return 0;
-
-       /* Get the device id. */
-       port    = &ports[port_id];
-       pci_id = &port->dev_info.pci_dev->id;
-
-       /* Check if NIC supports bypass. */
-       if (pci_id->device_id == IXGBE_DEV_ID_82599_BYPASS) {
-               return 1;
-       }
-       else {
-               printf("\tBypass not supported for port_id = %d.\n", port_id);
-               return 0;
-       }
-}
-#endif