X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=062a233e97d8b5d61c383395242f535d9a527658;hb=e9d48c0072d36eb6423b45fba4ec49d0def6c36f;hp=d17b3645ad1c1295923fe11e9eebffaeb79b4af0;hpb=1c1d4d7a923d4804f1926fc5264f9ecdd8977b04;p=dpdk.git

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index d17b3645ad..062a233e97 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  * 
- *   Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
  *   All rights reserved.
  * 
  *   Redistribution and use in source and binary forms, with or without
@@ -77,11 +77,16 @@
 #include <cmdline_parse_etheraddr.h>
 #include <cmdline_socket.h>
 #include <cmdline.h>
+#include <rte_pci_dev_ids.h>
 
 #include "testpmd.h"
 
 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;
@@ -228,6 +233,9 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"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"
+
 			"vlan set filter (on|off) (port_id)\n"
 			"    Set the VLAN filter on a port.\n\n"
 
@@ -247,6 +255,18 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    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_vlan set tpid (value) (port_id)\n"
+			"    Set the outer VLAN TPID for Packet Filtering on"
+			" a port\n\n"
+
 			"tx_vlan set vlan_id (port_id)\n"
 			"    Set hardware insertion of VLAN ID in packets sent"
 			" on a port.\n\n"
@@ -281,6 +301,13 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"mac_addr remove (port_id) (XX:XX:XX:XX:XX:XX)\n"
 			"    Remove a MAC address from 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 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"
 
@@ -288,7 +315,8 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    Set the allmulti mode on port_id, or all.\n\n"
 
 			"set flow_ctrl rx (on|off) tx (on|off) (high_water)"
-			" (low_water) (pause_time) (send_xon) (port_id)\n"
+			" (low_water) (pause_time) (send_xon) mac_ctrl_frame_fwd"
+                        " (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)"
@@ -301,6 +329,65 @@ static void cmd_help_long_parsed(void *parsed_result,
 			" 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 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) mirror-rule (rule_id)" 
+			"(pool-mirror|vlan-mirror)\n"
+			" (poolmask|vlanid[,vlanid]*) dst-pool (pool_id) (on|off)\n"
+			"   Set pool or vlan type mirror rule on a port.\n"
+			"   e.g., 'set port 0 mirror-rule 0 vlan-mirror 0,1"
+			" dst-pool 0 on' enable mirror traffic with vlan 0,1"
+			" to pool 0.\n\n"
+
+			"set port (port_id) mirror-rule (rule_id)"
+			" (uplink-mirror|downlink-mirror) dst-pool"
+			" (pool_id) (on|off)\n"
+			"   Set uplink or downlink type mirror rule on a port.\n"
+			"   e.g., 'set port 0 mirror-rule 0 uplink-mirror dst-pool"
+			" 0 on' enable mirror income traffic to pool 0.\n\n"
+
+			"reset port (port_id) mirror-rule (rule_id)\n"
+			"   Reset a mirror rule.\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"
+
+			#ifdef RTE_NIC_BYPASS
+			"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"
+#endif
+
 		);
 	}
 
@@ -1196,7 +1283,7 @@ cmdline_parse_inst_t cmd_config_rss_reta = {
 	},
 };
 
-/* *** SHOW PORT INFO *** */
+/* *** SHOW PORT RETA INFO *** */
 struct cmd_showport_reta {
 	cmdline_fixed_string_t show;
 	cmdline_fixed_string_t port;
@@ -1920,8 +2007,10 @@ cmd_vlan_offload_parsed(void *parsed_result,
 		uint16_t queue_id = 0;
 
 		/* No queue_id, return */
-		if(i + 1 >= len)
+		if(i + 1 >= len) {
+			printf("must specify (port,queue_id)\n");
 			return;
+		}
 		tmp = strtoul(str + i + 1, NULL, 0);
 		/* If queue_id greater that what 16-bits can represent, return */
 		if(tmp > 0xffff)
@@ -2197,6 +2286,376 @@ cmdline_parse_inst_t cmd_tx_cksum_set = {
 	},
 };
 
+/* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */
+struct cmd_set_flush_rx {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t flush_rx;
+	cmdline_fixed_string_t mode;
+};
+
+static void
+cmd_set_flush_rx_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	struct cmd_set_flush_rx *res = parsed_result;
+	no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
+}
+
+cmdline_parse_token_string_t cmd_setflushrx_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
+			set, "set");
+cmdline_parse_token_string_t cmd_setflushrx_flush_rx =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
+			flush_rx, "flush_rx");
+cmdline_parse_token_string_t cmd_setflushrx_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
+			mode, "on#off");
+
+
+cmdline_parse_inst_t cmd_set_flush_rx = {
+	.f = cmd_set_flush_rx_parsed,
+	.help_str = "set flush_rx on|off: enable/disable flush on rx streams",
+	.data = NULL,
+	.tokens = {
+		(void *)&cmd_setflushrx_set,
+		(void *)&cmd_setflushrx_flush_rx,
+		(void *)&cmd_setflushrx_mode,
+		NULL,
+	},
+};
+
+#ifdef RTE_NIC_BYPASS
+/* *** SET NIC BYPASS MODE *** */
+struct cmd_set_bypass_mode_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t bypass;
+	cmdline_fixed_string_t mode;
+	cmdline_fixed_string_t value;
+	uint8_t port_id;
+};
+
+static void
+cmd_set_bypass_mode_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	struct cmd_set_bypass_mode_result *res = 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"))
+		bypass_mode = RTE_BYPASS_MODE_ISOLATE;
+	else
+		bypass_mode = RTE_BYPASS_MODE_NORMAL;
+
+	/* Set the bypass mode for the relevant port. */
+	if (0 != rte_eth_dev_bypass_state_set(port_id, &bypass_mode)) {
+		printf("\t Failed to set bypass mode for port = %d.\n", port_id);
+	}
+}
+
+cmdline_parse_token_string_t cmd_setbypass_mode_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
+			set, "set");
+cmdline_parse_token_string_t cmd_setbypass_mode_bypass =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
+			bypass, "bypass");
+cmdline_parse_token_string_t cmd_setbypass_mode_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
+			mode, "mode");
+cmdline_parse_token_string_t cmd_setbypass_mode_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
+			value, "normal#bypass#isolate");
+cmdline_parse_token_num_t cmd_setbypass_mode_port =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_mode_result,
+				port_id, UINT8);
+
+cmdline_parse_inst_t cmd_set_bypass_mode = {
+	.f = cmd_set_bypass_mode_parsed,
+	.help_str = "set bypass mode (normal|bypass|isolate) (port_id): "
+	            "Set the NIC bypass mode for port_id",
+	.data = NULL,
+	.tokens = {
+		(void *)&cmd_setbypass_mode_set,
+		(void *)&cmd_setbypass_mode_bypass,
+		(void *)&cmd_setbypass_mode_mode,
+		(void *)&cmd_setbypass_mode_value,
+		(void *)&cmd_setbypass_mode_port,
+		NULL,
+	},
+};
+
+/* *** SET NIC BYPASS EVENT *** */
+struct cmd_set_bypass_event_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t bypass;
+	cmdline_fixed_string_t event;
+	cmdline_fixed_string_t event_value;
+	cmdline_fixed_string_t mode;
+	cmdline_fixed_string_t mode_value;
+	uint8_t port_id;
+};
+
+static void
+cmd_set_bypass_event_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	int32_t rc;
+	struct cmd_set_bypass_event_result *res = parsed_result;
+	portid_t port_id = res->port_id;
+	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"))
+		bypass_event = RTE_BYPASS_EVENT_OS_ON;
+	else if (!strcmp(res->event_value, "os_off"))
+		bypass_event = RTE_BYPASS_EVENT_OS_OFF;
+	else if (!strcmp(res->event_value, "power_on"))
+		bypass_event = RTE_BYPASS_EVENT_POWER_ON;
+	else if (!strcmp(res->event_value, "power_off"))
+		bypass_event = RTE_BYPASS_EVENT_POWER_OFF;
+	else
+		bypass_event = RTE_BYPASS_EVENT_NONE;
+
+	if (!strcmp(res->mode_value, "bypass"))
+		bypass_mode = RTE_BYPASS_MODE_BYPASS;
+	else if (!strcmp(res->mode_value, "isolate"))
+		bypass_mode = RTE_BYPASS_MODE_ISOLATE;
+	else
+		bypass_mode = RTE_BYPASS_MODE_NORMAL;
+
+	/* Set the watchdog timeout. */
+	if (bypass_event == RTE_BYPASS_EVENT_TIMEOUT) {
+
+		rc = -EINVAL;
+		if (!RTE_BYPASS_TMT_VALID(bypass_timeout) ||
+				(rc = rte_eth_dev_wd_timeout_store(port_id,
+				bypass_timeout)) != 0) {
+			printf("Failed to set timeout value %u "
+				"for port %d, errto code: %d.\n",
+				bypass_timeout, port_id, rc);
+		}
+	}
+
+	/* Set the bypass event to transition to bypass mode. */
+	if (0 != rte_eth_dev_bypass_event_store(port_id,
+			bypass_event, bypass_mode)) {
+		printf("\t Failed to set bypass event for port = %d.\n", port_id);
+	}
+
+}
+
+cmdline_parse_token_string_t cmd_setbypass_event_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			set, "set");
+cmdline_parse_token_string_t cmd_setbypass_event_bypass =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			bypass, "bypass");
+cmdline_parse_token_string_t cmd_setbypass_event_event =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			event, "event");
+cmdline_parse_token_string_t cmd_setbypass_event_event_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			event_value, "none#timeout#os_off#os_on#power_on#power_off");
+cmdline_parse_token_string_t cmd_setbypass_event_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			mode, "mode");
+cmdline_parse_token_string_t cmd_setbypass_event_mode_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
+			mode_value, "normal#bypass#isolate");
+cmdline_parse_token_num_t cmd_setbypass_event_port =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_event_result,
+				port_id, UINT8);
+
+cmdline_parse_inst_t cmd_set_bypass_event = {
+	.f = cmd_set_bypass_event_parsed,
+	.help_str = "set bypass event (timeout|os_on|os_off|power_on|power_off) "
+	            "mode (normal|bypass|isolate) (port_id): "
+	            "Set the NIC bypass event mode for port_id",
+	.data = NULL,
+	.tokens = {
+		(void *)&cmd_setbypass_event_set,
+		(void *)&cmd_setbypass_event_bypass,
+		(void *)&cmd_setbypass_event_event,
+		(void *)&cmd_setbypass_event_event_value,
+		(void *)&cmd_setbypass_event_mode,
+		(void *)&cmd_setbypass_event_mode_value,
+		(void *)&cmd_setbypass_event_port,
+		NULL,
+	},
+};
+
+
+/* *** SET NIC BYPASS TIMEOUT *** */
+struct cmd_set_bypass_timeout_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t bypass;
+	cmdline_fixed_string_t timeout;
+	cmdline_fixed_string_t value;
+};
+
+static void
+cmd_set_bypass_timeout_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	struct cmd_set_bypass_timeout_result *res = parsed_result;
+
+	if (!strcmp(res->value, "1.5"))
+		bypass_timeout = RTE_BYPASS_TMT_1_5_SEC;
+	else if (!strcmp(res->value, "2"))
+		bypass_timeout = RTE_BYPASS_TMT_2_SEC;
+	else if (!strcmp(res->value, "3"))
+		bypass_timeout = RTE_BYPASS_TMT_3_SEC;
+	else if (!strcmp(res->value, "4"))
+		bypass_timeout = RTE_BYPASS_TMT_4_SEC;
+	else if (!strcmp(res->value, "8"))
+		bypass_timeout = RTE_BYPASS_TMT_8_SEC;
+	else if (!strcmp(res->value, "16"))
+		bypass_timeout = RTE_BYPASS_TMT_16_SEC;
+	else if (!strcmp(res->value, "32"))
+		bypass_timeout = RTE_BYPASS_TMT_32_SEC;
+	else
+		bypass_timeout = RTE_BYPASS_TMT_OFF;
+}
+
+cmdline_parse_token_string_t cmd_setbypass_timeout_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
+			set, "set");
+cmdline_parse_token_string_t cmd_setbypass_timeout_bypass =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
+			bypass, "bypass");
+cmdline_parse_token_string_t cmd_setbypass_timeout_timeout =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
+			timeout, "timeout");
+cmdline_parse_token_string_t cmd_setbypass_timeout_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
+			value, "0#1.5#2#3#4#8#16#32");
+
+cmdline_parse_inst_t cmd_set_bypass_timeout = {
+	.f = cmd_set_bypass_timeout_parsed,
+	.help_str = "set bypass timeout (0|1.5|2|3|4|8|16|32) seconds: "
+	            "Set the NIC bypass watchdog timeout",
+	.data = NULL,
+	.tokens = {
+		(void *)&cmd_setbypass_timeout_set,
+		(void *)&cmd_setbypass_timeout_bypass,
+		(void *)&cmd_setbypass_timeout_timeout,
+		(void *)&cmd_setbypass_timeout_value,
+		NULL,
+	},
+};
+
+/* *** SHOW NIC BYPASS MODE *** */
+struct cmd_show_bypass_config_result {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t bypass;
+	cmdline_fixed_string_t config;
+	uint8_t port_id;
+};
+
+static void
+cmd_show_bypass_config_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	struct cmd_show_bypass_config_result *res = parsed_result;
+	uint32_t event_mode;
+	uint32_t bypass_mode;
+	portid_t port_id = res->port_id;
+	uint32_t timeout = bypass_timeout;
+	int i;
+
+	static const char * const timeouts[RTE_BYPASS_TMT_NUM] =
+		{"off", "1.5", "2", "3", "4", "8", "16", "32"};
+	static const char * const modes[RTE_BYPASS_MODE_NUM] =
+		{"UNKNOWN", "normal", "bypass", "isolate"};
+	static const char * const events[RTE_BYPASS_EVENT_NUM] = {
+		"NONE",
+		"OS/board on",
+		"power supply on",
+		"OS/board off",
+		"power supply off",
+		"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);
+		return;
+	}
+	else {
+		if (!RTE_BYPASS_MODE_VALID(bypass_mode))
+			bypass_mode = RTE_BYPASS_MODE_NONE;
+
+		printf("\tbypass mode    = %s\n",  modes[bypass_mode]);
+	}
+
+	/* Display the bypass timeout.*/
+	if (!RTE_BYPASS_TMT_VALID(timeout))
+		timeout = RTE_BYPASS_TMT_OFF;
+
+	printf("\tbypass timeout = %s\n", timeouts[timeout]);
+
+	/* Display the bypass events and associated modes. */
+	for (i = RTE_BYPASS_EVENT_START; i < num_events; i++) {
+
+		if (0 != rte_eth_dev_bypass_event_show(port_id, i, &event_mode)) {
+			printf("\tFailed to get bypass mode for event = %s\n",
+				events[i]);
+		} else {
+			if (!RTE_BYPASS_MODE_VALID(event_mode))
+				event_mode = RTE_BYPASS_MODE_NONE;
+
+			printf("\tbypass event: %-16s = %s\n", events[i],
+				modes[event_mode]);
+		}
+	}
+}
+
+cmdline_parse_token_string_t cmd_showbypass_config_show =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
+			show, "show");
+cmdline_parse_token_string_t cmd_showbypass_config_bypass =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
+			bypass, "bypass");
+cmdline_parse_token_string_t cmd_showbypass_config_config =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
+			config, "config");
+cmdline_parse_token_num_t cmd_showbypass_config_port =
+	TOKEN_NUM_INITIALIZER(struct cmd_show_bypass_config_result,
+				port_id, UINT8);
+
+cmdline_parse_inst_t cmd_show_bypass_config = {
+	.f = cmd_show_bypass_config_parsed,
+	.help_str = "show bypass config (port_id): "
+	            "Show the NIC bypass config for port_id",
+	.data = NULL,
+	.tokens = {
+		(void *)&cmd_showbypass_config_show,
+		(void *)&cmd_showbypass_config_bypass,
+		(void *)&cmd_showbypass_config_config,
+		(void *)&cmd_showbypass_config_port,
+		NULL,
+	},
+};
+#endif
+
 /* *** SET FORWARDING MODE *** */
 struct cmd_set_fwd_mode_result {
 	cmdline_fixed_string_t set;
@@ -2908,6 +3367,8 @@ struct cmd_link_flow_ctrl_set_result {
 	cmdline_fixed_string_t rx_lfc_mode;
 	cmdline_fixed_string_t tx;
 	cmdline_fixed_string_t tx_lfc_mode;
+	cmdline_fixed_string_t mac_ctrl_frame_fwd;
+	cmdline_fixed_string_t mac_ctrl_frame_fwd_mode;
 	uint32_t high_water;
 	uint32_t low_water;
 	uint16_t pause_time;
@@ -2922,7 +3383,7 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result,
 {
 	struct cmd_link_flow_ctrl_set_result *res = parsed_result;
 	struct rte_eth_fc_conf fc_conf;
-	int rx_fc_enable, tx_fc_enable;
+	int rx_fc_enable, tx_fc_enable, mac_ctrl_frame_fwd;
 	int ret;
 
 	/*
@@ -2937,12 +3398,14 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result,
 
 	rx_fc_enable = (!strcmp(res->rx_lfc_mode, "on")) ? 1 : 0;
 	tx_fc_enable = (!strcmp(res->tx_lfc_mode, "on")) ? 1 : 0;
+	mac_ctrl_frame_fwd = (!strcmp(res->mac_ctrl_frame_fwd_mode, "on")) ? 1 : 0;
 
 	fc_conf.mode       = rx_tx_onoff_2_lfc_mode[rx_fc_enable][tx_fc_enable];
 	fc_conf.high_water = res->high_water;
 	fc_conf.low_water  = res->low_water;
 	fc_conf.pause_time = res->pause_time;
 	fc_conf.send_xon   = res->send_xon;
+	fc_conf.mac_ctrl_frame_fwd = (uint8_t)mac_ctrl_frame_fwd;
 
 	ret = rte_eth_dev_flow_ctrl_set(res->port_id, &fc_conf);
 	if (ret != 0)
@@ -2979,6 +3442,12 @@ cmdline_parse_token_num_t cmd_lfc_set_pause_time =
 cmdline_parse_token_num_t cmd_lfc_set_send_xon =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				send_xon, UINT16);
+cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
+				mac_ctrl_frame_fwd, "mac_ctrl_frame_fwd");
+cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd =
+	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
+				mac_ctrl_frame_fwd_mode, "on#off");
 cmdline_parse_token_num_t cmd_lfc_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				port_id, UINT8);
@@ -2986,7 +3455,9 @@ cmdline_parse_token_num_t cmd_lfc_set_portid =
 cmdline_parse_inst_t cmd_link_flow_control_set = {
 	.f = cmd_link_flow_ctrl_set_parsed,
 	.data = NULL,
-	.help_str = "Configure the Ethernet link flow control...",
+	.help_str = "Configure the Ethernet flow control: set flow_ctrl rx on|off \
+tx on|off high_water low_water pause_time send_xon mac_ctrl_frame_fwd on|off \
+port_id",
 	.tokens = {
 		(void *)&cmd_lfc_set_set,
 		(void *)&cmd_lfc_set_flow_ctrl,
@@ -2998,6 +3469,8 @@ cmdline_parse_inst_t cmd_link_flow_control_set = {
 		(void *)&cmd_lfc_set_low_water,
 		(void *)&cmd_lfc_set_pause_time,
 		(void *)&cmd_lfc_set_send_xon,
+		(void *)&cmd_lfc_set_mac_ctrl_frame_fwd_mode,
+		(void *)&cmd_lfc_set_mac_ctrl_frame_fwd,
 		(void *)&cmd_lfc_set_portid,
 		NULL,
 	},
@@ -3811,6 +4284,652 @@ cmdline_parse_inst_t cmd_set_qmap = {
 	},
 };
 
+/* *** CONFIGURE UNICAST HASH TABLE *** */
+struct cmd_set_uc_hash_table {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t what;
+	struct ether_addr address;
+	cmdline_fixed_string_t mode;
+};
+
+static void
+cmd_set_uc_hash_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret=0;
+	struct cmd_set_uc_hash_table *res = parsed_result;
+	
+	int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0;
+	
+	if (strcmp(res->what, "uta") == 0)
+		ret = rte_eth_dev_uc_hash_table_set(res->port_id, 
+						&res->address,(uint8_t)is_on);
+	if (ret < 0)
+		printf("bad unicast hash table parameter, return code = %d \n", ret);
+	
+}
+
+cmdline_parse_token_string_t cmd_set_uc_hash_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
+				 set, "set");
+cmdline_parse_token_string_t cmd_set_uc_hash_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
+				 port, "port");
+cmdline_parse_token_num_t cmd_set_uc_hash_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table,
+			      port_id, UINT8);
+cmdline_parse_token_string_t cmd_set_uc_hash_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
+				 what, "uta");
+cmdline_parse_token_etheraddr_t cmd_set_uc_hash_mac =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_uc_hash_table, 
+				address);
+cmdline_parse_token_string_t cmd_set_uc_hash_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
+				 mode, "on#off");
+
+cmdline_parse_inst_t cmd_set_uc_hash_filter = {
+	.f = cmd_set_uc_hash_parsed,
+	.data = NULL,
+	.help_str = "set port X uta Y on|off(X = port number,Y = MAC address)",
+	.tokens = {
+		(void *)&cmd_set_uc_hash_set,
+		(void *)&cmd_set_uc_hash_port,
+		(void *)&cmd_set_uc_hash_portid,
+		(void *)&cmd_set_uc_hash_what,
+		(void *)&cmd_set_uc_hash_mac,
+		(void *)&cmd_set_uc_hash_mode,
+		NULL,
+	},
+};
+
+struct cmd_set_uc_all_hash_table {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t value;
+	cmdline_fixed_string_t mode;
+};
+
+static void
+cmd_set_uc_all_hash_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret=0;
+	struct cmd_set_uc_all_hash_table *res = parsed_result;
+	
+	int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0;
+	
+	if ((strcmp(res->what, "uta") == 0) && 
+		(strcmp(res->value, "all") == 0))
+		ret = rte_eth_dev_uc_all_hash_table_set(res->port_id,(uint8_t) is_on);
+	if (ret < 0)
+		printf("bad unicast hash table parameter," 
+			"return code = %d \n", ret);
+}
+
+cmdline_parse_token_string_t cmd_set_uc_all_hash_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
+				 set, "set");
+cmdline_parse_token_string_t cmd_set_uc_all_hash_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
+				 port, "port");
+cmdline_parse_token_num_t cmd_set_uc_all_hash_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table,
+			      port_id, UINT8);
+cmdline_parse_token_string_t cmd_set_uc_all_hash_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
+				 what, "uta");
+cmdline_parse_token_string_t cmd_set_uc_all_hash_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 
+				value,"all");
+cmdline_parse_token_string_t cmd_set_uc_all_hash_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
+				 mode, "on#off");
+
+cmdline_parse_inst_t cmd_set_uc_all_hash_filter = {
+	.f = cmd_set_uc_all_hash_parsed,
+	.data = NULL,
+	.help_str = "set port X uta all on|off (X = port number)",
+	.tokens = {
+		(void *)&cmd_set_uc_all_hash_set,
+		(void *)&cmd_set_uc_all_hash_port,
+		(void *)&cmd_set_uc_all_hash_portid,
+		(void *)&cmd_set_uc_all_hash_what,
+		(void *)&cmd_set_uc_all_hash_value,
+		(void *)&cmd_set_uc_all_hash_mode,
+		NULL,
+	},
+};
+
+/* *** CONFIGURE VF TRAFFIC CONTROL *** */
+struct cmd_set_vf_traffic {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t vf;
+	uint8_t vf_id;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t mode;
+};
+
+static void
+cmd_set_vf_traffic_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	struct cmd_set_vf_traffic *res = parsed_result;
+	int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0;
+	int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0;
+
+	set_vf_traffic(res->port_id, (uint8_t)is_rx, res->vf_id,(uint8_t) is_on);
+}
+
+cmdline_parse_token_string_t cmd_setvf_traffic_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
+				 set, "set");
+cmdline_parse_token_string_t cmd_setvf_traffic_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
+				 port, "port");
+cmdline_parse_token_num_t cmd_setvf_traffic_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
+			      port_id, UINT8);
+cmdline_parse_token_string_t cmd_setvf_traffic_vf =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
+				 vf, "vf");
+cmdline_parse_token_num_t cmd_setvf_traffic_vfid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
+			      vf_id, UINT8);
+cmdline_parse_token_string_t cmd_setvf_traffic_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
+				 what, "tx#rx");
+cmdline_parse_token_string_t cmd_setvf_traffic_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
+				 mode, "on#off");
+
+cmdline_parse_inst_t cmd_set_vf_traffic = {
+	.f = cmd_set_vf_traffic_parsed,
+	.data = NULL,
+	.help_str = "set port X vf Y rx|tx on|off (X = port number,Y = vf id)",
+	.tokens = {
+		(void *)&cmd_setvf_traffic_set,
+		(void *)&cmd_setvf_traffic_port,
+		(void *)&cmd_setvf_traffic_portid,
+		(void *)&cmd_setvf_traffic_vf,
+		(void *)&cmd_setvf_traffic_vfid,
+		(void *)&cmd_setvf_traffic_what,
+		(void *)&cmd_setvf_traffic_mode,
+		NULL,
+	},
+};
+
+/* *** CONFIGURE VF RECEIVE MODE *** */
+struct cmd_set_vf_rxmode {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t vf;
+	uint8_t vf_id;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t mode;
+	cmdline_fixed_string_t on;
+};
+
+static void
+cmd_set_vf_rxmode_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret;
+	uint16_t rx_mode = 0;
+	struct cmd_set_vf_rxmode *res = parsed_result;
+	
+	int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0;
+	if (!strcmp(res->what,"rxmode")) {
+		if (!strcmp(res->mode, "AUPE"))
+			rx_mode |= ETH_VMDQ_ACCEPT_UNTAG;
+		else if (!strcmp(res->mode, "ROPE"))
+			rx_mode |= ETH_VMDQ_ACCEPT_HASH_UC;
+		else if (!strcmp(res->mode, "BAM"))
+			rx_mode |= ETH_VMDQ_ACCEPT_BROADCAST;
+		else if (!strncmp(res->mode, "MPE",3))
+			rx_mode |= ETH_VMDQ_ACCEPT_MULTICAST;
+	}
+
+	ret = rte_eth_dev_set_vf_rxmode(res->port_id,res->vf_id,rx_mode,(uint8_t)is_on);
+	if (ret < 0)
+		printf("bad VF receive mode parameter, return code = %d \n",
+		ret);
+}
+
+cmdline_parse_token_string_t cmd_set_vf_rxmode_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 set, "set");
+cmdline_parse_token_string_t cmd_set_vf_rxmode_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 port, "port");
+cmdline_parse_token_num_t cmd_set_vf_rxmode_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
+			      port_id, UINT8);
+cmdline_parse_token_string_t cmd_set_vf_rxmode_vf =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 vf, "vf");
+cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
+			      vf_id, UINT8);
+cmdline_parse_token_string_t cmd_set_vf_rxmode_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 what, "rxmode");
+cmdline_parse_token_string_t cmd_set_vf_rxmode_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 mode, "AUPE#ROPE#BAM#MPE");
+cmdline_parse_token_string_t cmd_set_vf_rxmode_on =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
+				 on, "on#off");
+
+cmdline_parse_inst_t cmd_set_vf_rxmode = {
+	.f = cmd_set_vf_rxmode_parsed,
+	.data = NULL,
+	.help_str = "set port X vf Y rxmode AUPE|ROPE|BAM|MPE on|off",
+	.tokens = {
+		(void *)&cmd_set_vf_rxmode_set,
+		(void *)&cmd_set_vf_rxmode_port,
+		(void *)&cmd_set_vf_rxmode_portid,
+		(void *)&cmd_set_vf_rxmode_vf,
+		(void *)&cmd_set_vf_rxmode_vfid,
+		(void *)&cmd_set_vf_rxmode_what,
+		(void *)&cmd_set_vf_rxmode_mode,
+		(void *)&cmd_set_vf_rxmode_on,
+		NULL,
+	},
+};
+
+/* *** ADD MAC ADDRESS FILTER FOR A VF OF A PORT *** */
+struct cmd_vf_mac_addr_result {
+	cmdline_fixed_string_t mac_addr_cmd;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t port;
+	uint8_t port_num;
+	cmdline_fixed_string_t vf;
+	uint8_t vf_num;
+	struct ether_addr address;
+};
+
+static void cmd_vf_mac_addr_parsed(void *parsed_result,
+		__attribute__((unused)) struct cmdline *cl,
+		__attribute__((unused)) void *data)
+{
+	struct cmd_vf_mac_addr_result *res = parsed_result;
+	int ret = 0;
+
+	if (strcmp(res->what, "add") == 0)
+		ret = rte_eth_dev_mac_addr_add(res->port_num, 
+					&res->address, res->vf_num);
+	if(ret < 0)
+		printf("vf_mac_addr_cmd error: (%s)\n", strerror(-ret));
+
+}
+
+cmdline_parse_token_string_t cmd_vf_mac_addr_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
+				mac_addr_cmd,"mac_addr");
+cmdline_parse_token_string_t cmd_vf_mac_addr_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 
+				what,"add");
+cmdline_parse_token_string_t cmd_vf_mac_addr_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 
+				port,"port");
+cmdline_parse_token_num_t cmd_vf_mac_addr_portnum =
+	TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result, 
+				port_num, UINT8);
+cmdline_parse_token_string_t cmd_vf_mac_addr_vf =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 
+				vf,"vf");
+cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum =
+	TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
+				vf_num, UINT8);
+cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result, 
+				address);
+
+cmdline_parse_inst_t cmd_vf_mac_addr_filter = {
+	.f = cmd_vf_mac_addr_parsed,
+	.data = (void *)0,
+	.help_str = "mac_addr add port X vf Y ethaddr:(X = port number,"
+	"Y = VF number)add MAC address filtering for a VF on port X",
+	.tokens = {
+		(void *)&cmd_vf_mac_addr_cmd,
+		(void *)&cmd_vf_mac_addr_what,
+		(void *)&cmd_vf_mac_addr_port,
+		(void *)&cmd_vf_mac_addr_portnum,
+		(void *)&cmd_vf_mac_addr_vf,
+		(void *)&cmd_vf_mac_addr_vfnum,
+		(void *)&cmd_vf_mac_addr_addr,
+		NULL,
+	},
+};
+
+/* *** ADD/REMOVE A VLAN IDENTIFIER TO/FROM A PORT VLAN RX FILTER *** */
+struct cmd_vf_rx_vlan_filter {
+	cmdline_fixed_string_t rx_vlan;
+	cmdline_fixed_string_t what;
+	uint16_t vlan_id;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t vf;
+	uint64_t vf_mask;
+};
+
+static void
+cmd_vf_rx_vlan_filter_parsed(void *parsed_result,
+			  __attribute__((unused)) struct cmdline *cl,
+			  __attribute__((unused)) void *data)
+{
+	struct cmd_vf_rx_vlan_filter *res = parsed_result;
+
+	if (!strcmp(res->what, "add"))
+		set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 1);
+	else
+		set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 0);
+}
+
+cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_rx_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+				 rx_vlan, "rx_vlan");
+cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+				 what, "add#rm");
+cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid =
+	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+			      vlan_id, UINT16);
+cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+				 port, "port");
+cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+			      port_id, UINT8);
+cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf =
+	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+				 vf, "vf");
+cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vf_mask =
+	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
+			      vf_mask, UINT64);
+
+cmdline_parse_inst_t cmd_vf_rxvlan_filter = {
+	.f = cmd_vf_rx_vlan_filter_parsed,
+	.data = NULL,
+	.help_str = "rx_vlan add|rm X port Y vf Z (X = VLAN ID,"
+		"Y = port number,Z = hexadecimal VF mask)",
+	.tokens = {
+		(void *)&cmd_vf_rx_vlan_filter_rx_vlan,
+		(void *)&cmd_vf_rx_vlan_filter_what,
+		(void *)&cmd_vf_rx_vlan_filter_vlanid,
+		(void *)&cmd_vf_rx_vlan_filter_port,
+		(void *)&cmd_vf_rx_vlan_filter_portid,
+		(void *)&cmd_vf_rx_vlan_filter_vf,
+		(void *)&cmd_vf_rx_vlan_filter_vf_mask,
+		NULL,
+	},
+};
+
+/* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */
+struct cmd_set_mirror_mask_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t mirror;
+	uint8_t rule_id;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t value;
+	cmdline_fixed_string_t dstpool;
+	uint8_t dstpool_id;
+	cmdline_fixed_string_t on;
+};
+
+cmdline_parse_token_string_t cmd_mirror_mask_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				set, "set");
+cmdline_parse_token_string_t cmd_mirror_mask_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				port, "port");
+cmdline_parse_token_string_t cmd_mirror_mask_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
+				port_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_mask_mirror =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				mirror, "mirror-rule");
+cmdline_parse_token_num_t cmd_mirror_mask_ruleid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
+				rule_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_mask_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				what, "pool-mirror#vlan-mirror");
+cmdline_parse_token_string_t cmd_mirror_mask_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				value, NULL);
+cmdline_parse_token_string_t cmd_mirror_mask_dstpool =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				dstpool, "dst-pool");
+cmdline_parse_token_num_t cmd_mirror_mask_poolid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
+				dstpool_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_mask_on =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
+				on, "on#off");
+
+static void
+cmd_set_mirror_mask_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret,nb_item,i;
+	struct cmd_set_mirror_mask_result *res = parsed_result;
+	struct rte_eth_vmdq_mirror_conf mr_conf;
+
+	memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf));
+
+	unsigned int vlan_list[ETH_VMDQ_MAX_VLAN_FILTERS];
+
+	mr_conf.dst_pool = res->dstpool_id;
+
+	if (!strcmp(res->what, "pool-mirror")) {
+		mr_conf.pool_mask = strtoull(res->value,NULL,16);
+		mr_conf.rule_type_mask = ETH_VMDQ_POOL_MIRROR;
+	} else if(!strcmp(res->what, "vlan-mirror")) {
+		mr_conf.rule_type_mask = ETH_VMDQ_VLAN_MIRROR;
+		nb_item = parse_item_list(res->value, "core",
+					ETH_VMDQ_MAX_VLAN_FILTERS,vlan_list,1);
+		if (nb_item <= 0)
+			return;
+
+		for(i=0; i < nb_item; i++) {
+			if (vlan_list[i] > ETHER_MAX_VLAN_ID) {
+				printf("Invalid vlan_id: must be < 4096\n");
+				return;
+			}
+
+			mr_conf.vlan.vlan_id[i] = (uint16_t)vlan_list[i];
+			mr_conf.vlan.vlan_mask |= 1ULL << i;
+		}
+	}
+
+	if(!strcmp(res->on, "on"))
+		ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf,
+						res->rule_id, 1);
+	else
+		ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf,
+						res->rule_id, 0);
+	if(ret < 0)
+		printf("mirror rule add error: (%s)\n", strerror(-ret));
+}
+
+cmdline_parse_inst_t cmd_set_mirror_mask = {
+		.f = cmd_set_mirror_mask_parsed,
+		.data = NULL,
+		.help_str = "set port X mirror-rule Y pool-mirror|vlan-mirror " 
+				"pool_mask|vlan_id[,vlan_id]* dst-pool Z on|off",
+		.tokens = {
+			(void *)&cmd_mirror_mask_set,
+			(void *)&cmd_mirror_mask_port,
+			(void *)&cmd_mirror_mask_portid,
+			(void *)&cmd_mirror_mask_mirror,
+			(void *)&cmd_mirror_mask_ruleid,
+			(void *)&cmd_mirror_mask_what,
+			(void *)&cmd_mirror_mask_value,
+			(void *)&cmd_mirror_mask_dstpool,
+			(void *)&cmd_mirror_mask_poolid,
+			(void *)&cmd_mirror_mask_on,
+			NULL,
+		},
+};
+
+/* *** CONFIGURE VM MIRROR UDLINK/DOWNLINK RULE *** */
+struct cmd_set_mirror_link_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t mirror;
+	uint8_t rule_id;
+	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t dstpool;
+	uint8_t dstpool_id;
+	cmdline_fixed_string_t on;
+};
+
+cmdline_parse_token_string_t cmd_mirror_link_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				 set, "set");
+cmdline_parse_token_string_t cmd_mirror_link_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				port, "port");
+cmdline_parse_token_string_t cmd_mirror_link_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
+				port_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_link_mirror =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				mirror, "mirror-rule");
+cmdline_parse_token_num_t cmd_mirror_link_ruleid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
+			    rule_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_link_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				what, "uplink-mirror#downlink-mirror");
+cmdline_parse_token_string_t cmd_mirror_link_dstpool =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				dstpool, "dst-pool");
+cmdline_parse_token_num_t cmd_mirror_link_poolid =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
+				dstpool_id, UINT8);
+cmdline_parse_token_string_t cmd_mirror_link_on =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
+				on, "on#off");
+
+static void
+cmd_set_mirror_link_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret;
+	struct cmd_set_mirror_link_result *res = parsed_result;
+	struct rte_eth_vmdq_mirror_conf mr_conf;
+
+	memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf));
+	if(!strcmp(res->what, "uplink-mirror")) {
+		mr_conf.rule_type_mask = ETH_VMDQ_UPLINK_MIRROR;
+	}else if(!strcmp(res->what, "downlink-mirror"))
+		mr_conf.rule_type_mask = ETH_VMDQ_DOWNLIN_MIRROR;
+
+	mr_conf.dst_pool = res->dstpool_id;
+
+	if(!strcmp(res->on, "on"))
+		ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf,
+						res->rule_id, 1);
+	else
+		ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf,
+						res->rule_id, 0);
+
+	/* check the return value and print it if is < 0 */
+	if(ret < 0)
+		printf("mirror rule add error: (%s)\n", strerror(-ret));
+
+}
+
+cmdline_parse_inst_t cmd_set_mirror_link = {
+		.f = cmd_set_mirror_link_parsed,
+		.data = NULL,
+		.help_str = "set port X mirror-rule Y uplink-mirror|"
+			"downlink-mirror dst-pool Z on|off",
+		.tokens = {
+			(void *)&cmd_mirror_link_set,
+			(void *)&cmd_mirror_link_port,
+			(void *)&cmd_mirror_link_portid,
+			(void *)&cmd_mirror_link_mirror,
+			(void *)&cmd_mirror_link_ruleid,
+			(void *)&cmd_mirror_link_what,
+			(void *)&cmd_mirror_link_dstpool,
+			(void *)&cmd_mirror_link_poolid,
+			(void *)&cmd_mirror_link_on,
+			NULL,
+		},
+};
+
+/* *** RESET VM MIRROR RULE *** */
+struct cmd_rm_mirror_rule_result {
+	cmdline_fixed_string_t reset;
+	cmdline_fixed_string_t port;
+	uint8_t port_id;
+	cmdline_fixed_string_t mirror;
+	uint8_t rule_id;
+};
+
+cmdline_parse_token_string_t cmd_rm_mirror_rule_reset =
+	TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result,
+				 reset, "reset");
+cmdline_parse_token_string_t cmd_rm_mirror_rule_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result,
+				port, "port");
+cmdline_parse_token_string_t cmd_rm_mirror_rule_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
+				port_id, UINT8);
+cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror =
+	TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result,
+				mirror, "mirror-rule");
+cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid =
+	TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
+				rule_id, UINT8);
+
+static void
+cmd_reset_mirror_rule_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	int ret;
+	struct cmd_set_mirror_link_result *res = parsed_result;
+        /* check rule_id */
+	ret = rte_eth_mirror_rule_reset(res->port_id,res->rule_id);
+	if(ret < 0)
+		printf("mirror rule remove error: (%s)\n", strerror(-ret));
+}
+
+cmdline_parse_inst_t cmd_reset_mirror_rule = {
+		.f = cmd_reset_mirror_rule_parsed,
+		.data = NULL,
+		.help_str = "reset port X mirror-rule Y",
+		.tokens = {
+			(void *)&cmd_rm_mirror_rule_reset,
+			(void *)&cmd_rm_mirror_rule_port,
+			(void *)&cmd_rm_mirror_rule_portid,
+			(void *)&cmd_rm_mirror_rule_mirror,
+			(void *)&cmd_rm_mirror_rule_ruleid,
+			NULL,
+		},
+};
+
 /* ******************************************************************************** */
 
 /* list of instructions */
@@ -3833,6 +4952,13 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(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,
+#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
 	(cmdline_parse_inst_t *)&cmd_vlan_offload,
 	(cmdline_parse_inst_t *)&cmd_vlan_tpid,
 	(cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all,
@@ -3874,6 +5000,15 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_config_burst,
 	(cmdline_parse_inst_t *)&cmd_config_thresh,
 	(cmdline_parse_inst_t *)&cmd_config_threshold,
+	(cmdline_parse_inst_t *)&cmd_set_vf_rxmode,
+	(cmdline_parse_inst_t *)&cmd_set_uc_hash_filter,
+	(cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter,
+	(cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter ,
+	(cmdline_parse_inst_t *)&cmd_set_vf_traffic,
+	(cmdline_parse_inst_t *)&cmd_vf_rxvlan_filter,
+	(cmdline_parse_inst_t *)&cmd_set_mirror_mask,
+	(cmdline_parse_inst_t *)&cmd_set_mirror_link,
+	(cmdline_parse_inst_t *)&cmd_reset_mirror_rule,
 	NULL,
 };
 
@@ -3914,3 +5049,30 @@ 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)
+{
+	struct rte_port   *port;
+	struct rte_pci_id *pci_id;
+
+	if (port_id >= nb_ports) {
+		printf("\tPort id must be less than %d.\n", nb_ports);
+		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