X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=0be28f6c1dc5e93abf2833c4fb37101855cd0f14;hb=88523f27e8448fc45c531e58a53af49cce39e891;hp=8c571c07a611474254927eeb9af17c2c8bfcb6df;hpb=7741e4cf16c0548e15d07b847fd96691b44efb29;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 8c571c07a6..0be28f6c1d 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -1,7 +1,8 @@ /*- * BSD LICENSE * - * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. + * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * Copyright(c) 2014 6WIND S.A. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -41,7 +42,11 @@ #include #include #ifndef __linux__ +#ifndef __FreeBSD__ #include +#else +#include +#endif #endif #include @@ -68,6 +73,7 @@ #include #include #include +#include #include #include @@ -77,11 +83,16 @@ #include #include #include +#include #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; @@ -171,6 +182,10 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (info|stats|fdir|stat_qmap) (port_id|all)\n" " Display information for port_id, or all.\n\n" + "show port rss-hash [key]\n" + " Display the RSS hash functions and RSS hash key" + " of port X\n\n" + "clear port (info|stats|fdir|stat_qmap) (port_id|all)\n" " Clear information for port_id, or all.\n\n" @@ -215,6 +230,10 @@ static void cmd_help_long_parsed(void *parsed_result, "set burst (num)\n" " Set number of packets per burst.\n\n" + "set burst tx delay (microseconds) retry (num)\n" + " Set the transmit delay time and number of retries" + " in mac_retry forwarding mode.\n\n" + "set txpkts (x[,y]*)\n" " Set the length of each segment of TXONLY" " packets.\n\n" @@ -228,6 +247,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" @@ -276,17 +298,9 @@ static void cmd_help_long_parsed(void *parsed_result, " bit 3 - insert sctp checksum offload if set\n" " Please check the NIC datasheet for HW limits.\n\n" -#ifdef RTE_LIBRTE_IEEE1588 - "set fwd (io|mac|rxonly|txonly|csum|ieee1588)\n" - " Set IO, MAC, RXONLY, CSUM or TXONLY or ieee1588" - " packet forwarding mode.\n\n" + "set fwd (%s)\n" + " Set packet forwarding mode.\n\n" -#else - "set fwd (io|mac|rxonly|txonly|csum)\n" - " Set IO, MAC, RXONLY, CSUM or TXONLY packet" - " forwarding mode.\n\n" - -#endif "mac_addr add (port_id) (XX:XX:XX:XX:XX:XX)\n" " Add a MAC address on port_id.\n\n" @@ -307,7 +321,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)" @@ -341,8 +356,8 @@ static void cmd_help_long_parsed(void *parsed_result, " to pool 0.\n\n" "set port (port_id) mirror-rule (rule_id)" - "(uplink-mirror|downlink-mirror) dst-pool" - "(pool_id) (on|off)\n" + " (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" @@ -350,7 +365,36 @@ static void cmd_help_long_parsed(void *parsed_result, "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 + + , list_pkt_forwarding_modes() ); } @@ -1084,26 +1128,22 @@ cmd_config_rss_parsed(void *parsed_result, __attribute__((unused)) void *data) { struct cmd_config_rss *res = parsed_result; - - if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); - return; - } + struct rte_eth_rss_conf rss_conf; + uint8_t i; if (!strcmp(res->value, "ip")) - rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6; + rss_conf.rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6; else if (!strcmp(res->value, "udp")) - rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6 | ETH_RSS_IPV4_UDP; + rss_conf.rss_hf = ETH_RSS_IPV4_UDP | ETH_RSS_IPV6_UDP; else if (!strcmp(res->value, "none")) - rss_hf = 0; + rss_conf.rss_hf = 0; else { printf("Unknown parameter\n"); return; } - - init_port_config(); - - cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); + rss_conf.rss_key = NULL; + for (i = 0; i < rte_eth_dev_count(); i++) + rte_eth_dev_rss_hash_update(i, &rss_conf); } cmdline_parse_token_string_t cmd_config_rss_port = @@ -1131,6 +1171,99 @@ cmdline_parse_inst_t cmd_config_rss = { }, }; +/* *** configure rss hash key *** */ +struct cmd_config_rss_hash_key { + cmdline_fixed_string_t port; + cmdline_fixed_string_t config; + uint8_t port_id; + cmdline_fixed_string_t rss_hash_key; + cmdline_fixed_string_t key; +}; + +#define RSS_HASH_KEY_LENGTH 40 +static uint8_t +hexa_digit_to_value(char hexa_digit) +{ + if ((hexa_digit >= '0') && (hexa_digit <= '9')) + return (uint8_t) (hexa_digit - '0'); + if ((hexa_digit >= 'a') && (hexa_digit <= 'f')) + return (uint8_t) ((hexa_digit - 'a') + 10); + if ((hexa_digit >= 'A') && (hexa_digit <= 'F')) + return (uint8_t) ((hexa_digit - 'A') + 10); + /* Invalid hexa digit */ + return 0xFF; +} + +static uint8_t +parse_and_check_key_hexa_digit(char *key, int idx) +{ + uint8_t hexa_v; + + hexa_v = hexa_digit_to_value(key[idx]); + if (hexa_v == 0xFF) + printf("invalid key: character %c at position %d is not a " + "valid hexa digit\n", key[idx], idx); + return hexa_v; +} + +static void +cmd_config_rss_hash_key_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_rss_hash_key *res = parsed_result; + uint8_t hash_key[RSS_HASH_KEY_LENGTH]; + uint8_t xdgt0; + uint8_t xdgt1; + int i; + + /* Check the length of the RSS hash key */ + if (strlen(res->key) != (RSS_HASH_KEY_LENGTH * 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); + return; + } + /* Translate RSS hash key into binary representation */ + for (i = 0; i < RSS_HASH_KEY_LENGTH; i++) { + xdgt0 = parse_and_check_key_hexa_digit(res->key, (i * 2)); + if (xdgt0 == 0xFF) + return; + xdgt1 = parse_and_check_key_hexa_digit(res->key, (i * 2) + 1); + if (xdgt1 == 0xFF) + return; + hash_key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1); + } + port_rss_hash_key_update(res->port_id, hash_key); +} + +cmdline_parse_token_string_t cmd_config_rss_hash_key_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, port, "port"); +cmdline_parse_token_string_t cmd_config_rss_hash_key_config = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, config, + "config"); +cmdline_parse_token_string_t cmd_config_rss_hash_key_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id, UINT8); +cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, + rss_hash_key, "rss-hash-key"); +cmdline_parse_token_string_t cmd_config_rss_hash_key_value = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL); + +cmdline_parse_inst_t cmd_config_rss_hash_key = { + .f = cmd_config_rss_hash_key_parsed, + .data = NULL, + .help_str = "port config X rss-hash-key 80 hexa digits", + .tokens = { + (void *)&cmd_config_rss_hash_key_port, + (void *)&cmd_config_rss_hash_key_config, + (void *)&cmd_config_rss_hash_key_port_id, + (void *)&cmd_config_rss_hash_key_rss_hash_key, + (void *)&cmd_config_rss_hash_key_value, + NULL, + }, +}; + /* *** Configure RSS RETA *** */ struct cmd_config_rss_reta { cmdline_fixed_string_t port; @@ -1246,7 +1379,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; @@ -1307,6 +1440,63 @@ cmdline_parse_inst_t cmd_showport_reta = { }, }; +/* *** Show RSS hash configuration *** */ +struct cmd_showport_rss_hash { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t rss_hash; + cmdline_fixed_string_t key; /* optional argument */ +}; + +static void cmd_showport_rss_hash_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + void *show_rss_key) +{ + struct cmd_showport_rss_hash *res = parsed_result; + + port_rss_hash_conf_show(res->port_id, show_rss_key != NULL); +} + +cmdline_parse_token_string_t cmd_showport_rss_hash_show = + TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, show, "show"); +cmdline_parse_token_string_t cmd_showport_rss_hash_port = + TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, port, "port"); +cmdline_parse_token_num_t cmd_showport_rss_hash_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id, UINT8); +cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash = + TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash, + "rss-hash"); +cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key = + TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key"); + +cmdline_parse_inst_t cmd_showport_rss_hash = { + .f = cmd_showport_rss_hash_parsed, + .data = NULL, + .help_str = "show port X rss-hash (X = port number)\n", + .tokens = { + (void *)&cmd_showport_rss_hash_show, + (void *)&cmd_showport_rss_hash_port, + (void *)&cmd_showport_rss_hash_port_id, + (void *)&cmd_showport_rss_hash_rss_hash, + NULL, + }, +}; + +cmdline_parse_inst_t cmd_showport_rss_hash_key = { + .f = cmd_showport_rss_hash_parsed, + .data = (void *)1, + .help_str = "show port X rss-hash key (X = port number)\n", + .tokens = { + (void *)&cmd_showport_rss_hash_show, + (void *)&cmd_showport_rss_hash_port, + (void *)&cmd_showport_rss_hash_port_id, + (void *)&cmd_showport_rss_hash_rss_hash, + (void *)&cmd_showport_rss_hash_rss_key, + NULL, + }, +}; + /* *** Configure DCB *** */ struct cmd_config_dcb { cmdline_fixed_string_t port; @@ -1970,8 +2160,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) @@ -2286,6 +2478,377 @@ cmdline_parse_inst_t cmd_set_flush_rx = { }, }; +/* *** ENABLE/DISABLE LINK STATUS CHECK *** */ +struct cmd_set_link_check { + cmdline_fixed_string_t set; + cmdline_fixed_string_t link_check; + cmdline_fixed_string_t mode; +}; + +static void +cmd_set_link_check_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_set_link_check *res = parsed_result; + no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); +} + +cmdline_parse_token_string_t cmd_setlinkcheck_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, + set, "set"); +cmdline_parse_token_string_t cmd_setlinkcheck_link_check = + TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, + link_check, "link_check"); +cmdline_parse_token_string_t cmd_setlinkcheck_mode = + TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, + mode, "on#off"); + + +cmdline_parse_inst_t cmd_set_link_check = { + .f = cmd_set_link_check_parsed, + .help_str = "set link_check on|off: enable/disable link status check " + "when starting/stopping a port", + .data = NULL, + .tokens = { + (void *)&cmd_setlinkcheck_set, + (void *)&cmd_setlinkcheck_link_check, + (void *)&cmd_setlinkcheck_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; @@ -2308,22 +2871,12 @@ cmdline_parse_token_string_t cmd_setfwd_fwd = TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, fwd, "fwd"); cmdline_parse_token_string_t cmd_setfwd_mode = TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode, -#ifdef RTE_LIBRTE_IEEE1588 - "io#mac#rxonly#txonly#csum#ieee1588"); -#else - "io#mac#rxonly#txonly#csum"); -#endif + "" /* defined at init */); cmdline_parse_inst_t cmd_set_fwd_mode = { .f = cmd_set_fwd_mode_parsed, .data = NULL, -#ifdef RTE_LIBRTE_IEEE1588 - .help_str = "set fwd io|mac|rxonly|txonly|csum|ieee1588 - set IO, MAC," - " RXONLY, TXONLY, CSUM or IEEE1588 packet forwarding mode", -#else - .help_str = "set fwd io|mac|rxonly|txonly|csum - set IO, MAC," - " RXONLY, CSUM or TXONLY packet forwarding mode", -#endif + .help_str = NULL, /* defined at init */ .tokens = { (void *)&cmd_setfwd_set, (void *)&cmd_setfwd_fwd, @@ -2332,6 +2885,86 @@ cmdline_parse_inst_t cmd_set_fwd_mode = { }, }; +static void cmd_set_fwd_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_modes(); + rte_snprintf(help, sizeof help, "set fwd %s - " + "set packet forwarding mode", modes); + cmd_set_fwd_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_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; + cmdline_fixed_string_t burst; + cmdline_fixed_string_t tx; + cmdline_fixed_string_t delay; + uint32_t time; + cmdline_fixed_string_t retry; + uint32_t retry_num; +}; + +static void cmd_set_burst_tx_retry_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_set_burst_tx_retry_result *res = parsed_result; + + if (!strcmp(res->set, "set") && !strcmp(res->burst, "burst") + && !strcmp(res->tx, "tx")) { + if (!strcmp(res->delay, "delay")) + burst_tx_delay_time = res->time; + if (!strcmp(res->retry, "retry")) + burst_tx_retry_num = res->retry_num; + } + +} + +cmdline_parse_token_string_t cmd_set_burst_tx_retry_set = + TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, set, "set"); +cmdline_parse_token_string_t cmd_set_burst_tx_retry_burst = + TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, burst, + "burst"); +cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx = + TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, tx, "tx"); +cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay = + TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, delay, "delay"); +cmdline_parse_token_num_t cmd_set_burst_tx_retry_time = + TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time, UINT32); +cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry = + TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry, "retry"); +cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num = + TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num, UINT32); + +cmdline_parse_inst_t cmd_set_burst_tx_retry = { + .f = cmd_set_burst_tx_retry_parsed, + .help_str = "set burst tx delay (time_by_useconds) retry (retry_num)", + .tokens = { + (void *)&cmd_set_burst_tx_retry_set, + (void *)&cmd_set_burst_tx_retry_burst, + (void *)&cmd_set_burst_tx_retry_tx, + (void *)&cmd_set_burst_tx_retry_delay, + (void *)&cmd_set_burst_tx_retry_time, + (void *)&cmd_set_burst_tx_retry_retry, + (void *)&cmd_set_burst_tx_retry_retry_num, + NULL, + }, +}; + /* *** SET PROMISC MODE *** */ struct cmd_set_promisc_mode_result { cmdline_fixed_string_t set; @@ -2997,6 +3630,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; @@ -3011,7 +3646,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; /* @@ -3021,17 +3656,19 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. */ static enum rte_eth_fc_mode rx_tx_onoff_2_lfc_mode[2][2] = { - {RTE_FC_NONE, RTE_FC_RX_PAUSE}, {RTE_FC_TX_PAUSE, RTE_FC_FULL} + {RTE_FC_NONE, RTE_FC_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} }; 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) @@ -3068,6 +3705,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); @@ -3075,7 +3718,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, @@ -3087,6 +3732,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, }, @@ -4548,6 +5195,115 @@ cmdline_parse_inst_t cmd_reset_mirror_rule = { /* ******************************************************************************** */ +struct cmd_dump_result { + cmdline_fixed_string_t dump; +}; + +static void +dump_struct_sizes(void) +{ +#define DUMP_SIZE(t) printf("sizeof(" #t ") = %u\n", (unsigned)sizeof(t)); + DUMP_SIZE(struct rte_mbuf); + DUMP_SIZE(struct rte_pktmbuf); + DUMP_SIZE(struct rte_ctrlmbuf); + DUMP_SIZE(struct rte_mempool); + DUMP_SIZE(struct rte_ring); +#undef DUMP_SIZE +} + +static void cmd_dump_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_dump_result *res = parsed_result; + + if (!strcmp(res->dump, "dump_physmem")) + 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")) + rte_ring_list_dump(stdout); + else if (!strcmp(res->dump, "dump_mempool")) + rte_mempool_list_dump(stdout); + else if (!strcmp(res->dump, "dump_devargs")) + rte_eal_devargs_dump(stdout); +} + +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#" + "dump_devargs"); + +cmdline_parse_inst_t cmd_dump = { + .f = cmd_dump_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = "dump status", + .tokens = { /* token list, NULL terminated */ + (void *)&cmd_dump_dump, + NULL, + }, +}; + +/* ******************************************************************************** */ + +struct cmd_dump_one_result { + cmdline_fixed_string_t dump; + cmdline_fixed_string_t name; +}; + +static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_dump_one_result *res = parsed_result; + + if (!strcmp(res->dump, "dump_ring")) { + struct rte_ring *r; + r = rte_ring_lookup(res->name); + if (r == NULL) { + cmdline_printf(cl, "Cannot find ring\n"); + return; + } + rte_ring_dump(stdout, r); + } else if (!strcmp(res->dump, "dump_mempool")) { + struct rte_mempool *mp; + mp = rte_mempool_lookup(res->name); + if (mp == NULL) { + cmdline_printf(cl, "Cannot find mempool\n"); + return; + } + rte_mempool_dump(stdout, mp); + } +} + +cmdline_parse_token_string_t cmd_dump_one_dump = + TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, dump, + "dump_ring#dump_mempool"); + +cmdline_parse_token_string_t cmd_dump_one_name = + TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, name, NULL); + +cmdline_parse_inst_t cmd_dump_one = { + .f = cmd_dump_one_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = "dump one ring/mempool: dump_ring|dump_mempool ", + .tokens = { /* token list, NULL terminated */ + (void *)&cmd_dump_one_dump, + (void *)&cmd_dump_one_name, + NULL, + }, +}; + +/* ******************************************************************************** */ + /* list of instructions */ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_help_brief, @@ -4564,11 +5320,19 @@ cmdline_parse_ctx_t main_ctx[] = { (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 (cmdline_parse_inst_t *)&cmd_vlan_offload, (cmdline_parse_inst_t *)&cmd_vlan_tpid, (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all, @@ -4619,6 +5383,11 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_set_mirror_mask, (cmdline_parse_inst_t *)&cmd_set_mirror_link, (cmdline_parse_inst_t *)&cmd_reset_mirror_rule, + (cmdline_parse_inst_t *)&cmd_showport_rss_hash, + (cmdline_parse_inst_t *)&cmd_showport_rss_hash_key, + (cmdline_parse_inst_t *)&cmd_config_rss_hash_key, + (cmdline_parse_inst_t *)&cmd_dump, + (cmdline_parse_inst_t *)&cmd_dump_one, NULL, }; @@ -4628,6 +5397,9 @@ prompt(void) { struct cmdline *cl; + /* initialize non-constant commands */ + cmd_set_fwd_mode_init(); + cl = cmdline_stdin_new(main_ctx, "testpmd> "); if (cl == NULL) { return; @@ -4659,3 +5431,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