X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=d17b3645ad1c1295923fe11e9eebffaeb79b4af0;hb=1c1d4d7a923d4804f1926fc5264f9ecdd8977b04;hp=70718af6665c1b1d2e0f872c55ac939bad1b1f86;hpb=d59b178f125987b3c64ddcc4fe4fcdd90f8cdbdb;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 70718af666..d17b3645ad 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -1,246 +1,1546 @@ /*- * BSD LICENSE * - * Copyright(c) 2010-2012 Intel Corporation. All rights reserved. + * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. * All rights reserved. * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions * are met: * - * * Redistributions of source code must retain the above copyright + * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the * distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifndef __linux__ -#include -#endif -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef __linux__ +#include +#endif +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "testpmd.h" + +static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue); + +/* *** Help command with introduction. *** */ +struct cmd_help_brief_result { + cmdline_fixed_string_t help; +}; + +static void cmd_help_brief_parsed(__attribute__((unused)) void *parsed_result, + struct cmdline *cl, + __attribute__((unused)) void *data) +{ + cmdline_printf( + cl, + "\n" + "Help is available for the following sections:\n\n" + " help control : Start and stop forwarding.\n" + " help display : Displaying port, stats and config " + "information.\n" + " help config : Configuration information.\n" + " help ports : Configuring ports.\n" + " help flowdir : Flow Director filter help.\n" + " help registers : Reading and setting port registers.\n" + " help all : All of the above sections.\n\n" + ); + +} + +cmdline_parse_token_string_t cmd_help_brief_help = + TOKEN_STRING_INITIALIZER(struct cmd_help_brief_result, help, "help"); + +cmdline_parse_inst_t cmd_help_brief = { + .f = cmd_help_brief_parsed, + .data = NULL, + .help_str = "show help", + .tokens = { + (void *)&cmd_help_brief_help, + NULL, + }, +}; + +/* *** Help command with help sections. *** */ +struct cmd_help_long_result { + cmdline_fixed_string_t help; + cmdline_fixed_string_t section; +}; + +static void cmd_help_long_parsed(void *parsed_result, + struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int show_all = 0; + struct cmd_help_long_result *res = parsed_result; + + if (!strcmp(res->section, "all")) + show_all = 1; + + if (show_all || !strcmp(res->section, "control")) { + + cmdline_printf( + cl, + "\n" + "Control forwarding:\n" + "-------------------\n\n" + + "start\n" + " Start packet forwarding with current configuration.\n\n" + + "start tx_first\n" + " Start packet forwarding with current config" + " after sending one burst of packets.\n\n" + + "stop\n" + " Stop packet forwarding, and display accumulated" + " statistics.\n\n" + + "quit\n" + " Quit to prompt in Linux and reboot on Baremetal.\n\n" + ); + } + + if (show_all || !strcmp(res->section, "display")) { + + cmdline_printf( + cl, + "\n" + "Display:\n" + "--------\n\n" + + "show port (info|stats|fdir|stat_qmap) (port_id|all)\n" + " Display information for port_id, or all.\n\n" + + "clear port (info|stats|fdir|stat_qmap) (port_id|all)\n" + " Clear information for port_id, or all.\n\n" + + "show config (rxtx|cores|fwd)\n" + " Display the given configuration.\n\n" + + "read rxd (port_id) (queue_id) (rxd_id)\n" + " Display an RX descriptor of a port RX queue.\n\n" + + "read txd (port_id) (queue_id) (txd_id)\n" + " Display a TX descriptor of a port TX queue.\n\n" + ); + } + + if (show_all || !strcmp(res->section, "config")) { + cmdline_printf( + cl, + "\n" + "Configuration:\n" + "--------------\n" + "Configuration changes only become active when" + " forwarding is started/restarted.\n\n" + + "set default\n" + " Reset forwarding to the default configuration.\n\n" + + "set verbose (level)\n" + " Set the debug verbosity level X.\n\n" + + "set nbport (num)\n" + " Set number of ports.\n\n" + + "set nbcore (num)\n" + " Set number of cores.\n\n" + + "set coremask (mask)\n" + " Set the forwarding cores hexadecimal mask.\n\n" + + "set portmask (mask)\n" + " Set the forwarding ports hexadecimal mask.\n\n" + + "set burst (num)\n" + " Set number of packets per burst.\n\n" + + "set txpkts (x[,y]*)\n" + " Set the length of each segment of TXONLY" + " packets.\n\n" + + "set corelist (x[,y]*)\n" + " Set the list of forwarding cores.\n\n" + + "set portlist (x[,y]*)\n" + " Set the list of forwarding ports.\n\n" + + "vlan set strip (on|off) (port_id)\n" + " Set the VLAN strip on a port.\n\n" + + "vlan set filter (on|off) (port_id)\n" + " Set the VLAN filter on a port.\n\n" + + "vlan set qinq (on|off) (port_id)\n" + " Set the VLAN QinQ (extended queue in queue)" + " on a port.\n\n" + + "vlan set tpid (value) (port_id)\n" + " Set the outer VLAN TPID for Packet Filtering on" + " a port\n\n" + + "rx_vlan add (vlan_id|all) (port_id)\n" + " Add a vlan_id, or all identifiers, to the set" + " of VLAN identifiers filtered by port_id.\n\n" + + "rx_vlan rm (vlan_id|all) (port_id)\n" + " Remove a vlan_id, or all identifiers, from the set" + " of VLAN identifiers filtered by port_id.\n\n" + + "tx_vlan set vlan_id (port_id)\n" + " Set hardware insertion of VLAN ID in packets sent" + " on a port.\n\n" + + "tx_vlan reset (port_id)\n" + " Disable hardware insertion of a VLAN header in" + " packets sent on a port.\n\n" + + "tx_checksum set mask (port_id)\n" + " Enable hardware insertion of checksum offload with" + " the 4-bit mask, 0~0xf, in packets sent on a port.\n" + " bit 0 - insert ip checksum offload if set\n" + " bit 1 - insert udp checksum offload if set\n" + " bit 2 - insert tcp checksum offload if set\n" + " 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" + +#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" + + "mac_addr remove (port_id) (XX:XX:XX:XX:XX:XX)\n" + " Remove a MAC address from port_id.\n\n" + + "set promisc (port_id|all) (on|off)\n" + " Set the promiscuous mode on port_id, or all.\n\n" + + "set allmulti (port_id|all) (on|off)\n" + " Set the allmulti mode on port_id, or all.\n\n" + + "set flow_ctrl rx (on|off) tx (on|off) (high_water)" + " (low_water) (pause_time) (send_xon) (port_id)\n" + " Set the link flow control parameter on a port.\n\n" + + "set pfc_ctrl rx (on|off) tx (on|off) (high_water)" + " (low_water) (pause_time) (priority) (port_id)\n" + " Set the priority flow control parameter on a" + " port.\n\n" + + "set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n" + " Set statistics mapping (qmapping 0..15) for RX/TX" + " queue on port.\n" + " e.g., 'set stat_qmap rx 0 2 5' sets rx queue 2" + " on port 0 to mapping 5.\n\n" + ); + } + + + if (show_all || !strcmp(res->section, "flowdir")) { + + cmdline_printf( + cl, + "\n" + "Flow director mode:\n" + "-------------------\n\n" + + "add_signature_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)" + " queue (queue_id)\n" + " Add a signature filter.\n\n" + + "upd_signature_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)" + " queue (queue_id)\n" + " Update a signature filter.\n\n" + + "rm_signature_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)\n" + " Remove a signature filter.\n\n" + + "add_perfect_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)" + " queue (queue_id) soft (soft_id)\n" + " Add a perfect filter.\n\n" + + "upd_perfect_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)" + " queue (queue_id)\n" + " Update a perfect filter.\n\n" + + "rm_perfect_filter (port_id) (ip|udp|tcp|sctp)" + " src (src_ip_address) (src_port)" + " dst (dst_ip_address) (dst_port)" + " flexbytes (flexbytes_values) vlan (vlan_id)" + " soft (soft_id)\n" + " Remove a perfect filter.\n\n" + + "set_masks_filter (port_id) only_ip_flow (0|1)" + " src_mask (ip_src_mask) (src_port_mask)" + " dst_mask (ip_dst_mask) (dst_port_mask)" + " flexbytes (0|1) vlan_id (0|1) vlan_prio (0|1)\n" + " Set IPv4 filter masks.\n\n" + + "set_ipv6_masks_filter (port_id) only_ip_flow (0|1)" + " src_mask (ip_src_mask) (src_port_mask)" + " dst_mask (ip_dst_mask) (dst_port_mask)" + " flexbytes (0|1) vlan_id (0|1) vlan_prio (0|1)" + " compare_dst (0|1)\n" + " Set IPv6 filter masks.\n\n" + ); + } + + if (show_all || !strcmp(res->section, "ports")) { + + cmdline_printf( + cl, + "\n" + "Port Operations:\n" + "----------------\n\n" + + "port start (port_id|all)\n" + " Start all ports or port_id.\n\n" + + "port stop (port_id|all)\n" + " Stop all ports or port_id.\n\n" + + "port close (port_id|all)\n" + " Close all ports or port_id.\n\n" + + "port config (port_id|all) speed (10|100|1000|10000|auto)" + " duplex (half|full|auto)\n" + " Set speed and duplex for all ports or port_id\n\n" + + "port config all (rxq|txq|rxd|txd) (value)\n" + " Set number for rxq/txq/rxd/txd.\n\n" + + "port config all max-pkt-len (value)\n" + " Set the max packet length.\n\n" + + "port config all (crc-strip|rx-cksum|hw-vlan|drop-en)" + " (on|off)\n" + " Set crc-strip/rx-checksum/hardware-vlan/drop_en" + " for ports.\n\n" + + "port config all rss (ip|udp|none)\n" + " Set the RSS mode.\n\n" + + "port config port-id rss reta (hash,queue)[,(hash,queue)]\n" + " Set the RSS redirection table.\n\n" + + "port config (port_id) dcb vt (on|off) (traffic_class)" + " pfc (on|off)\n" + " Set the DCB mode.\n\n" + + "port config all burst (value)\n" + " Set the number of packets per burst.\n\n" + + "port config all (txpt|txht|txwt|rxpt|rxht|rxwt)" + " (value)\n" + " Set the ring prefetch/host/writeback threshold" + " for tx/rx queue.\n\n" + + "port config all (txfreet|txrst|rxfreet) (value)\n" + " Set free threshold for rx/tx, or set" + " tx rs bit threshold.\n\n" + ); + } + + if (show_all || !strcmp(res->section, "registers")) { + + cmdline_printf( + cl, + "\n" + "Registers:\n" + "----------\n\n" + + "read reg (port_id) (address)\n" + " Display value of a port register.\n\n" + + "read regfield (port_id) (address) (bit_x) (bit_y)\n" + " Display a port register bit field.\n\n" + + "read regbit (port_id) (address) (bit_x)\n" + " Display a single port register bit.\n\n" + + "write reg (port_id) (address) (value)\n" + " Set value of a port register.\n\n" + + "write regfield (port_id) (address) (bit_x) (bit_y)" + " (value)\n" + " Set bit field of a port register.\n\n" + + "write regbit (port_id) (address) (bit_x) (value)\n" + " Set single bit value of a port register.\n\n" + ); + } +} + +cmdline_parse_token_string_t cmd_help_long_help = + TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, help, "help"); + +cmdline_parse_token_string_t cmd_help_long_section = + TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, section, + "all#control#display#config#flowdir#" + "ports#registers"); + +cmdline_parse_inst_t cmd_help_long = { + .f = cmd_help_long_parsed, + .data = NULL, + .help_str = "show help", + .tokens = { + (void *)&cmd_help_long_help, + (void *)&cmd_help_long_section, + NULL, + }, +}; + + +/* *** start/stop/close all ports *** */ +struct cmd_operate_port_result { + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + cmdline_fixed_string_t value; +}; + +static void cmd_operate_port_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_operate_port_result *res = parsed_result; + + if (!strcmp(res->name, "start")) + start_port(RTE_PORT_ALL); + else if (!strcmp(res->name, "stop")) + stop_port(RTE_PORT_ALL); + else if (!strcmp(res->name, "close")) + close_port(RTE_PORT_ALL); + else + printf("Unknown parameter\n"); +} + +cmdline_parse_token_string_t cmd_operate_port_all_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, keyword, + "port"); +cmdline_parse_token_string_t cmd_operate_port_all_port = + TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, name, + "start#stop#close"); +cmdline_parse_token_string_t cmd_operate_port_all_all = + TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, value, "all"); + +cmdline_parse_inst_t cmd_operate_port = { + .f = cmd_operate_port_parsed, + .data = NULL, + .help_str = "port start|stop|close all: start/stop/close all ports", + .tokens = { + (void *)&cmd_operate_port_all_cmd, + (void *)&cmd_operate_port_all_port, + (void *)&cmd_operate_port_all_all, + NULL, + }, +}; + +/* *** start/stop/close specific port *** */ +struct cmd_operate_specific_port_result { + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + uint8_t value; +}; + +static void cmd_operate_specific_port_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_operate_specific_port_result *res = parsed_result; + + if (!strcmp(res->name, "start")) + start_port(res->value); + else if (!strcmp(res->name, "stop")) + stop_port(res->value); + else if (!strcmp(res->name, "close")) + close_port(res->value); + else + printf("Unknown parameter\n"); +} + +cmdline_parse_token_string_t cmd_operate_specific_port_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result, + keyword, "port"); +cmdline_parse_token_string_t cmd_operate_specific_port_port = + TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result, + name, "start#stop#close"); +cmdline_parse_token_num_t cmd_operate_specific_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result, + value, UINT8); + +cmdline_parse_inst_t cmd_operate_specific_port = { + .f = cmd_operate_specific_port_parsed, + .data = NULL, + .help_str = "port start|stop|close X: start/stop/close port X", + .tokens = { + (void *)&cmd_operate_specific_port_cmd, + (void *)&cmd_operate_specific_port_port, + (void *)&cmd_operate_specific_port_id, + NULL, + }, +}; + +/* *** configure speed for all ports *** */ +struct cmd_config_speed_all { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t item1; + cmdline_fixed_string_t item2; + cmdline_fixed_string_t value1; + cmdline_fixed_string_t value2; +}; + +static void +cmd_config_speed_all_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __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; + portid_t pid; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->value1, "10")) + link_speed = ETH_LINK_SPEED_10; + else if (!strcmp(res->value1, "100")) + link_speed = ETH_LINK_SPEED_100; + else if (!strcmp(res->value1, "1000")) + link_speed = ETH_LINK_SPEED_1000; + else if (!strcmp(res->value1, "10000")) + link_speed = ETH_LINK_SPEED_10000; + else if (!strcmp(res->value1, "auto")) + link_speed = ETH_LINK_SPEED_AUTONEG; + else { + printf("Unknown parameter\n"); + return; + } + + if (!strcmp(res->value2, "half")) + link_duplex = ETH_LINK_HALF_DUPLEX; + else if (!strcmp(res->value2, "full")) + link_duplex = ETH_LINK_FULL_DUPLEX; + else if (!strcmp(res->value2, "auto")) + link_duplex = ETH_LINK_AUTONEG_DUPLEX; + else { + printf("Unknown parameter\n"); + return; + } + + for (pid = 0; pid < nb_ports; pid++) { + ports[pid].dev_conf.link_speed = link_speed; + ports[pid].dev_conf.link_duplex = link_duplex; + } + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_speed_all_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, port, "port"); +cmdline_parse_token_string_t cmd_config_speed_all_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, keyword, + "config"); +cmdline_parse_token_string_t cmd_config_speed_all_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, all, "all"); +cmdline_parse_token_string_t cmd_config_speed_all_item1 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item1, "speed"); +cmdline_parse_token_string_t cmd_config_speed_all_value1 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value1, + "10#100#1000#10000#auto"); +cmdline_parse_token_string_t cmd_config_speed_all_item2 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item2, "duplex"); +cmdline_parse_token_string_t cmd_config_speed_all_value2 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value2, + "half#full#auto"); + +cmdline_parse_inst_t cmd_config_speed_all = { + .f = cmd_config_speed_all_parsed, + .data = NULL, + .help_str = "port config all speed 10|100|1000|10000|auto duplex " + "half|full|auto", + .tokens = { + (void *)&cmd_config_speed_all_port, + (void *)&cmd_config_speed_all_keyword, + (void *)&cmd_config_speed_all_all, + (void *)&cmd_config_speed_all_item1, + (void *)&cmd_config_speed_all_value1, + (void *)&cmd_config_speed_all_item2, + (void *)&cmd_config_speed_all_value2, + NULL, + }, +}; + +/* *** configure speed for specific port *** */ +struct cmd_config_speed_specific { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + uint8_t id; + cmdline_fixed_string_t item1; + cmdline_fixed_string_t item2; + cmdline_fixed_string_t value1; + cmdline_fixed_string_t value2; +}; + +static void +cmd_config_speed_specific_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __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; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (res->id >= nb_ports) { + printf("Port id %d must be less than %d\n", res->id, nb_ports); + return; + } + + if (!strcmp(res->value1, "10")) + link_speed = ETH_LINK_SPEED_10; + else if (!strcmp(res->value1, "100")) + link_speed = ETH_LINK_SPEED_100; + else if (!strcmp(res->value1, "1000")) + link_speed = ETH_LINK_SPEED_1000; + else if (!strcmp(res->value1, "10000")) + link_speed = ETH_LINK_SPEED_10000; + else if (!strcmp(res->value1, "auto")) + link_speed = ETH_LINK_SPEED_AUTONEG; + else { + printf("Unknown parameter\n"); + return; + } + + if (!strcmp(res->value2, "half")) + link_duplex = ETH_LINK_HALF_DUPLEX; + else if (!strcmp(res->value2, "full")) + link_duplex = ETH_LINK_FULL_DUPLEX; + else if (!strcmp(res->value2, "auto")) + link_duplex = ETH_LINK_AUTONEG_DUPLEX; + else { + printf("Unknown parameter\n"); + return; + } + + ports[res->id].dev_conf.link_speed = link_speed; + ports[res->id].dev_conf.link_duplex = link_duplex; + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + + +cmdline_parse_token_string_t cmd_config_speed_specific_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, port, + "port"); +cmdline_parse_token_string_t cmd_config_speed_specific_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword, + "config"); +cmdline_parse_token_num_t cmd_config_speed_specific_id = + TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, UINT8); +cmdline_parse_token_string_t cmd_config_speed_specific_item1 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1, + "speed"); +cmdline_parse_token_string_t cmd_config_speed_specific_value1 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value1, + "10#100#1000#10000#auto"); +cmdline_parse_token_string_t cmd_config_speed_specific_item2 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2, + "duplex"); +cmdline_parse_token_string_t cmd_config_speed_specific_value2 = + TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value2, + "half#full#auto"); + +cmdline_parse_inst_t cmd_config_speed_specific = { + .f = cmd_config_speed_specific_parsed, + .data = NULL, + .help_str = "port config X speed 10|100|1000|10000|auto duplex " + "half|full|auto", + .tokens = { + (void *)&cmd_config_speed_specific_port, + (void *)&cmd_config_speed_specific_keyword, + (void *)&cmd_config_speed_specific_id, + (void *)&cmd_config_speed_specific_item1, + (void *)&cmd_config_speed_specific_value1, + (void *)&cmd_config_speed_specific_item2, + (void *)&cmd_config_speed_specific_value2, + NULL, + }, +}; + +/* *** configure txq/rxq, txd/rxd *** */ +struct cmd_config_rx_tx { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + uint16_t value; +}; + +static void +cmd_config_rx_tx_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_rx_tx *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "rxq")) { + if (res->value <= 0) { + printf("rxq %d invalid - must be > 0\n", res->value); + return; + } + nb_rxq = res->value; + } + else if (!strcmp(res->name, "txq")) { + if (res->value <= 0) { + printf("txq %d invalid - must be > 0\n", res->value); + return; + } + nb_txq = res->value; + } + else if (!strcmp(res->name, "rxd")) { + if (res->value <= 0 || res->value > RTE_TEST_RX_DESC_MAX) { + printf("rxd %d invalid - must be > 0 && <= %d\n", + res->value, RTE_TEST_RX_DESC_MAX); + return; + } + nb_rxd = res->value; + } else if (!strcmp(res->name, "txd")) { + if (res->value <= 0 || res->value > RTE_TEST_TX_DESC_MAX) { + printf("txd %d invalid - must be > 0 && <= %d\n", + res->value, RTE_TEST_TX_DESC_MAX); + return; + } + nb_txd = res->value; + } else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_rx_tx_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, port, "port"); +cmdline_parse_token_string_t cmd_config_rx_tx_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, keyword, "config"); +cmdline_parse_token_string_t cmd_config_rx_tx_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, all, "all"); +cmdline_parse_token_string_t cmd_config_rx_tx_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name, + "rxq#txq#rxd#txd"); +cmdline_parse_token_num_t cmd_config_rx_tx_value = + TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, UINT16); + +cmdline_parse_inst_t cmd_config_rx_tx = { + .f = cmd_config_rx_tx_parsed, + .data = NULL, + .help_str = "port config all rxq|txq|rxd|txd value", + .tokens = { + (void *)&cmd_config_rx_tx_port, + (void *)&cmd_config_rx_tx_keyword, + (void *)&cmd_config_rx_tx_all, + (void *)&cmd_config_rx_tx_name, + (void *)&cmd_config_rx_tx_value, + NULL, + }, +}; + +/* *** config max packet length *** */ +struct cmd_config_max_pkt_len_result { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + uint32_t value; +}; + +static void +cmd_config_max_pkt_len_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_max_pkt_len_result *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "max-pkt-len")) { + if (res->value < ETHER_MIN_LEN) { + printf("max-pkt-len can not be less than %d\n", + ETHER_MIN_LEN); + return; + } + if (res->value == rx_mode.max_rx_pkt_len) + return; + + rx_mode.max_rx_pkt_len = res->value; + if (res->value > ETHER_MAX_LEN) + rx_mode.jumbo_frame = 1; + else + rx_mode.jumbo_frame = 0; + } else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_max_pkt_len_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, port, + "port"); +cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, keyword, + "config"); +cmdline_parse_token_string_t cmd_config_max_pkt_len_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, all, + "all"); +cmdline_parse_token_string_t cmd_config_max_pkt_len_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, name, + "max-pkt-len"); +cmdline_parse_token_num_t cmd_config_max_pkt_len_value = + TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value, + UINT32); + +cmdline_parse_inst_t cmd_config_max_pkt_len = { + .f = cmd_config_max_pkt_len_parsed, + .data = NULL, + .help_str = "port config all max-pkt-len value", + .tokens = { + (void *)&cmd_config_max_pkt_len_port, + (void *)&cmd_config_max_pkt_len_keyword, + (void *)&cmd_config_max_pkt_len_all, + (void *)&cmd_config_max_pkt_len_name, + (void *)&cmd_config_max_pkt_len_value, + NULL, + }, +}; + +/* *** configure rx mode *** */ +struct cmd_config_rx_mode_flag { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + cmdline_fixed_string_t value; +}; + +static void +cmd_config_rx_mode_flag_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_rx_mode_flag *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "crc-strip")) { + if (!strcmp(res->value, "on")) + rx_mode.hw_strip_crc = 1; + else if (!strcmp(res->value, "off")) + rx_mode.hw_strip_crc = 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; + else if (!strcmp(res->value, "off")) + rx_mode.hw_ip_checksum = 0; + else { + printf("Unknown parameter\n"); + return; + } + } else if (!strcmp(res->name, "hw-vlan")) { + if (!strcmp(res->value, "on")) { + rx_mode.hw_vlan_filter = 1; + rx_mode.hw_vlan_strip = 1; + } + else if (!strcmp(res->value, "off")) { + rx_mode.hw_vlan_filter = 0; + rx_mode.hw_vlan_strip = 0; + } + else { + printf("Unknown parameter\n"); + return; + } + } else if (!strcmp(res->name, "drop-en")) { + if (!strcmp(res->value, "on")) + rx_drop_en = 1; + else if (!strcmp(res->value, "off")) + rx_drop_en = 0; + else { + printf("Unknown parameter\n"); + return; + } + } else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_rx_mode_flag_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, port, "port"); +cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, keyword, + "config"); +cmdline_parse_token_string_t cmd_config_rx_mode_flag_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all"); +cmdline_parse_token_string_t cmd_config_rx_mode_flag_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name, + "crc-strip#rx-cksum#hw-vlan"); +cmdline_parse_token_string_t cmd_config_rx_mode_flag_value = + TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value, + "on#off"); + +cmdline_parse_inst_t cmd_config_rx_mode_flag = { + .f = cmd_config_rx_mode_flag_parsed, + .data = NULL, + .help_str = "port config all crc-strip|rx-cksum|hw-vlan on|off", + .tokens = { + (void *)&cmd_config_rx_mode_flag_port, + (void *)&cmd_config_rx_mode_flag_keyword, + (void *)&cmd_config_rx_mode_flag_all, + (void *)&cmd_config_rx_mode_flag_name, + (void *)&cmd_config_rx_mode_flag_value, + NULL, + }, +}; + +/* *** configure rss *** */ +struct cmd_config_rss { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + cmdline_fixed_string_t value; +}; + +static void +cmd_config_rss_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_rss *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->value, "ip")) + 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; + else if (!strcmp(res->value, "none")) + rss_hf = 0; + else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); -#include + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +cmdline_parse_token_string_t cmd_config_rss_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss, port, "port"); +cmdline_parse_token_string_t cmd_config_rss_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss, keyword, "config"); +cmdline_parse_token_string_t cmd_config_rss_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss, all, "all"); +cmdline_parse_token_string_t cmd_config_rss_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss, name, "rss"); +cmdline_parse_token_string_t cmd_config_rss_value = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss, value, "ip#udp#none"); + +cmdline_parse_inst_t cmd_config_rss = { + .f = cmd_config_rss_parsed, + .data = NULL, + .help_str = "port config all rss ip|udp|none", + .tokens = { + (void *)&cmd_config_rss_port, + (void *)&cmd_config_rss_keyword, + (void *)&cmd_config_rss_all, + (void *)&cmd_config_rss_name, + (void *)&cmd_config_rss_value, + NULL, + }, +}; -#include -#include -#include -#include -#include -#include -#include -#include +/* *** Configure RSS RETA *** */ +struct cmd_config_rss_reta { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + uint8_t port_id; + cmdline_fixed_string_t name; + cmdline_fixed_string_t list_name; + cmdline_fixed_string_t list_of_items; +}; -#include "testpmd.h" +static int +parse_reta_config(const char *str, struct rte_eth_rss_reta *reta_conf) +{ + int i; + unsigned size; + uint8_t hash_index; + uint8_t nb_queue; + char s[256]; + const char *p, *p0 = str; + char *end; + enum fieldnames { + FLD_HASH_INDEX = 0, + FLD_QUEUE, + _NUM_FLD + }; + unsigned long int_fld[_NUM_FLD]; + char *str_fld[_NUM_FLD]; + + while ((p = strchr(p0,'(')) != NULL) { + ++p; + if((p0 = strchr(p,')')) == NULL) + return -1; + + size = p0 - p; + if(size >= sizeof(s)) + return -1; + + rte_snprintf(s, sizeof(s), "%.*s", size, p); + if (rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ',') != _NUM_FLD) + return -1; + for (i = 0; i < _NUM_FLD; i++) { + errno = 0; + int_fld[i] = strtoul(str_fld[i], &end, 0); + if (errno != 0 || end == str_fld[i] || int_fld[i] > 255) + return -1; + } -/* *** HELP *** */ -struct cmd_help_result { - cmdline_fixed_string_t help; + hash_index = (uint8_t)int_fld[FLD_HASH_INDEX]; + nb_queue = (uint8_t)int_fld[FLD_QUEUE]; + + if (hash_index >= ETH_RSS_RETA_NUM_ENTRIES) { + printf("Invalid RETA hash index=%d",hash_index); + return -1; + } + + if (hash_index < ETH_RSS_RETA_NUM_ENTRIES/2) + reta_conf->mask_lo |= (1ULL << hash_index); + else + reta_conf->mask_hi |= (1ULL << (hash_index - ETH_RSS_RETA_NUM_ENTRIES/2)); + + reta_conf->reta[hash_index] = nb_queue; + } + + return 0; +} + +static void +cmd_set_rss_reta_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + int ret; + struct rte_eth_rss_reta reta_conf; + struct cmd_config_rss_reta *res = parsed_result; + + memset(&reta_conf,0,sizeof(struct rte_eth_rss_reta)); + if (!strcmp(res->list_name, "reta")) { + if (parse_reta_config(res->list_of_items, &reta_conf)) { + printf("Invalid RSS Redirection Table config entered\n"); + return; + } + ret = rte_eth_dev_rss_reta_update(res->port_id, &reta_conf); + if (ret != 0) + printf("Bad redirection table parameter, return code = %d \n",ret); + } +} + +cmdline_parse_token_string_t cmd_config_rss_reta_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, port, "port"); +cmdline_parse_token_string_t cmd_config_rss_reta_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, keyword, "config"); +cmdline_parse_token_num_t cmd_config_rss_reta_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, UINT8); +cmdline_parse_token_string_t cmd_config_rss_reta_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, name, "rss"); +cmdline_parse_token_string_t cmd_config_rss_reta_list_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_name, "reta"); +cmdline_parse_token_string_t cmd_config_rss_reta_list_of_items = + TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_of_items, + NULL); +cmdline_parse_inst_t cmd_config_rss_reta = { + .f = cmd_set_rss_reta_parsed, + .data = NULL, + .help_str = "port config X rss reta (hash,queue)[,(hash,queue)]", + .tokens = { + (void *)&cmd_config_rss_reta_port, + (void *)&cmd_config_rss_reta_keyword, + (void *)&cmd_config_rss_reta_port_id, + (void *)&cmd_config_rss_reta_name, + (void *)&cmd_config_rss_reta_list_name, + (void *)&cmd_config_rss_reta_list_of_items, + NULL, + }, }; -static void cmd_help_parsed(__attribute__((unused)) void *parsed_result, - struct cmdline *cl, - __attribute__((unused)) void *data) +/* *** SHOW PORT INFO *** */ +struct cmd_showport_reta { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + uint8_t port_id; + cmdline_fixed_string_t rss; + cmdline_fixed_string_t reta; + uint64_t mask_lo; + uint64_t mask_hi; +}; + +static void cmd_showport_reta_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) { - cmdline_printf(cl, - "\n" - "TEST PMD\n" - "--------\n" - "\n" - "This commandline can be used to configure forwarding\n" - "\n"); - cmdline_printf(cl, - "Display informations:\n" - "---------------------\n" - "- show port info|stats|fdir|stat_qmap X|all\n" - " Diplays information or stats or stats queue mapping on port X, or all\n" - "- clear port stats X|all\n" - " Clear stats for port X, or all\n" - "- show config rxtx|cores|fwd\n" - " Displays the given configuration\n" - "- read reg port_id reg_off\n" - " Displays value of a port register\n" - "- read regfield port_id reg_off bit_x bit_y\n" - " Displays value of a port register bit field\n" - "- read regbit port_id reg_off bit_x\n" - " Displays value of a port register bit\n" - "- read rxd port_id queue_id rxd_id\n" - " Displays a RX descriptor of a port RX queue\n" - "- read txd port_id queue_id txd_id\n" - " Displays a TX descriptor of a port TX queue\n" - "\n"); - cmdline_printf(cl, - "Configure:\n" - "----------\n" - "Modifications are taken into account once " - "forwarding is restarted.\n" - "- set default\n" - " Set forwarding to default configuration\n" - "- set nbport|nbcore|burst|verbose X\n" - " Set number of ports, number of cores, number " - "of packets per burst,\n or verbose level to X\n" - "- set txpkts x[,y]*\n" - " Set the length of each segment of TXONLY packets\n" - "- set coremask|portmask X\n" - " Set the hexadecimal mask of forwarding cores / " - "forwarding ports\n" - "- set corelist|portlist x[,y]*\n" - " Set the list of forwarding cores / forwarding " - "ports\n" - "- vlan set strip|filter|qinq on/off port_id\n" - " Set the VLAN strip, filter, QinQ(extended) on a port" - "- rx_vlan add/rm vlan_id|all port_id\n" - " Set the VLAN filter table, add/remove vlan_id, or all " - "identifiers, to/from the set of VLAN Identifiers\n" - "filtered by port_id\n" - "- rx_vlan set tpid value port_id\n" - " Set Outer VLAN TPID for Packet Filtering on a port \n" - "- tx_vlan set vlan_id port_id\n" - " Set hardware insertion of VLAN ID in packets sent on a port\n" - "- tx_vlan reset port_id\n" - " Disable hardware insertion of a VLAN header in " - "packets sent on port_id\n" - "- tx_checksum set mask port_id\n" - " Enable hardware insertion of checksum offload with " - "the 4-bit mask (0~0xf)\n in packets sent on port_id\n" - " Please check the NIC datasheet for HW limits\n" - " bit 0 - insert ip checksum offload if set \n" - " bit 1 - insert udp checksum offload if set \n" - " bit 2 - insert tcp checksum offload if set\n" - " bit 3 - insert sctp checksum offload if set\n" -#ifdef RTE_LIBRTE_IEEE1588 - "- set fwd io|mac|rxonly|txonly|csum|ieee1588\n" - " Set IO, MAC, RXONLY, TXONLY, CSUM or IEEE1588 " - "packet forwarding mode\n" -#else - "- set fwd io|mac|rxonly|txonly|csum\n" - " Set IO, MAC, RXONLY, CSUM or TXONLY packet " - "forwarding mode\n" -#endif - "- mac_addr add|remove X \n" - " Add/Remove the MAC address on port X\n" - "- set promisc|allmulti [all|X] on|off\n" - " Set/unset promisc|allmulti mode on port X, or all\n" - "- set flow_ctrl rx on|off tx on|off high_water low_water " - "pause_time send_xon port_id \n" - " Set the link flow control parameter on the port \n" - "- write reg port_id reg_off value\n" - " Set value of a port register\n" - "- write regfield port_id reg_off bit_x bit_y value\n" - " Set bit field value of a port register\n" - "- write regbit port_id reg_off bit_x value\n" - " Set bit value of a port register\n" - "- set stat_qmap tx|rx port_id queue_id qmapping\n" - " Set statistics mapping (qmapping 0..15) for tx|rx queue_id on port_id\n" - " e.g., 'set stat_qmap rx 0 2 5' sets rx queue 2 on port 0 to mapping 5\n" - "\n"); - cmdline_printf(cl, - "Control forwarding:\n" - "-------------------\n" - "- start\n" - " Start packet forwarding with current config\n" - "- start tx_first\n" - " Start packet forwarding with current config" - " after sending one burst\n of packets\n" - "- stop\n" - " Stop packet forwarding, and displays accumulated" - " stats\n" - "\n"); - cmdline_printf(cl, - "Flow director mode:\n" - "-------------------\n" - "- add_signature_filter port_id ip|udp|tcp|sctp src\n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id queue queue_id\n" - "- upd_signature_filter port_id ip|udp|tcp|sctp src \n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id queue queue_id\n" - "- rm_signature_filter port_id ip|udp|tcp|sctp src\n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id\n" - "- add_perfect_filter port_id ip|udp|tcp|sctp src\n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id queue \n" - " queue_id soft soft_id\n" - "- upd_perfect_filter port_id ip|udp|tcp|sctp src\n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id queue queue_id\n" - "- rm_perfect_filter port_id ip|udp|tcp|sctp src\n" - " ip_src_address port_src dst ip_dst_address port_dst\n" - " flexbytes flexbytes_values vlan vlan_id soft soft_id\n" - "- set_masks_filter port_id only_ip_flow 0|1 src_mask\n" - " ip_src_mask port_src_mask dst_mask ip_dst_mask\n" - " port_dst_mask flexbytes 0|1 vlan_id 0|1 vlan_prio 0|1\n" - "- set_ipv6_masks_filter port_id only_ip_flow 0|1 src_mask\n" - " ip_src_mask port_src_mask dst_mask ip_dst_mask\n" - " port_dst_mask flexbytes 0|1 vlan_id 0|1\n" - " vlan_prio 0|1 compare_dst 0|1\n" - "\n"); - cmdline_printf(cl, - "Misc:\n" - "-----\n" - "- quit\n" - " Quit to prompt in linux, and reboot on baremetal\n" - "\n"); + struct cmd_showport_reta *res = parsed_result; + struct rte_eth_rss_reta reta_conf; + + if ((res->mask_lo == 0) && (res->mask_hi == 0)) { + printf("Invalid RSS Redirection Table config entered\n"); + return; + } + + reta_conf.mask_lo = res->mask_lo; + reta_conf.mask_hi = res->mask_hi; + + port_rss_reta_info(res->port_id,&reta_conf); +} + +cmdline_parse_token_string_t cmd_showport_reta_show = + TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, show, "show"); +cmdline_parse_token_string_t cmd_showport_reta_port = + TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, port, "port"); +cmdline_parse_token_num_t cmd_showport_reta_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, UINT8); +cmdline_parse_token_string_t cmd_showport_reta_rss = + TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, rss, "rss"); +cmdline_parse_token_string_t cmd_showport_reta_reta = + TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, reta, "reta"); +cmdline_parse_token_num_t cmd_showport_reta_mask_lo = + TOKEN_NUM_INITIALIZER(struct cmd_showport_reta,mask_lo,UINT64); +cmdline_parse_token_num_t cmd_showport_reta_mask_hi = + TOKEN_NUM_INITIALIZER(struct cmd_showport_reta,mask_hi,UINT64); + +cmdline_parse_inst_t cmd_showport_reta = { + .f = cmd_showport_reta_parsed, + .data = NULL, + .help_str = "show port X rss reta mask_lo mask_hi (X = port number)\n\ + (mask_lo and mask_hi is UINT64)", + .tokens = { + (void *)&cmd_showport_reta_show, + (void *)&cmd_showport_reta_port, + (void *)&cmd_showport_reta_port_id, + (void *)&cmd_showport_reta_rss, + (void *)&cmd_showport_reta_reta, + (void *)&cmd_showport_reta_mask_lo, + (void *)&cmd_showport_reta_mask_hi, + NULL, + }, +}; + +/* *** Configure DCB *** */ +struct cmd_config_dcb { + cmdline_fixed_string_t port; + cmdline_fixed_string_t config; + uint8_t port_id; + cmdline_fixed_string_t dcb; + cmdline_fixed_string_t vt; + cmdline_fixed_string_t vt_en; + uint8_t num_tcs; + cmdline_fixed_string_t pfc; + cmdline_fixed_string_t pfc_en; +}; + +static void +cmd_config_dcb_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_dcb *res = parsed_result; + struct dcb_config dcb_conf; + portid_t port_id = res->port_id; + struct rte_port *port; + + port = &ports[port_id]; + /** Check if the port is not started **/ + if (port->port_status != RTE_PORT_STOPPED) { + printf("Please stop port %d first\n",port_id); + return; + } + + dcb_conf.num_tcs = (enum rte_eth_nb_tcs) res->num_tcs; + if ((dcb_conf.num_tcs != ETH_4_TCS) && (dcb_conf.num_tcs != ETH_8_TCS)){ + printf("The invalid number of traffic class,only 4 or 8 allowed\n"); + return; + } + + /* DCB in VT mode */ + if (!strncmp(res->vt_en, "on",2)) + dcb_conf.dcb_mode = DCB_VT_ENABLED; + else + dcb_conf.dcb_mode = DCB_ENABLED; + + if (!strncmp(res->pfc_en, "on",2)) { + dcb_conf.pfc_en = 1; + } + else + dcb_conf.pfc_en = 0; + + if (init_port_dcb_config(port_id,&dcb_conf) != 0) { + printf("Cannot initialize network ports\n"); + return; + } + + cmd_reconfig_device_queue(port_id, 1, 1); } -cmdline_parse_token_string_t cmd_help_help = - TOKEN_STRING_INITIALIZER(struct cmd_help_result, help, "help"); +cmdline_parse_token_string_t cmd_config_dcb_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, port, "port"); +cmdline_parse_token_string_t cmd_config_dcb_config = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config"); +cmdline_parse_token_num_t cmd_config_dcb_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, UINT8); +cmdline_parse_token_string_t cmd_config_dcb_dcb = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb"); +cmdline_parse_token_string_t cmd_config_dcb_vt = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt, "vt"); +cmdline_parse_token_string_t cmd_config_dcb_vt_en = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off"); +cmdline_parse_token_num_t cmd_config_dcb_num_tcs = + TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, UINT8); +cmdline_parse_token_string_t cmd_config_dcb_pfc= + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc"); +cmdline_parse_token_string_t cmd_config_dcb_pfc_en = + TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc_en, "on#off"); + +cmdline_parse_inst_t cmd_config_dcb = { + .f = cmd_config_dcb_parsed, + .data = NULL, + .help_str = "port config port-id dcb vt on|off nb-tcs pfc on|off", + .tokens = { + (void *)&cmd_config_dcb_port, + (void *)&cmd_config_dcb_config, + (void *)&cmd_config_dcb_port_id, + (void *)&cmd_config_dcb_dcb, + (void *)&cmd_config_dcb_vt, + (void *)&cmd_config_dcb_vt_en, + (void *)&cmd_config_dcb_num_tcs, + (void *)&cmd_config_dcb_pfc, + (void *)&cmd_config_dcb_pfc_en, + NULL, + }, +}; + +/* *** configure number of packets per burst *** */ +struct cmd_config_burst { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + uint16_t value; +}; + +static void +cmd_config_burst_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_burst *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "burst")) { + if (res->value < 1 || res->value > MAX_PKT_BURST) { + printf("burst must be >= 1 && <= %d\n", MAX_PKT_BURST); + return; + } + nb_pkt_per_burst = res->value; + } else { + printf("Unknown parameter\n"); + return; + } -cmdline_parse_inst_t cmd_help = { - .f = cmd_help_parsed, + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_burst_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_burst, port, "port"); +cmdline_parse_token_string_t cmd_config_burst_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_burst, keyword, "config"); +cmdline_parse_token_string_t cmd_config_burst_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_burst, all, "all"); +cmdline_parse_token_string_t cmd_config_burst_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst"); +cmdline_parse_token_num_t cmd_config_burst_value = + TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, UINT16); + +cmdline_parse_inst_t cmd_config_burst = { + .f = cmd_config_burst_parsed, .data = NULL, - .help_str = "show help", + .help_str = "port config all burst value", + .tokens = { + (void *)&cmd_config_burst_port, + (void *)&cmd_config_burst_keyword, + (void *)&cmd_config_burst_all, + (void *)&cmd_config_burst_name, + (void *)&cmd_config_burst_value, + NULL, + }, +}; + +/* *** configure rx/tx queues *** */ +struct cmd_config_thresh { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + uint8_t value; +}; + +static void +cmd_config_thresh_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_thresh *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "txpt")) + tx_thresh.pthresh = res->value; + else if(!strcmp(res->name, "txht")) + tx_thresh.hthresh = res->value; + else if(!strcmp(res->name, "txwt")) + tx_thresh.wthresh = res->value; + else if(!strcmp(res->name, "rxpt")) + rx_thresh.pthresh = res->value; + else if(!strcmp(res->name, "rxht")) + rx_thresh.hthresh = res->value; + else if(!strcmp(res->name, "rxwt")) + rx_thresh.wthresh = res->value; + else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_thresh_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, port, "port"); +cmdline_parse_token_string_t cmd_config_thresh_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, keyword, "config"); +cmdline_parse_token_string_t cmd_config_thresh_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, all, "all"); +cmdline_parse_token_string_t cmd_config_thresh_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name, + "txpt#txht#txwt#rxpt#rxht#rxwt"); +cmdline_parse_token_num_t cmd_config_thresh_value = + TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, UINT8); + +cmdline_parse_inst_t cmd_config_thresh = { + .f = cmd_config_thresh_parsed, + .data = NULL, + .help_str = "port config all txpt|txht|txwt|rxpt|rxht|rxwt value", + .tokens = { + (void *)&cmd_config_thresh_port, + (void *)&cmd_config_thresh_keyword, + (void *)&cmd_config_thresh_all, + (void *)&cmd_config_thresh_name, + (void *)&cmd_config_thresh_value, + NULL, + }, +}; + +/* *** configure free/rs threshold *** */ +struct cmd_config_threshold { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t all; + cmdline_fixed_string_t name; + uint16_t value; +}; + +static void +cmd_config_threshold_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_threshold *res = parsed_result; + + if (!all_ports_stopped()) { + printf("Please stop all ports first\n"); + return; + } + + if (!strcmp(res->name, "txfreet")) + tx_free_thresh = res->value; + else if (!strcmp(res->name, "txrst")) + tx_rs_thresh = res->value; + else if (!strcmp(res->name, "rxfreet")) + rx_free_thresh = res->value; + else { + printf("Unknown parameter\n"); + return; + } + + init_port_config(); + + cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); +} + +cmdline_parse_token_string_t cmd_config_threshold_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, port, "port"); +cmdline_parse_token_string_t cmd_config_threshold_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, keyword, + "config"); +cmdline_parse_token_string_t cmd_config_threshold_all = + TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, all, "all"); +cmdline_parse_token_string_t cmd_config_threshold_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name, + "txfreet#txrst#rxfreet"); +cmdline_parse_token_num_t cmd_config_threshold_value = + TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, UINT16); + +cmdline_parse_inst_t cmd_config_threshold = { + .f = cmd_config_threshold_parsed, + .data = NULL, + .help_str = "port config all txfreet|txrst|rxfreet value", .tokens = { - (void *)&cmd_help_help, + (void *)&cmd_config_threshold_port, + (void *)&cmd_config_threshold_keyword, + (void *)&cmd_config_threshold_all, + (void *)&cmd_config_threshold_name, + (void *)&cmd_config_threshold_value, NULL, }, }; @@ -586,12 +1886,12 @@ cmd_vlan_offload_parsed(void *parsed_result, __attribute__((unused)) void *data) { int on; - struct cmd_vlan_offload_result *res = parsed_result; + struct cmd_vlan_offload_result *res = parsed_result; char *str; int i, len = 0; portid_t port_id = 0; unsigned int tmp; - + str = res->port_id; len = strnlen(str, STR_TOKEN_SIZE); i = 0; @@ -599,13 +1899,13 @@ cmd_vlan_offload_parsed(void *parsed_result, while(i < len){ if(str[i] == ',') break; - + i++; } str[i]='\0'; tmp = strtoul(str, NULL, 0); /* If port_id greater that what portid_t can represent, return */ - if(tmp > 255) + if(tmp >= RTE_MAX_ETHPORTS) return; port_id = (portid_t)tmp; @@ -626,7 +1926,7 @@ cmd_vlan_offload_parsed(void *parsed_result, /* If queue_id greater that what 16-bits can represent, return */ if(tmp > 0xffff) return; - + queue_id = (uint16_t)tmp; rx_vlan_strip_set_on_queue(port_id, queue_id, on); } @@ -1481,7 +2781,7 @@ cmdline_parse_token_num_t cmd_pkt_filter_masks_port_src_mask = port_src_mask, UINT16); cmdline_parse_token_string_t cmd_pkt_filter_masks_dst_mask = TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, - src_mask, "dst_mask"); + dst_mask, "dst_mask"); cmdline_parse_token_num_t cmd_pkt_filter_masks_ip_dst_mask = TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, ip_dst_mask, UINT32); @@ -1703,6 +3003,109 @@ cmdline_parse_inst_t cmd_link_flow_control_set = { }, }; +/* *** SETUP ETHERNET PIRORITY FLOW CONTROL *** */ +struct cmd_priority_flow_ctrl_set_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t pfc_ctrl; + cmdline_fixed_string_t rx; + cmdline_fixed_string_t rx_pfc_mode; + cmdline_fixed_string_t tx; + cmdline_fixed_string_t tx_pfc_mode; + uint32_t high_water; + uint32_t low_water; + uint16_t pause_time; + uint8_t priority; + uint8_t port_id; +}; + +static void +cmd_priority_flow_ctrl_set_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_priority_flow_ctrl_set_result *res = parsed_result; + struct rte_eth_pfc_conf pfc_conf; + int rx_fc_enable, tx_fc_enable; + int ret; + + /* + * Rx on/off, flow control is enabled/disabled on RX side. This can indicate + * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side. + * Tx on/off, flow control is enabled/disabled on TX side. This can indicate + * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. + */ + static enum rte_eth_fc_mode rx_tx_onoff_2_pfc_mode[2][2] = { + {RTE_FC_NONE, RTE_FC_RX_PAUSE}, {RTE_FC_TX_PAUSE, RTE_FC_FULL} + }; + + rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on",2)) ? 1 : 0; + tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on",2)) ? 1 : 0; + pfc_conf.fc.mode = rx_tx_onoff_2_pfc_mode[rx_fc_enable][tx_fc_enable]; + pfc_conf.fc.high_water = res->high_water; + pfc_conf.fc.low_water = res->low_water; + pfc_conf.fc.pause_time = res->pause_time; + pfc_conf.priority = res->priority; + + ret = rte_eth_dev_priority_flow_ctrl_set(res->port_id, &pfc_conf); + if (ret != 0) + printf("bad priority flow contrl parameter, return code = %d \n", ret); +} + +cmdline_parse_token_string_t cmd_pfc_set_set = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + set, "set"); +cmdline_parse_token_string_t cmd_pfc_set_flow_ctrl = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + pfc_ctrl, "pfc_ctrl"); +cmdline_parse_token_string_t cmd_pfc_set_rx = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + rx, "rx"); +cmdline_parse_token_string_t cmd_pfc_set_rx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + rx_pfc_mode, "on#off"); +cmdline_parse_token_string_t cmd_pfc_set_tx = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + tx, "tx"); +cmdline_parse_token_string_t cmd_pfc_set_tx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + tx_pfc_mode, "on#off"); +cmdline_parse_token_num_t cmd_pfc_set_high_water = + TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + high_water, UINT32); +cmdline_parse_token_num_t cmd_pfc_set_low_water = + TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + low_water, UINT32); +cmdline_parse_token_num_t cmd_pfc_set_pause_time = + TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + pause_time, UINT16); +cmdline_parse_token_num_t cmd_pfc_set_priority = + TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + priority, UINT8); +cmdline_parse_token_num_t cmd_pfc_set_portid = + TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, + port_id, UINT8); + +cmdline_parse_inst_t cmd_priority_flow_control_set = { + .f = cmd_priority_flow_ctrl_set_parsed, + .data = NULL, + .help_str = "Configure the Ethernet priority flow control: set pfc_ctrl rx on|off\n\ + tx on|off high_water low_water pause_time priority port_id", + .tokens = { + (void *)&cmd_pfc_set_set, + (void *)&cmd_pfc_set_flow_ctrl, + (void *)&cmd_pfc_set_rx, + (void *)&cmd_pfc_set_rx_mode, + (void *)&cmd_pfc_set_tx, + (void *)&cmd_pfc_set_tx_mode, + (void *)&cmd_pfc_set_high_water, + (void *)&cmd_pfc_set_low_water, + (void *)&cmd_pfc_set_pause_time, + (void *)&cmd_pfc_set_priority, + (void *)&cmd_pfc_set_portid, + NULL, + }, +}; + /* *** RESET CONFIGURATION *** */ struct cmd_reset_result { cmdline_fixed_string_t reset; @@ -2335,7 +3738,7 @@ cmdline_parse_token_string_t cmd_mac_addr_what = "add#remove"); cmdline_parse_token_num_t cmd_mac_addr_portnum = TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num, UINT8); -cmdline_parse_token_string_t cmd_mac_addr_addr = +cmdline_parse_token_etheraddr_t cmd_mac_addr_addr = TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address); cmdline_parse_inst_t cmd_mac_addr = { @@ -2412,7 +3815,8 @@ cmdline_parse_inst_t cmd_set_qmap = { /* list of instructions */ cmdline_parse_ctx_t main_ctx[] = { - (cmdline_parse_inst_t *)&cmd_help, + (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_showportall, @@ -2437,6 +3841,8 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tx_vlan_reset, (cmdline_parse_inst_t *)&cmd_tx_cksum_set, (cmdline_parse_inst_t *)&cmd_link_flow_control_set, + (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, (cmdline_parse_inst_t *)&cmd_read_reg_bit, @@ -2455,6 +3861,19 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_stop, (cmdline_parse_inst_t *)&cmd_mac_addr, (cmdline_parse_inst_t *)&cmd_set_qmap, + (cmdline_parse_inst_t *)&cmd_operate_port, + (cmdline_parse_inst_t *)&cmd_operate_specific_port, + (cmdline_parse_inst_t *)&cmd_config_speed_all, + (cmdline_parse_inst_t *)&cmd_config_speed_specific, + (cmdline_parse_inst_t *)&cmd_config_rx_tx, + (cmdline_parse_inst_t *)&cmd_config_max_pkt_len, + (cmdline_parse_inst_t *)&cmd_config_rx_mode_flag, + (cmdline_parse_inst_t *)&cmd_config_rss, + (cmdline_parse_inst_t *)&cmd_config_rss_reta, + (cmdline_parse_inst_t *)&cmd_showport_reta, + (cmdline_parse_inst_t *)&cmd_config_burst, + (cmdline_parse_inst_t *)&cmd_config_thresh, + (cmdline_parse_inst_t *)&cmd_config_threshold, NULL, }; @@ -2471,3 +3890,27 @@ prompt(void) cmdline_interact(cl); cmdline_stdin_exit(cl); } + +static void +cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue) +{ + if (id < nb_ports) { + /* check if need_reconfig has been set to 1 */ + if (ports[id].need_reconfig == 0) + ports[id].need_reconfig = dev; + /* check if need_reconfig_queues has been set to 1 */ + if (ports[id].need_reconfig_queues == 0) + ports[id].need_reconfig_queues = queue; + } else { + portid_t pid; + + for (pid = 0; pid < nb_ports; pid++) { + /* check if need_reconfig has been set to 1 */ + if (ports[pid].need_reconfig == 0) + ports[pid].need_reconfig = dev; + /* check if need_reconfig_queues has been set to 1 */ + if (ports[pid].need_reconfig_queues == 0) + ports[pid].need_reconfig_queues = queue; + } + } +}