X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=1e5b294ab31dc812eca9124dfc808850cef69cee;hb=f7352c176bbf131728445680ee08961a67cc09a6;hp=11f9c015c975291439a42fc3ba5fef2ac9320e3f;hpb=f29fa2c59b858dc725c3d8486eddb59797bbb6dc;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 11f9c015c9..1e5b294ab3 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -8,12 +8,8 @@ #include #include #include -#include #include #include -#include -#include - #include #include @@ -28,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -39,7 +34,9 @@ #include #include #include +#ifdef RTE_LIB_GRO #include +#endif #include #include @@ -166,6 +163,9 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (info|stats|summary|xstats|fdir|dcb_tc) (port_id|all)\n" " Display information for port_id, or all.\n\n" + "show port info (port_id) representor\n" + " Show supported representors for a specific port\n\n" + "show port port_id (module_eeprom|eeprom)\n" " Display the module EEPROM or EEPROM information for port_id.\n\n" @@ -253,11 +253,17 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (port_id) macs|mcast_macs" " Display list of mac addresses added to port.\n\n" + "show port (port_id) flow transfer proxy\n" + " Display proxy port to manage transfer flows\n\n" + "show port (port_id) fec capabilities" " Show fec capabilities of a port.\n\n" "show port (port_id) fec_mode" " Show fec mode of a port.\n\n" + + "show port (port_id) flow_ctrl" + " Show flow control info of a port.\n\n" ); } @@ -457,6 +463,7 @@ static void cmd_help_long_parsed(void *parsed_result, "tso show (portid)" " Display the status of TCP Segmentation Offload.\n\n" +#ifdef RTE_LIB_GRO "set port (port_id) gro on|off\n" " Enable or disable Generic Receive Offload in" " csum forwarding engine.\n\n" @@ -467,7 +474,9 @@ static void cmd_help_long_parsed(void *parsed_result, "set gro flush (cycles)\n" " Set the cycle to flush GROed packets from" " reassembly tables.\n\n" +#endif +#ifdef RTE_LIB_GSO "set port (port_id) gso (on|off)" " Enable or disable Generic Segmentation Offload in" " csum forwarding engine.\n\n" @@ -478,6 +487,7 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (port_id) gso\n" " Show GSO configuration.\n\n" +#endif "set fwd (%s)\n" " Set packet forwarding mode.\n\n" @@ -534,6 +544,11 @@ static void cmd_help_long_parsed(void *parsed_result, " Set the priority flow control parameter on a" " port.\n\n" + "set pfc_queue_ctrl (port_id) rx (on|off) (tx_qid)" + " (tx_tc) tx (on|off) (rx_qid) (rx_tc) (pause_time)\n" + " Set the queue priority flow control parameter on a" + " given Rx and Tx queues of 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" @@ -551,7 +566,7 @@ static void cmd_help_long_parsed(void *parsed_result, " Set the option to enable display of RX and TX bursts.\n" "set port (port_id) vf (vf_id) rx|tx on|off\n" - " Enable/Disable a VF receive/tranmit from a port\n\n" + " Enable/Disable a VF receive/transmit from a port\n\n" "set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM" "|MPE) (on|off)\n" @@ -568,24 +583,6 @@ static void cmd_help_long_parsed(void *parsed_result, "queue_mask (queue_mask_value)\n" " Set rate limit for queues in VF of a port\n\n" - "set port (port_id) mirror-rule (rule_id)" - " (pool-mirror-up|pool-mirror-down|vlan-mirror)" - " (poolmask|vlanid[,vlanid]*) dst-pool (pool_id) (on|off)\n" - " Set pool or vlan type mirror rule on a port.\n" - " e.g., 'set port 0 mirror-rule 0 vlan-mirror 0,1" - " dst-pool 0 on' enable mirror traffic with vlan 0,1" - " to pool 0.\n\n" - - "set port (port_id) mirror-rule (rule_id)" - " (uplink-mirror|downlink-mirror) dst-pool" - " (pool_id) (on|off)\n" - " Set uplink or downlink type mirror rule on a port.\n" - " e.g., 'set port 0 mirror-rule 0 uplink-mirror dst-pool" - " 0 on' enable mirror income traffic to pool 0.\n\n" - - "reset port (port_id) mirror-rule (rule_id)\n" - " Reset a mirror rule.\n\n" - "set flush_rx (on|off)\n" " Flush (default) or don't flush RX streams before" " forwarding. Mainly used with PCAP drivers.\n\n" @@ -632,6 +629,9 @@ static void cmd_help_long_parsed(void *parsed_result, "show bonding config (port_id)\n" " Show the bonding config for port_id.\n\n" + "show bonding lacp info (port_id)\n" + " Show the bonding lacp information for port_id.\n\n" + "set bonding mac_addr (port_id) (address)\n" " Set the MAC address of a bonded device.\n\n" @@ -798,8 +798,8 @@ static void cmd_help_long_parsed(void *parsed_result, "receive buffers available.\n\n" "port config all rss (all|default|ip|tcp|udp|sctp|" - "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|" - "level-outer|level-inner|)\n" + "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|ipv4-chksum|l2tpv2|" + "none|level-default|level-outer|level-inner|)\n" " Set the RSS mode.\n\n" "port config port-id rss reta (hash,queue)[,(hash,queue)]\n" @@ -908,6 +908,9 @@ static void cmd_help_long_parsed(void *parsed_result, " Register a dynf and Set/clear this flag on Tx. " "Testpmd will set this value to any Tx packet " "sent from this port\n\n" + + "port cleanup (port_id) txq (queue_id) (free_cnt)\n" + " Cleanup txq mbufs for a specific Tx queue\n\n" ); } @@ -1220,7 +1223,7 @@ static void cmd_operate_port_parsed(void *parsed_result, else if (!strcmp(res->name, "reset")) reset_port(RTE_PORT_ALL); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_port_all_cmd = @@ -1235,7 +1238,7 @@ cmdline_parse_token_string_t cmd_operate_port_all_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/Reset all ports", + .help_str = "port start|stop|close|reset all: Start/Stop/Close/Reset all ports", .tokens = { (void *)&cmd_operate_port_all_cmd, (void *)&cmd_operate_port_all_port, @@ -1266,7 +1269,7 @@ static void cmd_operate_specific_port_parsed(void *parsed_result, else if (!strcmp(res->name, "reset")) reset_port(res->value); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_specific_port_cmd = @@ -1282,7 +1285,7 @@ cmdline_parse_token_num_t cmd_operate_specific_port_id = cmdline_parse_inst_t cmd_operate_specific_port = { .f = cmd_operate_specific_port_parsed, .data = NULL, - .help_str = "port start|stop|close : Start/Stop/Close/Reset port_id", + .help_str = "port start|stop|close|reset : Start/Stop/Close/Reset port_id", .tokens = { (void *)&cmd_operate_specific_port_cmd, (void *)&cmd_operate_specific_port_port, @@ -1311,7 +1314,7 @@ static void cmd_set_port_setup_on_parsed(void *parsed_result, else if (strcmp(res->mode, "iterator") == 0) setup_on_probe_event = false; else - printf("Unknown mode\n"); + fprintf(stderr, "Unknown mode\n"); } cmdline_parse_token_string_t cmd_set_port_setup_on_set = @@ -1360,7 +1363,7 @@ static void cmd_operate_attach_port_parsed(void *parsed_result, if (!strcmp(res->keyword, "attach")) attach_port(res->identifier); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_attach_port_port = @@ -1403,7 +1406,7 @@ static void cmd_operate_detach_port_parsed(void *parsed_result, RTE_ETH_VALID_PORTID_OR_RET(res->port_id); detach_port_device(res->port_id); } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } } @@ -1445,7 +1448,7 @@ static void cmd_operate_detach_device_parsed(void *parsed_result, if (!strcmp(res->keyword, "detach")) detach_devargs(res->identifier); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_detach_device_device = @@ -1488,51 +1491,51 @@ parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint32_t *speed) int duplex; if (!strcmp(duplexstr, "half")) { - duplex = ETH_LINK_HALF_DUPLEX; + duplex = RTE_ETH_LINK_HALF_DUPLEX; } else if (!strcmp(duplexstr, "full")) { - duplex = ETH_LINK_FULL_DUPLEX; + duplex = RTE_ETH_LINK_FULL_DUPLEX; } else if (!strcmp(duplexstr, "auto")) { - duplex = ETH_LINK_FULL_DUPLEX; + duplex = RTE_ETH_LINK_FULL_DUPLEX; } else { - printf("Unknown duplex parameter\n"); + fprintf(stderr, "Unknown duplex parameter\n"); return -1; } if (!strcmp(speedstr, "10")) { - *speed = (duplex == ETH_LINK_HALF_DUPLEX) ? - ETH_LINK_SPEED_10M_HD : ETH_LINK_SPEED_10M; + *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ? + RTE_ETH_LINK_SPEED_10M_HD : RTE_ETH_LINK_SPEED_10M; } else if (!strcmp(speedstr, "100")) { - *speed = (duplex == ETH_LINK_HALF_DUPLEX) ? - ETH_LINK_SPEED_100M_HD : ETH_LINK_SPEED_100M; + *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ? + RTE_ETH_LINK_SPEED_100M_HD : RTE_ETH_LINK_SPEED_100M; } else { - if (duplex != ETH_LINK_FULL_DUPLEX) { - printf("Invalid speed/duplex parameters\n"); + if (duplex != RTE_ETH_LINK_FULL_DUPLEX) { + fprintf(stderr, "Invalid speed/duplex parameters\n"); return -1; } if (!strcmp(speedstr, "1000")) { - *speed = ETH_LINK_SPEED_1G; + *speed = RTE_ETH_LINK_SPEED_1G; } else if (!strcmp(speedstr, "10000")) { - *speed = ETH_LINK_SPEED_10G; + *speed = RTE_ETH_LINK_SPEED_10G; } else if (!strcmp(speedstr, "25000")) { - *speed = ETH_LINK_SPEED_25G; + *speed = RTE_ETH_LINK_SPEED_25G; } else if (!strcmp(speedstr, "40000")) { - *speed = ETH_LINK_SPEED_40G; + *speed = RTE_ETH_LINK_SPEED_40G; } else if (!strcmp(speedstr, "50000")) { - *speed = ETH_LINK_SPEED_50G; + *speed = RTE_ETH_LINK_SPEED_50G; } else if (!strcmp(speedstr, "100000")) { - *speed = ETH_LINK_SPEED_100G; + *speed = RTE_ETH_LINK_SPEED_100G; } else if (!strcmp(speedstr, "200000")) { - *speed = ETH_LINK_SPEED_200G; + *speed = RTE_ETH_LINK_SPEED_200G; } else if (!strcmp(speedstr, "auto")) { - *speed = ETH_LINK_SPEED_AUTONEG; + *speed = RTE_ETH_LINK_SPEED_AUTONEG; } else { - printf("Unknown speed parameter\n"); + fprintf(stderr, "Unknown speed parameter\n"); return -1; } } - if (*speed != ETH_LINK_SPEED_AUTONEG) - *speed |= ETH_LINK_SPEED_FIXED; + if (*speed != RTE_ETH_LINK_SPEED_AUTONEG) + *speed |= RTE_ETH_LINK_SPEED_FIXED; return 0; } @@ -1547,7 +1550,7 @@ cmd_config_speed_all_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -1617,13 +1620,13 @@ cmd_config_speed_specific_parsed(void *parsed_result, struct cmd_config_speed_specific *res = parsed_result; uint32_t link_speed; - if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + if (port_id_is_invalid(res->id, ENABLED_WARN)) return; - } - if (port_id_is_invalid(res->id, ENABLED_WARN)) + if (!port_is_stopped(res->id)) { + fprintf(stderr, "Please stop port %d first\n", res->id); return; + } if (parse_and_check_speed_duplex(res->value1, res->value2, &link_speed) < 0) @@ -1692,7 +1695,7 @@ cmd_config_loopback_all_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -1750,7 +1753,7 @@ cmd_config_loopback_specific_parsed(void *parsed_result, return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %u first\n", res->port_id); + fprintf(stderr, "Please stop port %u first\n", res->port_id); return; } @@ -1807,12 +1810,12 @@ cmd_config_rx_tx_parsed(void *parsed_result, struct cmd_config_rx_tx *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } if (!strcmp(res->name, "rxq")) { if (!res->value && !nb_txq) { - printf("Warning: Either rx or tx queues should be non zero\n"); + fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n"); return; } if (check_nb_rxq(res->value) != 0) @@ -1821,7 +1824,7 @@ cmd_config_rx_tx_parsed(void *parsed_result, } else if (!strcmp(res->name, "txq")) { if (!res->value && !nb_rxq) { - printf("Warning: Either rx or tx queues should be non zero\n"); + fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n"); return; } if (check_nb_txq(res->value) != 0) @@ -1838,7 +1841,7 @@ cmd_config_rx_tx_parsed(void *parsed_result, nb_txd = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -1890,43 +1893,38 @@ cmd_config_max_pkt_len_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_config_max_pkt_len_result *res = parsed_result; - uint32_t max_rx_pkt_len_backup = 0; - portid_t pid; + portid_t port_id; int ret; - if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + if (strcmp(res->name, "max-pkt-len") != 0) { + printf("Unknown parameter\n"); return; } - RTE_ETH_FOREACH_DEV(pid) { - struct rte_port *port = &ports[pid]; - - if (!strcmp(res->name, "max-pkt-len")) { - if (res->value < RTE_ETHER_MIN_LEN) { - printf("max-pkt-len can not be less than %d\n", - RTE_ETHER_MIN_LEN); - return; - } - if (res->value == port->dev_conf.rxmode.max_rx_pkt_len) - return; + if (!all_ports_stopped()) { + fprintf(stderr, "Please stop all ports first\n"); + return; + } - ret = eth_dev_info_get_print_err(pid, &port->dev_info); - if (ret != 0) { - printf("rte_eth_dev_info_get() failed for port %u\n", - pid); - return; - } + RTE_ETH_FOREACH_DEV(port_id) { + struct rte_port *port = &ports[port_id]; - max_rx_pkt_len_backup = port->dev_conf.rxmode.max_rx_pkt_len; + if (res->value < RTE_ETHER_MIN_LEN) { + fprintf(stderr, + "max-pkt-len can not be less than %d\n", + RTE_ETHER_MIN_LEN); + return; + } - port->dev_conf.rxmode.max_rx_pkt_len = res->value; - if (update_jumbo_frame_offload(pid) != 0) - port->dev_conf.rxmode.max_rx_pkt_len = max_rx_pkt_len_backup; - } else { - printf("Unknown parameter\n"); + ret = eth_dev_info_get_print_err(port_id, &port->dev_info); + if (ret != 0) { + fprintf(stderr, + "rte_eth_dev_info_get() failed for port %u\n", + port_id); return; } + + update_mtu_from_frame_size(port_id, res->value); } init_port_config(); @@ -1982,7 +1980,7 @@ cmd_config_max_lro_pkt_size_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -1996,7 +1994,7 @@ cmd_config_max_lro_pkt_size_parsed(void *parsed_result, port->dev_conf.rxmode.max_lro_pkt_size = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } } @@ -2052,10 +2050,6 @@ cmd_config_mtu_parsed(void *parsed_result, { struct cmd_config_mtu_result *res = parsed_result; - if (res->value < RTE_ETHER_MIN_LEN) { - printf("mtu cannot be less than %d\n", RTE_ETHER_MIN_LEN); - return; - } port_mtu_set(res->port_id, res->value); } @@ -2106,7 +2100,7 @@ cmd_config_rx_mode_flag_parsed(void *parsed_result, struct cmd_config_rx_mode_flag *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -2116,11 +2110,11 @@ cmd_config_rx_mode_flag_parsed(void *parsed_result, else if (!strcmp(res->value, "off")) rx_drop_en = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2181,33 +2175,33 @@ cmd_config_rss_parsed(void *parsed_result, int ret; if (!strcmp(res->value, "all")) - rss_conf.rss_hf = ETH_RSS_ETH | ETH_RSS_VLAN | ETH_RSS_IP | - ETH_RSS_TCP | ETH_RSS_UDP | ETH_RSS_SCTP | - ETH_RSS_L2_PAYLOAD | ETH_RSS_L2TPV3 | ETH_RSS_ESP | - ETH_RSS_AH | ETH_RSS_PFCP | ETH_RSS_GTPU | - ETH_RSS_ECPRI; + rss_conf.rss_hf = RTE_ETH_RSS_ETH | RTE_ETH_RSS_VLAN | RTE_ETH_RSS_IP | + RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP | RTE_ETH_RSS_SCTP | + RTE_ETH_RSS_L2_PAYLOAD | RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_ESP | + RTE_ETH_RSS_AH | RTE_ETH_RSS_PFCP | RTE_ETH_RSS_GTPU | + RTE_ETH_RSS_ECPRI | RTE_ETH_RSS_L2TPV2; else if (!strcmp(res->value, "eth")) - rss_conf.rss_hf = ETH_RSS_ETH; + rss_conf.rss_hf = RTE_ETH_RSS_ETH; else if (!strcmp(res->value, "vlan")) - rss_conf.rss_hf = ETH_RSS_VLAN; + rss_conf.rss_hf = RTE_ETH_RSS_VLAN; else if (!strcmp(res->value, "ip")) - rss_conf.rss_hf = ETH_RSS_IP; + rss_conf.rss_hf = RTE_ETH_RSS_IP; else if (!strcmp(res->value, "udp")) - rss_conf.rss_hf = ETH_RSS_UDP; + rss_conf.rss_hf = RTE_ETH_RSS_UDP; else if (!strcmp(res->value, "tcp")) - rss_conf.rss_hf = ETH_RSS_TCP; + rss_conf.rss_hf = RTE_ETH_RSS_TCP; else if (!strcmp(res->value, "sctp")) - rss_conf.rss_hf = ETH_RSS_SCTP; + rss_conf.rss_hf = RTE_ETH_RSS_SCTP; else if (!strcmp(res->value, "ether")) - rss_conf.rss_hf = ETH_RSS_L2_PAYLOAD; + rss_conf.rss_hf = RTE_ETH_RSS_L2_PAYLOAD; else if (!strcmp(res->value, "port")) - rss_conf.rss_hf = ETH_RSS_PORT; + rss_conf.rss_hf = RTE_ETH_RSS_PORT; else if (!strcmp(res->value, "vxlan")) - rss_conf.rss_hf = ETH_RSS_VXLAN; + rss_conf.rss_hf = RTE_ETH_RSS_VXLAN; else if (!strcmp(res->value, "geneve")) - rss_conf.rss_hf = ETH_RSS_GENEVE; + rss_conf.rss_hf = RTE_ETH_RSS_GENEVE; else if (!strcmp(res->value, "nvgre")) - rss_conf.rss_hf = ETH_RSS_NVGRE; + rss_conf.rss_hf = RTE_ETH_RSS_NVGRE; else if (!strcmp(res->value, "l3-pre32")) rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE32; else if (!strcmp(res->value, "l3-pre40")) @@ -2221,51 +2215,55 @@ cmd_config_rss_parsed(void *parsed_result, else if (!strcmp(res->value, "l3-pre96")) rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE96; else if (!strcmp(res->value, "l3-src-only")) - rss_conf.rss_hf = ETH_RSS_L3_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L3_SRC_ONLY; else if (!strcmp(res->value, "l3-dst-only")) - rss_conf.rss_hf = ETH_RSS_L3_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L3_DST_ONLY; else if (!strcmp(res->value, "l4-src-only")) - rss_conf.rss_hf = ETH_RSS_L4_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L4_SRC_ONLY; else if (!strcmp(res->value, "l4-dst-only")) - rss_conf.rss_hf = ETH_RSS_L4_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L4_DST_ONLY; else if (!strcmp(res->value, "l2-src-only")) - rss_conf.rss_hf = ETH_RSS_L2_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L2_SRC_ONLY; else if (!strcmp(res->value, "l2-dst-only")) - rss_conf.rss_hf = ETH_RSS_L2_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L2_DST_ONLY; else if (!strcmp(res->value, "l2tpv3")) - rss_conf.rss_hf = ETH_RSS_L2TPV3; + rss_conf.rss_hf = RTE_ETH_RSS_L2TPV3; else if (!strcmp(res->value, "esp")) - rss_conf.rss_hf = ETH_RSS_ESP; + rss_conf.rss_hf = RTE_ETH_RSS_ESP; else if (!strcmp(res->value, "ah")) - rss_conf.rss_hf = ETH_RSS_AH; + rss_conf.rss_hf = RTE_ETH_RSS_AH; else if (!strcmp(res->value, "pfcp")) - rss_conf.rss_hf = ETH_RSS_PFCP; + rss_conf.rss_hf = RTE_ETH_RSS_PFCP; else if (!strcmp(res->value, "pppoe")) - rss_conf.rss_hf = ETH_RSS_PPPOE; + rss_conf.rss_hf = RTE_ETH_RSS_PPPOE; else if (!strcmp(res->value, "gtpu")) - rss_conf.rss_hf = ETH_RSS_GTPU; + rss_conf.rss_hf = RTE_ETH_RSS_GTPU; else if (!strcmp(res->value, "ecpri")) - rss_conf.rss_hf = ETH_RSS_ECPRI; + rss_conf.rss_hf = RTE_ETH_RSS_ECPRI; else if (!strcmp(res->value, "mpls")) - rss_conf.rss_hf = ETH_RSS_MPLS; + rss_conf.rss_hf = RTE_ETH_RSS_MPLS; + else if (!strcmp(res->value, "ipv4-chksum")) + rss_conf.rss_hf = RTE_ETH_RSS_IPV4_CHKSUM; + else if (!strcmp(res->value, "l2tpv2")) + rss_conf.rss_hf = RTE_ETH_RSS_L2TPV2; else if (!strcmp(res->value, "none")) rss_conf.rss_hf = 0; else if (!strcmp(res->value, "level-default")) { - rss_hf &= (~ETH_RSS_LEVEL_MASK); - rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_PMD_DEFAULT); + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_PMD_DEFAULT); } else if (!strcmp(res->value, "level-outer")) { - rss_hf &= (~ETH_RSS_LEVEL_MASK); - rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_OUTERMOST); + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_OUTERMOST); } else if (!strcmp(res->value, "level-inner")) { - rss_hf &= (~ETH_RSS_LEVEL_MASK); - rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_INNERMOST); + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_INNERMOST); } else if (!strcmp(res->value, "default")) use_default = 1; else if (isdigit(res->value[0]) && atoi(res->value) > 0 && atoi(res->value) < 64) rss_conf.rss_hf = 1ULL << atoi(res->value); else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } rss_conf.rss_key = NULL; @@ -2291,8 +2289,8 @@ cmd_config_rss_parsed(void *parsed_result, diag = rte_eth_dev_rss_hash_update(i, &local_rss_conf); if (diag < 0) { all_updated = 0; - printf("Configuration of RSS hash at ethernet port %d " - "failed with error (%d): %s.\n", + fprintf(stderr, + "Configuration of RSS hash at ethernet port %d failed with error (%d): %s.\n", i, -diag, strerror(-diag)); } } @@ -2318,8 +2316,8 @@ cmdline_parse_inst_t cmd_config_rss = { .data = NULL, .help_str = "port config all rss " "all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|" - "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|" - "level-outer|level-inner|", + "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|ipv4-chksum|l2tpv2|" + "none|level-default|level-outer|level-inner|", .tokens = { (void *)&cmd_config_rss_port, (void *)&cmd_config_rss_keyword, @@ -2360,8 +2358,9 @@ parse_and_check_key_hexa_digit(char *key, int idx) 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); + fprintf(stderr, + "invalid key: character %c at position %d is not a valid hexa digit\n", + key[idx], idx); return hexa_v; } @@ -2388,15 +2387,16 @@ cmd_config_rss_hash_key_parsed(void *parsed_result, dev_info.hash_key_size <= sizeof(hash_key)) hash_key_size = dev_info.hash_key_size; else { - printf("dev_info did not provide a valid hash key size\n"); + fprintf(stderr, + "dev_info did not provide a valid hash key size\n"); return; } /* Check the length of the RSS hash key */ key_len = strlen(res->key); if (key_len != (hash_key_size * 2)) { - printf("key length: %d invalid - key must be a string of %d" - " hexa-decimal numbers\n", - (int) key_len, hash_key_size * 2); + fprintf(stderr, + "key length: %d invalid - key must be a string of %d hexa-decimal numbers\n", + (int)key_len, hash_key_size * 2); return; } /* Translate RSS hash key into binary representation */ @@ -2432,7 +2432,7 @@ cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type = "ipv6-tcp-ex#ipv6-udp-ex#" "l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#" "l2-src-only#l2-dst-only#s-vlan#c-vlan#" - "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls"); + "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls#l2tpv2"); cmdline_parse_token_string_t cmd_config_rss_hash_key_value = TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL); @@ -2445,7 +2445,7 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = { "l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|" "l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|" "l2-src-only|l2-dst-only|s-vlan|c-vlan|" - "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls " + "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls|l2tpv2 " "", .tokens = { (void *)&cmd_config_rss_hash_key_port, @@ -2458,6 +2458,90 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = { }, }; +/* *** cleanup txq mbufs *** */ +struct cmd_cleanup_txq_mbufs_result { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + uint16_t port_id; + uint16_t queue_id; + uint32_t free_cnt; +}; + +static void +cmd_cleanup_txq_mbufs_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_cleanup_txq_mbufs_result *res = parsed_result; + uint16_t port_id = res->port_id; + uint16_t queue_id = res->queue_id; + uint32_t free_cnt = res->free_cnt; + struct rte_eth_txq_info qinfo; + int ret; + + if (test_done == 0) { + fprintf(stderr, "Please stop forwarding first\n"); + return; + } + + if (rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo)) { + fprintf(stderr, "Failed to get port %u Tx queue %u info\n", + port_id, queue_id); + return; + } + + if (qinfo.queue_state != RTE_ETH_QUEUE_STATE_STARTED) { + fprintf(stderr, "Tx queue %u not started\n", queue_id); + return; + } + + ret = rte_eth_tx_done_cleanup(port_id, queue_id, free_cnt); + if (ret < 0) { + fprintf(stderr, + "Failed to cleanup mbuf for port %u Tx queue %u error desc: %s(%d)\n", + port_id, queue_id, strerror(-ret), ret); + return; + } + + printf("Cleanup port %u Tx queue %u mbuf nums: %u\n", + port_id, queue_id, ret); +} + +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_port = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port, + "port"); +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_cleanup = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, keyword, + "cleanup"); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port_id, + RTE_UINT16); +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_txq = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, name, + "txq"); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_queue_id = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, queue_id, + RTE_UINT16); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_free_cnt = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, free_cnt, + RTE_UINT32); + +cmdline_parse_inst_t cmd_cleanup_txq_mbufs = { + .f = cmd_cleanup_txq_mbufs_parsed, + .data = NULL, + .help_str = "port cleanup txq ", + .tokens = { + (void *)&cmd_cleanup_txq_mbufs_port, + (void *)&cmd_cleanup_txq_mbufs_cleanup, + (void *)&cmd_cleanup_txq_mbufs_port_id, + (void *)&cmd_cleanup_txq_mbufs_txq, + (void *)&cmd_cleanup_txq_mbufs_queue_id, + (void *)&cmd_cleanup_txq_mbufs_free_cnt, + NULL, + }, +}; + /* *** configure port rxq/txq ring size *** */ struct cmd_config_rxtx_ring_size { cmdline_fixed_string_t port; @@ -2482,7 +2566,7 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, return; if (res->portid == (portid_t)RTE_PORT_ALL) { - printf("Invalid port id\n"); + fprintf(stderr, "Invalid port id\n"); return; } @@ -2493,7 +2577,7 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2503,8 +2587,9 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, return; if (isrx && res->size != 0 && res->size <= rx_free_thresh) { - printf("Invalid rx ring_size, must > rx_free_thresh: %d\n", - rx_free_thresh); + fprintf(stderr, + "Invalid rx ring_size, must > rx_free_thresh: %d\n", + rx_free_thresh); return; } @@ -2574,7 +2659,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, int ret = 0; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -2582,7 +2667,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, return; if (port_is_started(res->portid) != 1) { - printf("Please start port %u first\n", res->portid); + fprintf(stderr, "Please start port %u first\n", res->portid); return; } @@ -2591,7 +2676,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2605,7 +2690,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, else if (!strcmp(res->opname, "stop")) isstart = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2619,7 +2704,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, ret = rte_eth_dev_tx_queue_stop(res->portid, res->qid); if (ret == -ENOTSUP) - printf("Function not supported in PMD driver\n"); + fprintf(stderr, "Function not supported in PMD\n"); } cmdline_parse_token_string_t cmd_config_rxtx_queue_port = @@ -2673,7 +2758,7 @@ cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result, return; if (port_is_started(res->port_id) != 0) { - printf("Please stop port %u first\n", res->port_id); + fprintf(stderr, "Please stop port %u first\n", res->port_id); return; } @@ -2772,7 +2857,7 @@ cmd_setup_rxtx_queue_parsed( return; if (res->portid == (portid_t)RTE_PORT_ALL) { - printf("Invalid port id\n"); + fprintf(stderr, "Invalid port id\n"); return; } @@ -2781,15 +2866,15 @@ cmd_setup_rxtx_queue_parsed( else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } if (isrx && rx_queue_id_is_invalid(res->qid)) { - printf("Invalid rx queue\n"); + fprintf(stderr, "Invalid rx queue\n"); return; } else if (!isrx && tx_queue_id_is_invalid(res->qid)) { - printf("Invalid tx queue\n"); + fprintf(stderr, "Invalid tx queue\n"); return; } @@ -2801,9 +2886,8 @@ cmd_setup_rxtx_queue_parsed( mp = mbuf_pool_find(socket_id, 0); if (mp == NULL) { - printf("Failed to setup RX queue: " - "No mempool allocation" - " on the socket %d\n", + fprintf(stderr, + "Failed to setup RX queue: No mempool allocation on the socket %d\n", rxring_numa[res->portid]); return; } @@ -2814,19 +2898,24 @@ cmd_setup_rxtx_queue_parsed( &port->rx_conf[res->qid], mp); if (ret) - printf("Failed to setup RX queue\n"); + fprintf(stderr, "Failed to setup RX queue\n"); } else { socket_id = txring_numa[res->portid]; if (!numa_support || socket_id == NUMA_NO_CONFIG) socket_id = port->socket_id; + if (port->nb_tx_desc[res->qid] < tx_pkt_nb_segs) { + fprintf(stderr, + "Failed to setup TX queue: not enough descriptors\n"); + return; + } ret = rte_eth_tx_queue_setup(res->portid, res->qid, port->nb_tx_desc[res->qid], socket_id, &port->tx_conf[res->qid]); if (ret) - printf("Failed to setup TX queue\n"); + fprintf(stderr, "Failed to setup TX queue\n"); } } @@ -2899,12 +2988,13 @@ parse_reta_config(const char *str, nb_queue = (uint16_t)int_fld[FLD_QUEUE]; if (hash_index >= nb_entries) { - printf("Invalid RETA hash index=%d\n", hash_index); + fprintf(stderr, "Invalid RETA hash index=%d\n", + hash_index); return -1; } - idx = hash_index / RTE_RETA_GROUP_SIZE; - shift = hash_index % RTE_RETA_GROUP_SIZE; + idx = hash_index / RTE_ETH_RETA_GROUP_SIZE; + shift = hash_index % RTE_ETH_RETA_GROUP_SIZE; reta_conf[idx].mask |= (1ULL << shift); reta_conf[idx].reta[shift] = nb_queue; } @@ -2927,15 +3017,16 @@ cmd_set_rss_reta_parsed(void *parsed_result, return; if (dev_info.reta_size == 0) { - printf("Redirection table size is 0 which is " - "invalid for RSS\n"); + fprintf(stderr, + "Redirection table size is 0 which is invalid for RSS\n"); return; } else printf("The reta size of port %d is %u\n", res->port_id, dev_info.reta_size); - if (dev_info.reta_size > ETH_RSS_RETA_SIZE_512) { - printf("Currently do not support more than %u entries of " - "redirection table\n", ETH_RSS_RETA_SIZE_512); + if (dev_info.reta_size > RTE_ETH_RSS_RETA_SIZE_512) { + fprintf(stderr, + "Currently do not support more than %u entries of redirection table\n", + RTE_ETH_RSS_RETA_SIZE_512); return; } @@ -2943,15 +3034,16 @@ cmd_set_rss_reta_parsed(void *parsed_result, if (!strcmp(res->list_name, "reta")) { if (parse_reta_config(res->list_of_items, reta_conf, dev_info.reta_size)) { - printf("Invalid RSS Redirection Table " - "config entered\n"); + fprintf(stderr, + "Invalid RSS Redirection Table config entered\n"); return; } ret = rte_eth_dev_rss_reta_update(res->port_id, reta_conf, dev_info.reta_size); if (ret != 0) - printf("Bad redirection table parameter, " - "return code = %d \n", ret); + fprintf(stderr, + "Bad redirection table parameter, return code = %d\n", + ret); } } @@ -3005,8 +3097,8 @@ showport_parse_reta_config(struct rte_eth_rss_reta_entry64 *conf, char *end; char *str_fld[8]; uint16_t i; - uint16_t num = (nb_entries + RTE_RETA_GROUP_SIZE - 1) / - RTE_RETA_GROUP_SIZE; + uint16_t num = (nb_entries + RTE_ETH_RETA_GROUP_SIZE - 1) / + RTE_ETH_RETA_GROUP_SIZE; int ret; p = strchr(p0, '('); @@ -3018,18 +3110,20 @@ showport_parse_reta_config(struct rte_eth_rss_reta_entry64 *conf, return -1; size = p0 - p; if (size >= sizeof(s)) { - printf("The string size exceeds the internal buffer size\n"); + fprintf(stderr, + "The string size exceeds the internal buffer size\n"); return -1; } snprintf(s, sizeof(s), "%.*s", size, p); ret = rte_strsplit(s, sizeof(s), str_fld, num, ','); if (ret <= 0 || ret != num) { - printf("The bits of masks do not match the number of " - "reta entries: %u\n", num); + fprintf(stderr, + "The bits of masks do not match the number of reta entries: %u\n", + num); return -1; } for (i = 0; i < ret; i++) - conf[i].mask = (uint64_t)strtoul(str_fld[i], &end, 0); + conf[i].mask = (uint64_t)strtoull(str_fld[i], &end, 0); return 0; } @@ -3049,9 +3143,9 @@ cmd_showport_reta_parsed(void *parsed_result, if (ret != 0) return; - max_reta_size = RTE_MIN(dev_info.reta_size, ETH_RSS_RETA_SIZE_512); + max_reta_size = RTE_MIN(dev_info.reta_size, RTE_ETH_RSS_RETA_SIZE_512); if (res->size == 0 || res->size > max_reta_size) { - printf("Invalid redirection table size: %u (1-%u)\n", + fprintf(stderr, "Invalid redirection table size: %u (1-%u)\n", res->size, max_reta_size); return; } @@ -3059,8 +3153,8 @@ cmd_showport_reta_parsed(void *parsed_result, memset(reta_conf, 0, sizeof(reta_conf)); if (showport_parse_reta_config(reta_conf, res->size, res->list_of_items) < 0) { - printf("Invalid string: %s for reta masks\n", - res->list_of_items); + fprintf(stderr, "Invalid string: %s for reta masks\n", + res->list_of_items); return; } port_rss_reta_info(res->port_id, reta_conf, res->size); @@ -3176,6 +3270,7 @@ cmd_config_dcb_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_config_dcb *res = parsed_result; + struct rte_eth_dcb_info dcb_info; portid_t port_id = res->port_id; struct rte_port *port; uint8_t pfc_en; @@ -3184,20 +3279,29 @@ cmd_config_dcb_parsed(void *parsed_result, 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); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } - if ((res->num_tcs != ETH_4_TCS) && (res->num_tcs != ETH_8_TCS)) { - printf("The invalid number of traffic class," - " only 4 or 8 allowed.\n"); + if ((res->num_tcs != RTE_ETH_4_TCS) && (res->num_tcs != RTE_ETH_8_TCS)) { + fprintf(stderr, + "The invalid number of traffic class, only 4 or 8 allowed.\n"); return; } if (nb_fwd_lcores < res->num_tcs) { - printf("nb_cores shouldn't be less than number of TCs.\n"); + fprintf(stderr, + "nb_cores shouldn't be less than number of TCs.\n"); return; } + + /* Check whether the port supports the report of DCB info. */ + ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info); + if (ret == -ENOTSUP) { + fprintf(stderr, "rte_eth_dev_get_dcb_info not supported.\n"); + return; + } + if (!strncmp(res->pfc_en, "on", 2)) pfc_en = 1; else @@ -3212,13 +3316,13 @@ cmd_config_dcb_parsed(void *parsed_result, ret = init_port_dcb_config(port_id, DCB_ENABLED, (enum rte_eth_nb_tcs)res->num_tcs, pfc_en); - - if (ret != 0) { - printf("Cannot initialize network ports.\n"); + fprintf(stderr, "Cannot initialize network ports.\n"); return; } + fwd_config_setup(); + cmd_reconfig_device_queue(port_id, 1, 1); } @@ -3279,7 +3383,7 @@ cmd_config_burst_parsed(void *parsed_result, int ret; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3311,12 +3415,13 @@ cmd_config_burst_parsed(void *parsed_result, rec_nb_pkts); nb_pkt_per_burst = rec_nb_pkts; } else if (res->value > MAX_PKT_BURST) { - printf("burst must be >= 1 && <= %d\n", MAX_PKT_BURST); + fprintf(stderr, "burst must be >= 1 && <= %d\n", + MAX_PKT_BURST); return; } else nb_pkt_per_burst = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3367,7 +3472,7 @@ cmd_config_thresh_parsed(void *parsed_result, struct cmd_config_thresh *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3384,7 +3489,7 @@ cmd_config_thresh_parsed(void *parsed_result, else if(!strcmp(res->name, "rxwt")) rx_wthresh = res->value; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3436,7 +3541,7 @@ cmd_config_threshold_parsed(void *parsed_result, struct cmd_config_threshold *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3447,7 +3552,7 @@ cmd_config_threshold_parsed(void *parsed_result, else if (!strcmp(res->name, "rxfreet")) rx_free_thresh = res->value; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3511,7 +3616,7 @@ cmdline_parse_inst_t cmd_stop = { /* *** SET CORELIST and PORTLIST CONFIGURATION *** */ unsigned int -parse_item_list(char* str, const char* item_name, unsigned int max_items, +parse_item_list(const char *str, const char *item_name, unsigned int max_items, unsigned int *parsed_items, int check_unique_values) { unsigned int nb_item; @@ -3535,11 +3640,11 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, continue; } if (c != ',') { - printf("character %c is not a decimal digit\n", c); + fprintf(stderr, "character %c is not a decimal digit\n", c); return 0; } if (! value_ok) { - printf("No valid value before comma\n"); + fprintf(stderr, "No valid value before comma\n"); return 0; } if (nb_item < max_items) { @@ -3550,8 +3655,8 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, nb_item++; } if (nb_item >= max_items) { - printf("Number of %s = %u > %u (maximum items)\n", - item_name, nb_item + 1, max_items); + fprintf(stderr, "Number of %s = %u > %u (maximum items)\n", + item_name, nb_item + 1, max_items); return 0; } parsed_items[nb_item++] = value; @@ -3559,14 +3664,15 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, return nb_item; /* - * Then, check that all values in the list are differents. + * Then, check that all values in the list are different. * No optimization here... */ for (i = 0; i < nb_item; i++) { for (j = i + 1; j < nb_item; j++) { if (parsed_items[j] == parsed_items[i]) { - printf("duplicated %s %u at index %u and %u\n", - item_name, parsed_items[i], i, j); + fprintf(stderr, + "duplicated %s %u at index %u and %u\n", + item_name, parsed_items[i], i, j); return 0; } } @@ -3592,7 +3698,7 @@ static void cmd_set_list_parsed(void *parsed_result, unsigned int nb_item; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -3655,7 +3761,7 @@ static void cmd_set_mask_parsed(void *parsed_result, struct cmd_setmask_result *res = parsed_result; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } if (!strcmp(res->mask, "coremask")) { @@ -3756,7 +3862,7 @@ cmd_set_log_parsed(void *parsed_result, else { ret = rte_log_set_level_regexp(res->type, res->level); if (ret < 0) - printf("Unable to set log level\n"); + fprintf(stderr, "Unable to set log level\n"); } } @@ -4109,7 +4215,7 @@ cmd_vlan_offload_parsed(void *parsed_result, /* No queue_id, return */ if(i + 1 >= len) { - printf("must specify (port,queue_id)\n"); + fprintf(stderr, "must specify (port,queue_id)\n"); return; } tmp = strtoul(str + i + 1, NULL, 0); @@ -4181,11 +4287,11 @@ cmd_vlan_tpid_parsed(void *parsed_result, enum rte_vlan_type vlan_type; if (!strcmp(res->vlan_type, "inner")) - vlan_type = ETH_VLAN_TYPE_INNER; + vlan_type = RTE_ETH_VLAN_TYPE_INNER; else if (!strcmp(res->vlan_type, "outer")) - vlan_type = ETH_VLAN_TYPE_OUTER; + vlan_type = RTE_ETH_VLAN_TYPE_OUTER; else { - printf("Unknown vlan type\n"); + fprintf(stderr, "Unknown vlan type\n"); return; } vlan_tpid_set(res->port_id, vlan_type, res->tp_id); @@ -4294,7 +4400,7 @@ cmd_tx_vlan_set_parsed(void *parsed_result, return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4351,7 +4457,7 @@ cmd_tx_vlan_set_qinq_parsed(void *parsed_result, return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4467,7 +4573,7 @@ cmd_tx_vlan_reset_parsed(void *parsed_result, return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4520,53 +4626,59 @@ csum_show(int port_id) printf("Parse tunnel is %s\n", (ports[port_id].parse_tunnel) ? "on" : "off"); printf("IP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) ? "hw" : "sw"); printf("UDP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) ? "hw" : "sw"); printf("TCP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) ? "hw" : "sw"); printf("SCTP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_SCTP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) ? "hw" : "sw"); printf("Outer-Ip checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) ? "hw" : "sw"); printf("Outer-Udp checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw"); /* display warnings if configuration is not supported by the NIC */ ret = eth_dev_info_get_print_err(port_id, &dev_info); if (ret != 0) return; - if ((tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) == 0) { - printf("Warning: hardware IP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_CKSUM) == 0) { - printf("Warning: hardware UDP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_CKSUM) == 0) { - printf("Warning: hardware TCP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_SCTP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_SCTP_CKSUM) == 0) { - printf("Warning: hardware SCTP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) == 0) { - printf("Warning: hardware outer IP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware IP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware UDP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware TCP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware SCTP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware outer IP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) == 0) { - printf("Warning: hardware outer UDP checksum enabled but not " - "supported by port %d\n", port_id); + fprintf(stderr, + "Warning: hardware outer UDP checksum enabled but not supported by port %d\n", + port_id); } } @@ -4576,7 +4688,7 @@ cmd_config_queue_tx_offloads(struct rte_port *port) int k; /* Apply queue tx offloads configuration */ - for (k = 0; k < port->dev_info.max_rx_queues; k++) + for (k = 0; k < port->dev_info.max_tx_queues; k++) port->tx_conf[k].offloads = port->dev_conf.txmode.offloads; } @@ -4593,11 +4705,11 @@ cmd_csum_parsed(void *parsed_result, int ret; if (port_id_is_invalid(res->port_id, ENABLED_WARN)) { - printf("invalid port %d\n", res->port_id); + fprintf(stderr, "invalid port %d\n", res->port_id); return; } if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4612,53 +4724,59 @@ cmd_csum_parsed(void *parsed_result, if (!strcmp(res->proto, "ip")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_IPV4_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_IPV4_CKSUM; + RTE_ETH_TX_OFFLOAD_IPV4_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_IPV4_CKSUM; } else { - printf("IP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "IP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "udp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_UDP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_UDP_CKSUM; + RTE_ETH_TX_OFFLOAD_UDP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_UDP_CKSUM; } else { - printf("UDP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "UDP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "tcp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_TCP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_TCP_CKSUM; + RTE_ETH_TX_OFFLOAD_TCP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_TCP_CKSUM; } else { - printf("TCP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "TCP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "sctp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_SCTP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_SCTP_CKSUM; + RTE_ETH_TX_OFFLOAD_SCTP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_SCTP_CKSUM; } else { - printf("SCTP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "SCTP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "outer-ip")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM)) { + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM)) { csum_offloads |= - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM; + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM; } else { - printf("Outer IP checksum offload is not " - "supported by port %u\n", res->port_id); + fprintf(stderr, + "Outer IP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "outer-udp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_OUTER_UDP_CKSUM)) { + RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM)) { csum_offloads |= - DEV_TX_OFFLOAD_OUTER_UDP_CKSUM; + RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM; } else { - printf("Outer UDP checksum offload is not " - "supported by port %u\n", res->port_id); + fprintf(stderr, + "Outer UDP checksum offload is not supported by port %u\n", + res->port_id); } } @@ -4797,7 +4915,7 @@ cmd_tso_set_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4809,19 +4927,19 @@ cmd_tso_set_parsed(void *parsed_result, return; if ((ports[res->port_id].tso_segsz != 0) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) { - printf("Error: TSO is not supported by port %d\n", - res->port_id); + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_TSO) == 0) { + fprintf(stderr, "Error: TSO is not supported by port %d\n", + res->port_id); return; } if (ports[res->port_id].tso_segsz == 0) { ports[res->port_id].dev_conf.txmode.offloads &= - ~DEV_TX_OFFLOAD_TCP_TSO; + ~RTE_ETH_TX_OFFLOAD_TCP_TSO; printf("TSO for non-tunneled packets is disabled\n"); } else { ports[res->port_id].dev_conf.txmode.offloads |= - DEV_TX_OFFLOAD_TCP_TSO; + RTE_ETH_TX_OFFLOAD_TCP_TSO; printf("TSO segment size for non-tunneled packets is %d\n", ports[res->port_id].tso_segsz); } @@ -4833,9 +4951,10 @@ cmd_tso_set_parsed(void *parsed_result, return; if ((ports[res->port_id].tso_segsz != 0) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) { - printf("Warning: TSO enabled but not " - "supported by port %d\n", res->port_id); + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_TSO) == 0) { + fprintf(stderr, + "Warning: TSO enabled but not supported by port %d\n", + res->port_id); } cmd_reconfig_device_queue(res->port_id, 1, 1); @@ -4903,24 +5022,30 @@ check_tunnel_tso_nic_support(portid_t port_id) if (eth_dev_info_get_print_err(port_id, &dev_info) != 0) return dev_info; - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO)) - printf("Warning: VXLAN TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GRE_TNL_TSO)) - printf("Warning: GRE TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPIP_TNL_TSO)) - printf("Warning: IPIP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GENEVE_TNL_TSO)) - printf("Warning: GENEVE TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IP_TNL_TSO)) - printf("Warning: IP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_TNL_TSO)) - printf("Warning: UDP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO)) + fprintf(stderr, + "Warning: VXLAN TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO)) + fprintf(stderr, + "Warning: GRE TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO)) + fprintf(stderr, + "Warning: IPIP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO)) + fprintf(stderr, + "Warning: GENEVE TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IP_TNL_TSO)) + fprintf(stderr, + "Warning: IP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO)) + fprintf(stderr, + "Warning: UDP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); return dev_info; } @@ -4935,7 +5060,7 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4945,20 +5070,20 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, dev_info = check_tunnel_tso_nic_support(res->port_id); if (ports[res->port_id].tunnel_tso_segsz == 0) { ports[res->port_id].dev_conf.txmode.offloads &= - ~(DEV_TX_OFFLOAD_VXLAN_TNL_TSO | - DEV_TX_OFFLOAD_GRE_TNL_TSO | - DEV_TX_OFFLOAD_IPIP_TNL_TSO | - DEV_TX_OFFLOAD_GENEVE_TNL_TSO | - DEV_TX_OFFLOAD_IP_TNL_TSO | - DEV_TX_OFFLOAD_UDP_TNL_TSO); + ~(RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO); printf("TSO for tunneled packets is disabled\n"); } else { - uint64_t tso_offloads = (DEV_TX_OFFLOAD_VXLAN_TNL_TSO | - DEV_TX_OFFLOAD_GRE_TNL_TSO | - DEV_TX_OFFLOAD_IPIP_TNL_TSO | - DEV_TX_OFFLOAD_GENEVE_TNL_TSO | - DEV_TX_OFFLOAD_IP_TNL_TSO | - DEV_TX_OFFLOAD_UDP_TNL_TSO); + uint64_t tso_offloads = (RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO); ports[res->port_id].dev_conf.txmode.offloads |= (tso_offloads & dev_info.tx_offload_capa); @@ -4978,12 +5103,12 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, */ if (!ports[res->port_id].parse_tunnel) - printf("Warning: csum parse_tunnel must be set " - "so that tunneled packets are recognized\n"); + fprintf(stderr, + "Warning: csum parse_tunnel must be set so that tunneled packets are recognized\n"); if (!(ports[res->port_id].dev_conf.txmode.offloads & - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM)) - printf("Warning: csum set outer-ip must be set to hw " - "if outer L3 is IPv4; not necessary for IPv6\n"); + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM)) + fprintf(stderr, + "Warning: csum set outer-ip must be set to hw if outer L3 is IPv4; not necessary for IPv6\n"); } cmd_config_queue_tx_offloads(&ports[res->port_id]); @@ -5036,6 +5161,7 @@ cmdline_parse_inst_t cmd_tunnel_tso_show = { }, }; +#ifdef RTE_LIB_GRO /* *** SET GRO FOR A PORT *** */ struct cmd_gro_enable_result { cmdline_fixed_string_t cmd_set; @@ -5179,7 +5305,9 @@ cmdline_parse_inst_t cmd_gro_flush = { NULL, }, }; +#endif /* RTE_LIB_GRO */ +#ifdef RTE_LIB_GSO /* *** ENABLE/DISABLE GSO *** */ struct cmd_gso_enable_result { cmdline_fixed_string_t cmd_set; @@ -5247,17 +5375,17 @@ cmd_gso_size_parsed(void *parsed_result, struct cmd_gso_size_result *res = parsed_result; if (test_done == 0) { - printf("Before setting GSO segsz, please first" - " stop forwarding\n"); + fprintf(stderr, + "Before setting GSO segsz, please first stop forwarding\n"); return; } if (!strcmp(res->cmd_keyword, "gso") && !strcmp(res->cmd_segsz, "segsz")) { if (res->cmd_size < RTE_GSO_SEG_SIZE_MIN) - printf("gso_size should be larger than %zu." - " Please input a legal value\n", - RTE_GSO_SEG_SIZE_MIN); + fprintf(stderr, + "gso_size should be larger than %zu. Please input a legal value\n", + RTE_GSO_SEG_SIZE_MIN); else gso_max_segment_size = res->cmd_size; } @@ -5305,7 +5433,7 @@ cmd_gso_show_parsed(void *parsed_result, struct cmd_gso_show_result *res = parsed_result; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } if (!strcmp(res->cmd_keyword, "gso")) { @@ -5346,6 +5474,7 @@ cmdline_parse_inst_t cmd_gso_show = { NULL, }, }; +#endif /* RTE_LIB_GSO */ /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ struct cmd_set_flush_rx { @@ -5360,6 +5489,12 @@ cmd_set_flush_rx_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_set_flush_rx *res = parsed_result; + + if (num_procs > 1 && (strcmp(res->mode, "on") == 0)) { + printf("multi-process doesn't support to flush Rx queues.\n"); + return; + } + no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); } @@ -5458,7 +5593,8 @@ cmd_set_bypass_mode_parsed(void *parsed_result, rc = rte_pmd_ixgbe_bypass_state_set(port_id, &bypass_mode); #endif if (rc != 0) - printf("\t Failed to set bypass mode for port = %d.\n", port_id); + fprintf(stderr, "\t Failed to set bypass mode for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbypass_mode_set = @@ -5545,9 +5681,9 @@ cmd_set_bypass_event_parsed(void *parsed_result, bypass_timeout); } if (rc != 0) { - printf("Failed to set timeout value %u " - "for port %d, errto code: %d.\n", - bypass_timeout, port_id, rc); + fprintf(stderr, + "Failed to set timeout value %u for port %d, errto code: %d.\n", + bypass_timeout, port_id, rc); } } @@ -5557,8 +5693,8 @@ cmd_set_bypass_event_parsed(void *parsed_result, #endif if (rc != 0) - printf("\t Failed to set bypass event for port = %d.\n", - port_id); + fprintf(stderr, "\t Failed to set bypass event for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbypass_event_set = @@ -5700,7 +5836,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, /* Display the bypass mode.*/ if (rte_pmd_ixgbe_bypass_state_show(port_id, &bypass_mode) != 0) { - printf("\tFailed to get bypass mode for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get bypass mode for port = %d\n", + port_id); return; } else { @@ -5720,7 +5857,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < RTE_DIM(events); i++) { if (rte_pmd_ixgbe_bypass_event_show(port_id, i, &event_mode)) { - printf("\tFailed to get bypass mode for event = %s\n", + fprintf(stderr, + "\tFailed to get bypass mode for event = %s\n", events[i]); } else { if (!RTE_PMD_IXGBE_BYPASS_MODE_VALID(event_mode)) @@ -5732,7 +5870,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, } #endif if (rc != 0) - printf("\tFailed to get bypass configuration for port = %d\n", + fprintf(stderr, + "\tFailed to get bypass configuration for port = %d\n", port_id); } @@ -5779,10 +5918,24 @@ static void cmd_set_bonding_mode_parsed(void *parsed_result, { struct cmd_set_bonding_mode_result *res = parsed_result; portid_t port_id = res->port_id; + struct rte_port *port = &ports[port_id]; + + /* + * Bonding mode changed means resources of device changed, like whether + * started rte timer or not. Device should be restarted when resources + * of device changed. + */ + if (port->port_status != RTE_PORT_STOPPED) { + fprintf(stderr, + "\t Error: Can't set bonding mode when port %d is not stopped\n", + port_id); + return; + } /* Set the bonding mode for the relevant port. */ if (0 != rte_eth_bond_mode_set(port_id, res->value)) - printf("\t Failed to set bonding mode for port = %d.\n", port_id); + fprintf(stderr, "\t Failed to set bonding mode for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbonding_mode_set = @@ -5838,7 +5991,7 @@ static void cmd_set_bonding_lacp_dedicated_queues_parsed(void *parsed_result, /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -5919,14 +6072,15 @@ static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result, } else if (!strcmp(res->policy, "l34")) { policy = BALANCE_XMIT_POLICY_LAYER34; } else { - printf("\t Invalid xmit policy selection"); + fprintf(stderr, "\t Invalid xmit policy selection"); return; } /* Set the bonding mode for the relevant port. */ if (0 != rte_eth_bond_xmit_policy_set(port_id, policy)) { - printf("\t Failed to set bonding balance xmit policy for port = %d.\n", - port_id); + fprintf(stderr, + "\t Failed to set bonding balance xmit policy for port = %d.\n", + port_id); } } @@ -5962,6 +6116,186 @@ cmdline_parse_inst_t cmd_set_balance_xmit_policy = { } }; +/* *** SHOW IEEE802.3 BONDING INFORMATION *** */ +struct cmd_show_bonding_lacp_info_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t bonding; + cmdline_fixed_string_t lacp; + cmdline_fixed_string_t info; + portid_t port_id; +}; + +static void port_param_show(struct port_params *params) +{ + char buf[RTE_ETHER_ADDR_FMT_SIZE]; + + printf("\t\tsystem priority: %u\n", params->system_priority); + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, ¶ms->system); + printf("\t\tsystem mac address: %s\n", buf); + printf("\t\tport key: %u\n", params->key); + printf("\t\tport priority: %u\n", params->port_priority); + printf("\t\tport number: %u\n", params->port_number); +} + +static void lacp_slave_info_show(struct rte_eth_bond_8023ad_slave_info *info) +{ + char a_state[256] = { 0 }; + char p_state[256] = { 0 }; + int a_len = 0; + int p_len = 0; + uint32_t i; + + static const char * const state[] = { + "ACTIVE", + "TIMEOUT", + "AGGREGATION", + "SYNCHRONIZATION", + "COLLECTING", + "DISTRIBUTING", + "DEFAULTED", + "EXPIRED" + }; + static const char * const selection[] = { + "UNSELECTED", + "STANDBY", + "SELECTED" + }; + + for (i = 0; i < RTE_DIM(state); i++) { + if ((info->actor_state >> i) & 1) + a_len += snprintf(&a_state[a_len], + RTE_DIM(a_state) - a_len, "%s ", + state[i]); + + if ((info->partner_state >> i) & 1) + p_len += snprintf(&p_state[p_len], + RTE_DIM(p_state) - p_len, "%s ", + state[i]); + } + printf("\tAggregator port id: %u\n", info->agg_port_id); + printf("\tselection: %s\n", selection[info->selected]); + printf("\tActor detail info:\n"); + port_param_show(&info->actor); + printf("\t\tport state: %s\n", a_state); + printf("\tPartner detail info:\n"); + port_param_show(&info->partner); + printf("\t\tport state: %s\n", p_state); + printf("\n"); +} + +static void lacp_conf_show(struct rte_eth_bond_8023ad_conf *conf) +{ + printf("\tfast period: %u ms\n", conf->fast_periodic_ms); + printf("\tslow period: %u ms\n", conf->slow_periodic_ms); + printf("\tshort timeout: %u ms\n", conf->short_timeout_ms); + printf("\tlong timeout: %u ms\n", conf->long_timeout_ms); + printf("\taggregate wait timeout: %u ms\n", + conf->aggregate_wait_timeout_ms); + printf("\ttx period: %u ms\n", conf->tx_period_ms); + printf("\trx marker period: %u ms\n", conf->rx_marker_period_ms); + printf("\tupdate timeout: %u ms\n", conf->update_timeout_ms); + switch (conf->agg_selection) { + case AGG_BANDWIDTH: + printf("\taggregation mode: bandwidth\n"); + break; + case AGG_STABLE: + printf("\taggregation mode: stable\n"); + break; + case AGG_COUNT: + printf("\taggregation mode: count\n"); + break; + default: + printf("\taggregation mode: invalid\n"); + break; + } + + printf("\n"); +} + +static void cmd_show_bonding_lacp_info_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_bonding_lacp_info_result *res = parsed_result; + struct rte_eth_bond_8023ad_slave_info slave_info; + struct rte_eth_bond_8023ad_conf port_conf; + portid_t slaves[RTE_MAX_ETHPORTS]; + portid_t port_id = res->port_id; + int num_active_slaves; + int bonding_mode; + int i; + int ret; + + bonding_mode = rte_eth_bond_mode_get(port_id); + if (bonding_mode != BONDING_MODE_8023AD) { + fprintf(stderr, "\tBonding mode is not mode 4\n"); + return; + } + + num_active_slaves = rte_eth_bond_active_slaves_get(port_id, slaves, + RTE_MAX_ETHPORTS); + if (num_active_slaves < 0) { + fprintf(stderr, "\tFailed to get active slave list for port = %u\n", + port_id); + return; + } + if (num_active_slaves == 0) + fprintf(stderr, "\tIEEE802.3 port %u has no active slave\n", + port_id); + + printf("\tIEEE802.3 port: %u\n", port_id); + ret = rte_eth_bond_8023ad_conf_get(port_id, &port_conf); + if (ret) { + fprintf(stderr, "\tGet bonded device %u info failed\n", + port_id); + return; + } + lacp_conf_show(&port_conf); + + for (i = 0; i < num_active_slaves; i++) { + ret = rte_eth_bond_8023ad_slave_info(port_id, slaves[i], + &slave_info); + if (ret) { + fprintf(stderr, "\tGet slave device %u info failed\n", + slaves[i]); + return; + } + printf("\tSlave Port: %u\n", slaves[i]); + lacp_slave_info_show(&slave_info); + } +} + +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_show = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + show, "show"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_bonding = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + bonding, "bonding"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_lacp = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + bonding, "lacp"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_info = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + info, "info"); +cmdline_parse_token_num_t cmd_show_bonding_lacp_info_port_id = +TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + port_id, RTE_UINT16); + +cmdline_parse_inst_t cmd_show_bonding_lacp_info = { + .f = cmd_show_bonding_lacp_info_parsed, + .help_str = "show bonding lacp info : " + "Show bonding IEEE802.3 information for port_id", + .data = NULL, + .tokens = { + (void *)&cmd_show_bonding_lacp_info_show, + (void *)&cmd_show_bonding_lacp_info_bonding, + (void *)&cmd_show_bonding_lacp_info_lacp, + (void *)&cmd_show_bonding_lacp_info_info, + (void *)&cmd_show_bonding_lacp_info_port_id, + NULL + } +}; + /* *** SHOW NIC BONDING CONFIGURATION *** */ struct cmd_show_bonding_config_result { cmdline_fixed_string_t show; @@ -5985,18 +6319,21 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, /* Display the bonding mode.*/ bonding_mode = rte_eth_bond_mode_get(port_id); if (bonding_mode < 0) { - printf("\tFailed to get bonding mode for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get bonding mode for port = %d\n", + port_id); return; } else printf("\tBonding mode: %d\n", bonding_mode); - if (bonding_mode == BONDING_MODE_BALANCE) { + if (bonding_mode == BONDING_MODE_BALANCE || + bonding_mode == BONDING_MODE_8023AD) { int balance_xmit_policy; balance_xmit_policy = rte_eth_bond_xmit_policy_get(port_id); if (balance_xmit_policy < 0) { - printf("\tFailed to get balance xmit policy for port = %d\n", - port_id); + fprintf(stderr, + "\tFailed to get balance xmit policy for port = %d\n", + port_id); return; } else { printf("\tBalance Xmit Policy: "); @@ -6036,7 +6373,8 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, num_slaves = rte_eth_bond_slaves_get(port_id, slaves, RTE_MAX_ETHPORTS); if (num_slaves < 0) { - printf("\tFailed to get slave list for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get slave list for port = %d\n", + port_id); return; } if (num_slaves > 0) { @@ -6054,7 +6392,9 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, RTE_MAX_ETHPORTS); if (num_active_slaves < 0) { - printf("\tFailed to get active slave list for port = %d\n", port_id); + fprintf(stderr, + "\tFailed to get active slave list for port = %d\n", + port_id); return; } if (num_active_slaves > 0) { @@ -6071,7 +6411,8 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, primary_id = rte_eth_bond_primary_get(port_id); if (primary_id < 0) { - printf("\tFailed to get primary slave for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get primary slave for port = %d\n", + port_id); return; } else printf("\tPrimary: [%d]\n", primary_id); @@ -6124,8 +6465,8 @@ static void cmd_set_bonding_primary_parsed(void *parsed_result, /* Set the primary slave for a bonded device. */ if (0 != rte_eth_bond_primary_set(master_port_id, slave_port_id)) { - printf("\t Failed to set primary slave for port = %d.\n", - master_port_id); + fprintf(stderr, "\t Failed to set primary slave for port = %d.\n", + master_port_id); return; } init_port_config(); @@ -6181,8 +6522,9 @@ static void cmd_add_bonding_slave_parsed(void *parsed_result, /* add the slave for a bonded device. */ if (0 != rte_eth_bond_slave_add(master_port_id, slave_port_id)) { - printf("\t Failed to add slave %d to master port = %d.\n", - slave_port_id, master_port_id); + fprintf(stderr, + "\t Failed to add slave %d to master port = %d.\n", + slave_port_id, master_port_id); return; } init_port_config(); @@ -6239,8 +6581,9 @@ static void cmd_remove_bonding_slave_parsed(void *parsed_result, /* remove the slave from a bonded device. */ if (0 != rte_eth_bond_slave_remove(master_port_id, slave_port_id)) { - printf("\t Failed to remove slave %d from master port = %d.\n", - slave_port_id, master_port_id); + fprintf(stderr, + "\t Failed to remove slave %d from master port = %d.\n", + slave_port_id, master_port_id); return; } init_port_config(); @@ -6299,7 +6642,7 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, int ret; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -6309,7 +6652,7 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, /* Create a new bonded device. */ port_id = rte_eth_bond_create(ethdev_name, res->mode, res->socket); if (port_id < 0) { - printf("\t Failed to create bonded device.\n"); + fprintf(stderr, "\t Failed to create bonded device.\n"); return; } else { printf("Created new bonded device %s on (port %d).\n", ethdev_name, @@ -6320,9 +6663,11 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, reconfig(port_id, res->socket); ret = rte_eth_promiscuous_enable(port_id); if (ret != 0) - printf("Failed to enable promiscuous mode for port %u: %s - ignore\n", + fprintf(stderr, + "Failed to enable promiscuous mode for port %u: %s - ignore\n", port_id, rte_strerror(-ret)); + ports[port_id].bond_flag = 1; ports[port_id].need_setup = 0; ports[port_id].port_status = RTE_PORT_STOPPED; } @@ -6383,7 +6728,8 @@ static void cmd_set_bond_mac_addr_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if (ret < 0) - printf("set_bond_mac_addr error: (%s)\n", strerror(-ret)); + fprintf(stderr, "set_bond_mac_addr error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_set_bond_mac_addr_set = @@ -6435,7 +6781,8 @@ static void cmd_set_bond_mon_period_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if (ret < 0) - printf("set_bond_mac_addr error: (%s)\n", strerror(-ret)); + fprintf(stderr, "set_bond_mac_addr error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_set_bond_mon_period_set = @@ -6869,6 +7216,81 @@ cmdline_parse_inst_t cmd_set_allmulti_mode_one = { }, }; +/* *** GET CURRENT ETHERNET LINK FLOW CONTROL *** */ +struct cmd_link_flow_ctrl_show { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + portid_t port_id; + cmdline_fixed_string_t flow_ctrl; +}; + +cmdline_parse_token_string_t cmd_lfc_show_show = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + show, "show"); +cmdline_parse_token_string_t cmd_lfc_show_port = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + port, "port"); +cmdline_parse_token_num_t cmd_lfc_show_portid = + TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_show, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_lfc_show_flow_ctrl = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + flow_ctrl, "flow_ctrl"); + +static void +cmd_link_flow_ctrl_show_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_link_flow_ctrl_show *res = parsed_result; + static const char *info_border = "*********************"; + struct rte_eth_fc_conf fc_conf; + bool rx_fc_en = false; + bool tx_fc_en = false; + int ret; + + ret = rte_eth_dev_flow_ctrl_get(res->port_id, &fc_conf); + if (ret != 0) { + fprintf(stderr, + "Failed to get current flow ctrl information: err = %d\n", + ret); + return; + } + + if (fc_conf.mode == RTE_ETH_FC_RX_PAUSE || fc_conf.mode == RTE_ETH_FC_FULL) + rx_fc_en = true; + if (fc_conf.mode == RTE_ETH_FC_TX_PAUSE || fc_conf.mode == RTE_ETH_FC_FULL) + tx_fc_en = true; + + printf("\n%s Flow control infos for port %-2d %s\n", + info_border, res->port_id, info_border); + printf("FC mode:\n"); + printf(" Rx pause: %s\n", rx_fc_en ? "on" : "off"); + printf(" Tx pause: %s\n", tx_fc_en ? "on" : "off"); + printf("Autoneg: %s\n", fc_conf.autoneg ? "on" : "off"); + printf("Pause time: 0x%x\n", fc_conf.pause_time); + printf("High waterline: 0x%x\n", fc_conf.high_water); + printf("Low waterline: 0x%x\n", fc_conf.low_water); + printf("Send XON: %s\n", fc_conf.send_xon ? "on" : "off"); + printf("Forward MAC control frames: %s\n", + fc_conf.mac_ctrl_frame_fwd ? "on" : "off"); + printf("\n%s************** End ***********%s\n", + info_border, info_border); +} + +cmdline_parse_inst_t cmd_link_flow_control_show = { + .f = cmd_link_flow_ctrl_show_parsed, + .data = NULL, + .help_str = "show port flow_ctrl", + .tokens = { + (void *)&cmd_lfc_show_show, + (void *)&cmd_lfc_show_port, + (void *)&cmd_lfc_show_portid, + (void *)&cmd_lfc_show_flow_ctrl, + NULL, + }, +}; + /* *** SETUP ETHERNET LINK FLOW CONTROL *** */ struct cmd_link_flow_ctrl_set_result { cmdline_fixed_string_t set; @@ -7115,28 +7537,29 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, /* * 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. + * the RTE_ETH_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. + * the RTE_ETH_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_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} }; /* Partial command line, retrieve current configuration */ if (cmd) { ret = rte_eth_dev_flow_ctrl_get(res->port_id, &fc_conf); if (ret != 0) { - printf("cannot get current flow ctrl parameters, return" - "code = %d\n", ret); + fprintf(stderr, + "cannot get current flow ctrl parameters, return code = %d\n", + ret); return; } - if ((fc_conf.mode == RTE_FC_RX_PAUSE) || - (fc_conf.mode == RTE_FC_FULL)) + if ((fc_conf.mode == RTE_ETH_FC_RX_PAUSE) || + (fc_conf.mode == RTE_ETH_FC_FULL)) rx_fc_en = 1; - if ((fc_conf.mode == RTE_FC_TX_PAUSE) || - (fc_conf.mode == RTE_FC_FULL)) + if ((fc_conf.mode == RTE_ETH_FC_TX_PAUSE) || + (fc_conf.mode == RTE_ETH_FC_FULL)) tx_fc_en = 1; } @@ -7172,7 +7595,9 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, ret = rte_eth_dev_flow_ctrl_set(res->port_id, &fc_conf); if (ret != 0) - printf("bad flow contrl parameter, return code = %d \n", ret); + fprintf(stderr, + "bad flow control parameter, return code = %d\n", + ret); } /* *** SETUP ETHERNET PRIORITY FLOW CONTROL *** */ @@ -7202,12 +7627,12 @@ cmd_priority_flow_ctrl_set_parsed(void *parsed_result, /* * 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. + * the RTE_ETH_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. + * the RTE_ETH_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_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} }; memset(&pfc_conf, 0, sizeof(struct rte_eth_pfc_conf)); @@ -7221,7 +7646,9 @@ cmd_priority_flow_ctrl_set_parsed(void *parsed_result, 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); + fprintf(stderr, + "bad priority flow control parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_pfc_set_set = @@ -7280,6 +7707,122 @@ cmdline_parse_inst_t cmd_priority_flow_control_set = { }, }; +struct cmd_queue_priority_flow_ctrl_set_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t pfc_queue_ctrl; + portid_t port_id; + cmdline_fixed_string_t rx; + cmdline_fixed_string_t rx_pfc_mode; + uint16_t tx_qid; + uint8_t tx_tc; + cmdline_fixed_string_t tx; + cmdline_fixed_string_t tx_pfc_mode; + uint16_t rx_qid; + uint8_t rx_tc; + uint16_t pause_time; +}; + +static void +cmd_queue_priority_flow_ctrl_set_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_queue_priority_flow_ctrl_set_result *res = parsed_result; + struct rte_eth_pfc_queue_conf pfc_queue_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_ETH_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_ETH_FC_RX_PAUSE, Respond to the pause frame at + * the Tx side. + */ + static enum rte_eth_fc_mode rx_tx_onoff_2_mode[2][2] = { + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, + {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} + }; + + memset(&pfc_queue_conf, 0, sizeof(struct rte_eth_pfc_queue_conf)); + 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_queue_conf.mode = rx_tx_onoff_2_mode[rx_fc_enable][tx_fc_enable]; + pfc_queue_conf.rx_pause.tc = res->tx_tc; + pfc_queue_conf.rx_pause.tx_qid = res->tx_qid; + pfc_queue_conf.tx_pause.tc = res->rx_tc; + pfc_queue_conf.tx_pause.rx_qid = res->rx_qid; + pfc_queue_conf.tx_pause.pause_time = res->pause_time; + + ret = rte_eth_dev_priority_flow_ctrl_queue_configure(res->port_id, + &pfc_queue_conf); + if (ret != 0) { + fprintf(stderr, + "bad queue priority flow control parameter, rc = %d\n", + ret); + } +} + +cmdline_parse_token_string_t cmd_q_pfc_set_set = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + set, "set"); +cmdline_parse_token_string_t cmd_q_pfc_set_flow_ctrl = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + pfc_queue_ctrl, "pfc_queue_ctrl"); +cmdline_parse_token_num_t cmd_q_pfc_set_portid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_q_pfc_set_rx = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx, "rx"); +cmdline_parse_token_string_t cmd_q_pfc_set_rx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_pfc_mode, "on#off"); +cmdline_parse_token_num_t cmd_q_pfc_set_tx_qid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_qid, RTE_UINT16); +cmdline_parse_token_num_t cmd_q_pfc_set_tx_tc = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_tc, RTE_UINT8); +cmdline_parse_token_string_t cmd_q_pfc_set_tx = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx, "tx"); +cmdline_parse_token_string_t cmd_q_pfc_set_tx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_pfc_mode, "on#off"); +cmdline_parse_token_num_t cmd_q_pfc_set_rx_qid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_qid, RTE_UINT16); +cmdline_parse_token_num_t cmd_q_pfc_set_rx_tc = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_tc, RTE_UINT8); +cmdline_parse_token_num_t cmd_q_pfc_set_pause_time = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + pause_time, RTE_UINT16); + +cmdline_parse_inst_t cmd_queue_priority_flow_control_set = { + .f = cmd_queue_priority_flow_ctrl_set_parsed, + .data = NULL, + .help_str = "set pfc_queue_ctrl rx " + "tx : " + "Configure the Ethernet queue priority flow control", + .tokens = { + (void *)&cmd_q_pfc_set_set, + (void *)&cmd_q_pfc_set_flow_ctrl, + (void *)&cmd_q_pfc_set_portid, + (void *)&cmd_q_pfc_set_rx, + (void *)&cmd_q_pfc_set_rx_mode, + (void *)&cmd_q_pfc_set_tx_qid, + (void *)&cmd_q_pfc_set_tx_tc, + (void *)&cmd_q_pfc_set_tx, + (void *)&cmd_q_pfc_set_tx_mode, + (void *)&cmd_q_pfc_set_rx_qid, + (void *)&cmd_q_pfc_set_rx_tc, + (void *)&cmd_q_pfc_set_pause_time, + NULL, + }, +}; + /* *** RESET CONFIGURATION *** */ struct cmd_reset_result { cmdline_fixed_string_t reset; @@ -7670,6 +8213,137 @@ cmdline_parse_inst_t cmd_showport = { }, }; +/* *** show port representors information *** */ +struct cmd_representor_info_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_info; + cmdline_fixed_string_t cmd_keyword; + portid_t cmd_pid; +}; + +static void +cmd_representor_info_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_representor_info_result *res = parsed_result; + struct rte_eth_representor_info *info; + struct rte_eth_representor_range *range; + uint32_t range_diff; + uint32_t i; + int ret; + int num; + + if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); + return; + } + + ret = rte_eth_representor_info_get(res->cmd_pid, NULL); + if (ret < 0) { + fprintf(stderr, + "Failed to get the number of representor info ranges for port %hu: %s\n", + res->cmd_pid, rte_strerror(-ret)); + return; + } + num = ret; + + info = calloc(1, sizeof(*info) + num * sizeof(info->ranges[0])); + if (info == NULL) { + fprintf(stderr, + "Failed to allocate memory for representor info for port %hu\n", + res->cmd_pid); + return; + } + info->nb_ranges_alloc = num; + + ret = rte_eth_representor_info_get(res->cmd_pid, info); + if (ret < 0) { + fprintf(stderr, + "Failed to get the representor info for port %hu: %s\n", + res->cmd_pid, rte_strerror(-ret)); + free(info); + return; + } + + printf("Port controller: %hu\n", info->controller); + printf("Port PF: %hu\n", info->pf); + + printf("Ranges: %u\n", info->nb_ranges); + for (i = 0; i < info->nb_ranges; i++) { + range = &info->ranges[i]; + range_diff = range->id_end - range->id_base; + + printf("%u. ", i + 1); + printf("'%s' ", range->name); + if (range_diff > 0) + printf("[%u-%u]: ", range->id_base, range->id_end); + else + printf("[%u]: ", range->id_base); + + printf("Controller %d, PF %d", range->controller, range->pf); + + switch (range->type) { + case RTE_ETH_REPRESENTOR_NONE: + printf(", NONE\n"); + break; + case RTE_ETH_REPRESENTOR_VF: + if (range_diff > 0) + printf(", VF %d..%d\n", range->vf, + range->vf + range_diff); + else + printf(", VF %d\n", range->vf); + break; + case RTE_ETH_REPRESENTOR_SF: + printf(", SF %d\n", range->sf); + break; + case RTE_ETH_REPRESENTOR_PF: + if (range_diff > 0) + printf("..%d\n", range->pf + range_diff); + else + printf("\n"); + break; + default: + printf(", UNKNOWN TYPE %d\n", range->type); + break; + } + } + + free(info); +} + +cmdline_parse_token_string_t cmd_representor_info_show = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_show, "show"); +cmdline_parse_token_string_t cmd_representor_info_port = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_port, "port"); +cmdline_parse_token_string_t cmd_representor_info_info = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_info, "info"); +cmdline_parse_token_num_t cmd_representor_info_pid = + TOKEN_NUM_INITIALIZER(struct cmd_representor_info_result, + cmd_pid, RTE_UINT16); +cmdline_parse_token_string_t cmd_representor_info_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_keyword, "representor"); + +cmdline_parse_inst_t cmd_representor_info = { + .f = cmd_representor_info_parsed, + .data = NULL, + .help_str = "show port info representor", + .tokens = { + (void *)&cmd_representor_info_show, + (void *)&cmd_representor_info_port, + (void *)&cmd_representor_info_info, + (void *)&cmd_representor_info_pid, + (void *)&cmd_representor_info_keyword, + NULL, + }, +}; + + /* *** SHOW DEVICE INFO *** */ struct cmd_showdevice_result { cmdline_fixed_string_t show; @@ -7735,7 +8409,7 @@ static void cmd_showeeprom_parsed(void *parsed_result, else if (!strcmp(res->type, "module_eeprom")) port_module_eeprom_display(res->portnum); else - printf("Unknown argument\n"); + fprintf(stderr, "Unknown argument\n"); } cmdline_parse_token_string_t cmd_showeeprom_show = @@ -8253,7 +8927,7 @@ static void cmd_mac_addr_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if(ret < 0) - printf("mac_addr_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "mac_addr_cmd error: (%s)\n", strerror(-ret)); } @@ -8298,7 +8972,7 @@ static void cmd_set_eth_peer_parsed(void *parsed_result, struct cmd_eth_peer_result *res = parsed_result; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } if (!strcmp(res->eth_peer, "eth-peer")) { @@ -8535,7 +9209,9 @@ cmd_set_uc_hash_parsed(void *parsed_result, ret = rte_eth_dev_uc_hash_table_set(res->port_id, &res->address,(uint8_t)is_on); if (ret < 0) - printf("bad unicast hash table parameter, return code = %d \n", ret); + fprintf(stderr, + "bad unicast hash table parameter, return code = %d\n", + ret); } @@ -8596,8 +9272,9 @@ cmd_set_uc_all_hash_parsed(void *parsed_result, (strcmp(res->value, "all") == 0)) ret = rte_eth_dev_uc_all_hash_table_set(res->port_id,(uint8_t) is_on); if (ret < 0) - printf("bad unicast hash table parameter," - "return code = %d \n", ret); + fprintf(stderr, + "bad unicast hash table parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_set_uc_all_hash_set = @@ -8719,16 +9396,17 @@ cmd_set_vf_rxmode_parsed(void *parsed_result, int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0; if (!strcmp(res->what,"rxmode")) { if (!strcmp(res->mode, "AUPE")) - vf_rxmode |= ETH_VMDQ_ACCEPT_UNTAG; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_UNTAG; else if (!strcmp(res->mode, "ROPE")) - vf_rxmode |= ETH_VMDQ_ACCEPT_HASH_UC; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_HASH_UC; else if (!strcmp(res->mode, "BAM")) - vf_rxmode |= ETH_VMDQ_ACCEPT_BROADCAST; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_BROADCAST; else if (!strncmp(res->mode, "MPE",3)) - vf_rxmode |= ETH_VMDQ_ACCEPT_MULTICAST; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_MULTICAST; } RTE_SET_USED(is_on); + RTE_SET_USED(vf_rxmode); #ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) @@ -8741,8 +9419,9 @@ cmd_set_vf_rxmode_parsed(void *parsed_result, vf_rxmode, (uint8_t)is_on); #endif if (ret < 0) - printf("bad VF receive mode parameter, return code = %d \n", - ret); + fprintf(stderr, + "bad VF receive mode parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_set_vf_rxmode_set = @@ -8821,7 +9500,7 @@ static void cmd_vf_mac_addr_parsed(void *parsed_result, #endif if(ret < 0) - printf("vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); } @@ -8905,17 +9584,17 @@ cmd_vf_rx_vlan_filter_parsed(void *parsed_result, case 0: break; case -EINVAL: - printf("invalid vlan_id %d or vf_mask %"PRIu64"\n", - res->vlan_id, res->vf_mask); + fprintf(stderr, "invalid vlan_id %d or vf_mask %"PRIu64"\n", + res->vlan_id, res->vf_mask); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -8982,7 +9661,8 @@ static void cmd_queue_rate_limit_parsed(void *parsed_result, ret = set_queue_rate_limit(res->port_num, res->queue_num, res->rate_num); if (ret < 0) - printf("queue_rate_limit_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "queue_rate_limit_cmd error: (%s)\n", + strerror(-ret)); } @@ -9052,7 +9732,8 @@ static void cmd_vf_rate_limit_parsed(void *parsed_result, ret = set_vf_rate_limit(res->port_num, res->vf_num, res->rate_num, res->q_msk_val); if (ret < 0) - printf("vf_rate_limit_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "vf_rate_limit_cmd error: (%s)\n", + strerror(-ret)); } @@ -9122,7 +9803,7 @@ cmd_tunnel_udp_config_parsed(void *parsed_result, int ret; tunnel_udp.udp_port = res->udp_port; - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN; if (!strcmp(res->what, "add")) ret = rte_eth_dev_udp_tunnel_port_add(res->port_id, @@ -9132,7 +9813,8 @@ cmd_tunnel_udp_config_parsed(void *parsed_result, &tunnel_udp); if (ret < 0) - printf("udp tunneling add error: (%s)\n", strerror(-ret)); + fprintf(stderr, "udp tunneling add error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_tunnel_udp_config_rx_vxlan_port = @@ -9187,15 +9869,15 @@ cmd_cfg_tunnel_udp_port_parsed(void *parsed_result, tunnel_udp.udp_port = res->udp_port; if (!strcmp(res->tunnel_type, "vxlan")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN; } else if (!strcmp(res->tunnel_type, "geneve")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_GENEVE; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_GENEVE; } else if (!strcmp(res->tunnel_type, "vxlan-gpe")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN_GPE; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN_GPE; } else if (!strcmp(res->tunnel_type, "ecpri")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_ECPRI; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_ECPRI; } else { - printf("Invalid tunnel type\n"); + fprintf(stderr, "Invalid tunnel type\n"); return; } @@ -9207,7 +9889,8 @@ cmd_cfg_tunnel_udp_port_parsed(void *parsed_result, &tunnel_udp); if (ret < 0) - printf("udp tunneling port add error: (%s)\n", strerror(-ret)); + fprintf(stderr, "udp tunneling port add error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_config_tunnel_udp_port_port = @@ -9250,264 +9933,6 @@ cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = { }, }; -/* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */ -struct cmd_set_mirror_mask_result { - cmdline_fixed_string_t set; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; - cmdline_fixed_string_t what; - cmdline_fixed_string_t value; - cmdline_fixed_string_t dstpool; - uint8_t dstpool_id; - cmdline_fixed_string_t on; -}; - -cmdline_parse_token_string_t cmd_mirror_mask_set = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - set, "set"); -cmdline_parse_token_string_t cmd_mirror_mask_port = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - port, "port"); -cmdline_parse_token_num_t cmd_mirror_mask_portid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, - port_id, RTE_UINT16); -cmdline_parse_token_string_t cmd_mirror_mask_mirror = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - mirror, "mirror-rule"); -cmdline_parse_token_num_t cmd_mirror_mask_ruleid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, - rule_id, RTE_UINT8); -cmdline_parse_token_string_t cmd_mirror_mask_what = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - what, "pool-mirror-up#pool-mirror-down" - "#vlan-mirror"); -cmdline_parse_token_string_t cmd_mirror_mask_value = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - value, NULL); -cmdline_parse_token_string_t cmd_mirror_mask_dstpool = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - dstpool, "dst-pool"); -cmdline_parse_token_num_t cmd_mirror_mask_poolid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, - dstpool_id, RTE_UINT8); -cmdline_parse_token_string_t cmd_mirror_mask_on = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - on, "on#off"); - -static void -cmd_set_mirror_mask_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret,nb_item,i; - struct cmd_set_mirror_mask_result *res = parsed_result; - struct rte_eth_mirror_conf mr_conf; - - memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); - - unsigned int vlan_list[ETH_MIRROR_MAX_VLANS]; - - mr_conf.dst_pool = res->dstpool_id; - - if (!strcmp(res->what, "pool-mirror-up")) { - mr_conf.pool_mask = strtoull(res->value, NULL, 16); - mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_UP; - } else if (!strcmp(res->what, "pool-mirror-down")) { - mr_conf.pool_mask = strtoull(res->value, NULL, 16); - mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_DOWN; - } else if (!strcmp(res->what, "vlan-mirror")) { - mr_conf.rule_type = ETH_MIRROR_VLAN; - nb_item = parse_item_list(res->value, "vlan", - ETH_MIRROR_MAX_VLANS, vlan_list, 1); - if (nb_item <= 0) - return; - - for (i = 0; i < nb_item; i++) { - if (vlan_list[i] > RTE_ETHER_MAX_VLAN_ID) { - printf("Invalid vlan_id: must be < 4096\n"); - return; - } - - mr_conf.vlan.vlan_id[i] = (uint16_t)vlan_list[i]; - mr_conf.vlan.vlan_mask |= 1ULL << i; - } - } - - if (!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 1); - else - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 0); - if (ret < 0) - printf("mirror rule add error: (%s)\n", strerror(-ret)); -} - -cmdline_parse_inst_t cmd_set_mirror_mask = { - .f = cmd_set_mirror_mask_parsed, - .data = NULL, - .help_str = "set port mirror-rule " - "pool-mirror-up|pool-mirror-down|vlan-mirror " - " dst-pool on|off", - .tokens = { - (void *)&cmd_mirror_mask_set, - (void *)&cmd_mirror_mask_port, - (void *)&cmd_mirror_mask_portid, - (void *)&cmd_mirror_mask_mirror, - (void *)&cmd_mirror_mask_ruleid, - (void *)&cmd_mirror_mask_what, - (void *)&cmd_mirror_mask_value, - (void *)&cmd_mirror_mask_dstpool, - (void *)&cmd_mirror_mask_poolid, - (void *)&cmd_mirror_mask_on, - NULL, - }, -}; - -/* *** CONFIGURE VM MIRROR UPLINK/DOWNLINK RULE *** */ -struct cmd_set_mirror_link_result { - cmdline_fixed_string_t set; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; - cmdline_fixed_string_t what; - cmdline_fixed_string_t dstpool; - uint8_t dstpool_id; - cmdline_fixed_string_t on; -}; - -cmdline_parse_token_string_t cmd_mirror_link_set = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - set, "set"); -cmdline_parse_token_string_t cmd_mirror_link_port = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - port, "port"); -cmdline_parse_token_num_t cmd_mirror_link_portid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, - port_id, RTE_UINT16); -cmdline_parse_token_string_t cmd_mirror_link_mirror = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - mirror, "mirror-rule"); -cmdline_parse_token_num_t cmd_mirror_link_ruleid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, - rule_id, RTE_UINT8); -cmdline_parse_token_string_t cmd_mirror_link_what = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - what, "uplink-mirror#downlink-mirror"); -cmdline_parse_token_string_t cmd_mirror_link_dstpool = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - dstpool, "dst-pool"); -cmdline_parse_token_num_t cmd_mirror_link_poolid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, - dstpool_id, RTE_UINT8); -cmdline_parse_token_string_t cmd_mirror_link_on = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - on, "on#off"); - -static void -cmd_set_mirror_link_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret; - struct cmd_set_mirror_link_result *res = parsed_result; - struct rte_eth_mirror_conf mr_conf; - - memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); - if (!strcmp(res->what, "uplink-mirror")) - mr_conf.rule_type = ETH_MIRROR_UPLINK_PORT; - else - mr_conf.rule_type = ETH_MIRROR_DOWNLINK_PORT; - - mr_conf.dst_pool = res->dstpool_id; - - if (!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 1); - else - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 0); - - /* check the return value and print it if is < 0 */ - if (ret < 0) - printf("mirror rule add error: (%s)\n", strerror(-ret)); - -} - -cmdline_parse_inst_t cmd_set_mirror_link = { - .f = cmd_set_mirror_link_parsed, - .data = NULL, - .help_str = "set port mirror-rule " - "uplink-mirror|downlink-mirror dst-pool on|off", - .tokens = { - (void *)&cmd_mirror_link_set, - (void *)&cmd_mirror_link_port, - (void *)&cmd_mirror_link_portid, - (void *)&cmd_mirror_link_mirror, - (void *)&cmd_mirror_link_ruleid, - (void *)&cmd_mirror_link_what, - (void *)&cmd_mirror_link_dstpool, - (void *)&cmd_mirror_link_poolid, - (void *)&cmd_mirror_link_on, - NULL, - }, -}; - -/* *** RESET VM MIRROR RULE *** */ -struct cmd_rm_mirror_rule_result { - cmdline_fixed_string_t reset; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; -}; - -cmdline_parse_token_string_t cmd_rm_mirror_rule_reset = - TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, - reset, "reset"); -cmdline_parse_token_string_t cmd_rm_mirror_rule_port = - TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, - port, "port"); -cmdline_parse_token_num_t cmd_rm_mirror_rule_portid = - TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, - port_id, RTE_UINT16); -cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror = - TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, - mirror, "mirror-rule"); -cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid = - TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, - rule_id, RTE_UINT8); - -static void -cmd_reset_mirror_rule_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret; - struct cmd_set_mirror_link_result *res = parsed_result; - /* check rule_id */ - ret = rte_eth_mirror_rule_reset(res->port_id,res->rule_id); - if(ret < 0) - printf("mirror rule remove error: (%s)\n", strerror(-ret)); -} - -cmdline_parse_inst_t cmd_reset_mirror_rule = { - .f = cmd_reset_mirror_rule_parsed, - .data = NULL, - .help_str = "reset port mirror-rule ", - .tokens = { - (void *)&cmd_rm_mirror_rule_reset, - (void *)&cmd_rm_mirror_rule_port, - (void *)&cmd_rm_mirror_rule_portid, - (void *)&cmd_rm_mirror_rule_mirror, - (void *)&cmd_rm_mirror_rule_ruleid, - NULL, - }, -}; - /* ******************************************************************************** */ struct cmd_dump_result { @@ -9563,7 +9988,7 @@ dump_socket_mem(FILE *f) fprintf(f, "Total : size(M) total: %.6lf alloc: %.6lf(%.3lf%%) free: %.6lf \tcount alloc: %-4u free: %u\n", (double)total / (1024 * 1024), (double)alloc / (1024 * 1024), - (double)alloc * 100 / (double)total, + total ? ((double)alloc * 100 / (double)total) : 0, (double)free / (1024 * 1024), n_alloc, n_free); if (last_allocs) @@ -9712,10 +10137,11 @@ cmd_queue_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config error: (%s)\n", strerror(-ret)); + fprintf(stderr, "queue region config error: (%s)\n", + strerror(-ret)); } } @@ -9811,10 +10237,11 @@ cmd_region_flowtype_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("region flowtype config error: (%s)\n", strerror(-ret)); + fprintf(stderr, "region flowtype config error: (%s)\n", + strerror(-ret)); } } @@ -9901,11 +10328,11 @@ cmd_user_priority_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("user_priority region config error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "user_priority region config error: (%s)\n", + strerror(-ret)); } } @@ -9994,11 +10421,11 @@ cmd_flush_queue_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config flush error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "queue region config flush error: (%s)\n", + strerror(-ret)); } } @@ -10075,11 +10502,11 @@ cmd_show_queue_region_info_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config info show error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "queue region config info show error: (%s)\n", + strerror(-ret)); } } @@ -10117,7 +10544,7 @@ do { \ if ((ip_addr).family == AF_INET) \ (ip) = (ip_addr).addr.ipv4.s_addr; \ else { \ - printf("invalid parameter.\n"); \ + fprintf(stderr, "invalid parameter.\n"); \ return; \ } \ } while (0) @@ -10129,7 +10556,7 @@ do { \ &((ip_addr).addr.ipv6), \ sizeof(struct in6_addr)); \ else { \ - printf("invalid parameter.\n"); \ + fprintf(stderr, "invalid parameter.\n"); \ return; \ } \ } while (0) @@ -10158,6 +10585,10 @@ str2flowtype(char *string) {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP}, {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER}, {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD}, + {"ipv6-ex", RTE_ETH_FLOW_IPV6_EX}, + {"ipv6-tcp-ex", RTE_ETH_FLOW_IPV6_TCP_EX}, + {"ipv6-udp-ex", RTE_ETH_FLOW_IPV6_UDP_EX}, + {"gtpu", RTE_ETH_FLOW_GTPU}, }; for (i = 0; i < RTE_DIM(flowtype_str); i++) { @@ -10206,7 +10637,7 @@ cmd_flow_director_filter_parsed(void *parsed_result, memset(&conf, 0, sizeof(conf)); if (flow_type == RTE_ETH_FLOW_UNKNOWN) { - printf("Invalid flow type specified.\n"); + fprintf(stderr, "Invalid flow type specified.\n"); return; } ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, @@ -10214,7 +10645,7 @@ cmd_flow_director_filter_parsed(void *parsed_result, if (ret) return; if (mapping[flow_type].pctype == 0ULL) { - printf("Invalid flow type specified.\n"); + fprintf(stderr, "Invalid flow type specified.\n"); return; } for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) { @@ -10243,8 +10674,8 @@ cmd_flow_director_filter_parsed(void *parsed_result, &conf, add); if (ret < 0) - printf("flow director config error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "flow director config error: (%s)\n", + strerror(-ret)); close_file(conf.input.packet); } @@ -10354,7 +10785,7 @@ cmd_flow_director_mask_parsed(void *parsed_result, port = &ports[res->port_id]; /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -10362,14 +10793,14 @@ cmd_flow_director_mask_parsed(void *parsed_result, if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) { if (strcmp(res->mode_value, "MAC-VLAN")) { - printf("Please set mode to MAC-VLAN.\n"); + fprintf(stderr, "Please set mode to MAC-VLAN.\n"); return; } mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { if (strcmp(res->mode_value, "Tunnel")) { - printf("Please set mode to Tunnel.\n"); + fprintf(stderr, "Please set mode to Tunnel.\n"); return; } @@ -10379,7 +10810,7 @@ cmd_flow_director_mask_parsed(void *parsed_result, mask->tunnel_type_mask = res->tunnel_type_mask; } else { if (strcmp(res->mode_value, "IP")) { - printf("Please set mode to IP.\n"); + fprintf(stderr, "Please set mode to IP.\n"); return; } @@ -10584,7 +11015,7 @@ cmd_flow_director_flxpld_parsed(void *parsed_result, port = &ports[res->port_id]; /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -10602,7 +11033,7 @@ cmd_flow_director_flxpld_parsed(void *parsed_result, ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset, RTE_ETH_FDIR_MAX_FLEXLEN); if (ret < 0) { - printf("error: Cannot parse flex payload input.\n"); + fprintf(stderr, "error: Cannot parse flex payload input.\n"); return; } @@ -10656,10 +11087,9 @@ static void cmd_mcast_addr_parsed(void *parsed_result, struct cmd_mcast_addr_result *res = parsed_result; if (!rte_is_multicast_ether_addr(&res->mc_addr)) { - printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n", - res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1], - res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3], - res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]); + fprintf(stderr, + "Invalid multicast addr " RTE_ETHER_ADDR_PRT_FMT "\n", + RTE_ETHER_ADDR_BYTES(&res->mc_addr)); return; } if (strcmp(res->what, "add") == 0) @@ -10771,16 +11201,16 @@ cmd_set_vf_vlan_anti_spoof_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -10877,16 +11307,17 @@ cmd_set_vf_mac_anti_spoof_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -10983,16 +11414,17 @@ cmd_set_vf_vlan_stripq_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11087,16 +11519,17 @@ cmd_set_vf_vlan_insert_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or vlan_id %d\n", res->vf_id, res->vlan_id); + fprintf(stderr, "invalid vf_id %d or vlan_id %d\n", + res->vf_id, res->vlan_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11184,16 +11617,16 @@ cmd_set_tx_loopback_parsed( case 0: break; case -EINVAL: - printf("invalid is_on %d\n", is_on); + fprintf(stderr, "invalid is_on %d\n", is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11274,16 +11707,16 @@ cmd_set_all_queues_drop_en_parsed( case 0: break; case -EINVAL: - printf("invalid is_on %d\n", is_on); + fprintf(stderr, "invalid is_on %d\n", is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11366,16 +11799,17 @@ cmd_set_vf_split_drop_en_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11470,16 +11904,16 @@ cmd_set_vf_mac_addr_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or mac_addr\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d or mac_addr\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11568,7 +12002,7 @@ cmd_set_macsec_offload_on_parsed( if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (!port_is_stopped(port_id)) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -11576,7 +12010,7 @@ cmd_set_macsec_offload_on_parsed( if (ret != 0) return; - if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) { + if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MACSEC_INSERT) { #ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp); #endif @@ -11587,17 +12021,17 @@ cmd_set_macsec_offload_on_parsed( switch (ret) { case 0: ports[port_id].dev_conf.txmode.offloads |= - DEV_TX_OFFLOAD_MACSEC_INSERT; + RTE_ETH_TX_OFFLOAD_MACSEC_INSERT; cmd_reconfig_device_queue(port_id, 1, 1); break; case -ENODEV: - printf("invalid port_id %d\n", port_id); + fprintf(stderr, "invalid port_id %d\n", port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", port_id); + fprintf(stderr, "not supported on port %d\n", port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11665,7 +12099,7 @@ cmd_set_macsec_offload_off_parsed( if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (!port_is_stopped(port_id)) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -11673,7 +12107,7 @@ cmd_set_macsec_offload_off_parsed( if (ret != 0) return; - if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) { + if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MACSEC_INSERT) { #ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_macsec_disable(port_id); #endif @@ -11681,17 +12115,17 @@ cmd_set_macsec_offload_off_parsed( switch (ret) { case 0: ports[port_id].dev_conf.txmode.offloads &= - ~DEV_TX_OFFLOAD_MACSEC_INSERT; + ~RTE_ETH_TX_OFFLOAD_MACSEC_INSERT; cmd_reconfig_device_queue(port_id, 1, 1); break; case -ENODEV: - printf("invalid port_id %d\n", port_id); + fprintf(stderr, "invalid port_id %d\n", port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", port_id); + fprintf(stderr, "not supported on port %d\n", port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11773,13 +12207,13 @@ cmd_set_macsec_sc_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11893,16 +12327,16 @@ cmd_set_macsec_sa_parsed( case 0: break; case -EINVAL: - printf("invalid idx %d or an %d\n", res->idx, res->an); + fprintf(stderr, "invalid idx %d or an %d\n", res->idx, res->an); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -11985,16 +12419,16 @@ cmd_set_vf_promisc_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12075,16 +12509,16 @@ cmd_set_vf_allmulti_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12165,16 +12599,17 @@ cmd_set_vf_broadcast_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12259,16 +12694,17 @@ cmd_set_vf_vlan_tag_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12380,17 +12816,17 @@ cmd_vf_max_bw_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or bandwidth %d\n", - res->vf_id, res->bw); + fprintf(stderr, "invalid vf_id %d or bandwidth %d\n", + res->vf_id, res->bw); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12425,24 +12861,27 @@ vf_tc_min_bw_parse_bw_list(uint8_t *bw_list, p = strchr(p0, '('); if (p == NULL) { - printf("The bandwidth-list should be '(bw1, bw2, ...)'\n"); + fprintf(stderr, + "The bandwidth-list should be '(bw1, bw2, ...)'\n"); return -1; } p++; p0 = strchr(p, ')'); if (p0 == NULL) { - printf("The bandwidth-list should be '(bw1, bw2, ...)'\n"); + fprintf(stderr, + "The bandwidth-list should be '(bw1, bw2, ...)'\n"); return -1; } size = p0 - p; if (size >= sizeof(s)) { - printf("The string size exceeds the internal buffer size\n"); + fprintf(stderr, + "The string size exceeds the internal buffer size\n"); return -1; } snprintf(s, sizeof(s), "%.*s", size, p); ret = rte_strsplit(s, sizeof(s), str_fld, 16, ','); if (ret <= 0) { - printf("Failed to get the bandwidth list. "); + fprintf(stderr, "Failed to get the bandwidth list.\n"); return -1; } *tc_num = ret; @@ -12480,16 +12919,16 @@ cmd_vf_tc_min_bw_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or bandwidth\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d or bandwidth\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12529,7 +12968,7 @@ cmd_tc_min_bw_parsed( port = &ports[res->port_id]; /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -12545,16 +12984,16 @@ cmd_tc_min_bw_parsed( case 0: break; case -EINVAL: - printf("invalid bandwidth\n"); + fprintf(stderr, "invalid bandwidth\n"); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -12595,17 +13034,18 @@ cmd_vf_tc_max_bw_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d, tc_no %d or bandwidth %d\n", - res->vf_id, res->tc_no, res->bw); + fprintf(stderr, + "invalid vf_id %d, tc_no %d or bandwidth %d\n", + res->vf_id, res->tc_no, res->bw); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14001,16 +14441,16 @@ cmd_strict_link_prio_parsed( case 0: break; case -EINVAL: - printf("invalid tc_bitmap 0x%x\n", res->tc_map); + fprintf(stderr, "invalid tc_bitmap 0x%x\n", res->tc_map); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14061,13 +14501,13 @@ cmd_ddp_add_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } filepath = strdup(res->filepath); if (filepath == NULL) { - printf("Failed to allocate memory\n"); + fprintf(stderr, "Failed to allocate memory\n"); return; } file_num = rte_strsplit(filepath, strlen(filepath), file_fld, 2, ','); @@ -14086,9 +14526,9 @@ cmd_ddp_add_parsed( #endif if (ret == -EEXIST) - printf("Profile has already existed.\n"); + fprintf(stderr, "Profile has already existed.\n"); else if (ret < 0) - printf("Failed to load profile.\n"); + fprintf(stderr, "Failed to load profile.\n"); else if (file_num == 2) save_file(file_fld[1], buff, size); @@ -14138,7 +14578,7 @@ cmd_ddp_del_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -14154,9 +14594,9 @@ cmd_ddp_del_parsed( #endif if (ret == -EACCES) - printf("Profile does not exist.\n"); + fprintf(stderr, "Profile does not exist.\n"); else if (ret < 0) - printf("Failed to delete profile.\n"); + fprintf(stderr, "Failed to delete profile.\n"); close_file(buff); } @@ -14390,11 +14830,10 @@ no_print_pctypes: ret = 0; no_print_return: - if (proto) - free(proto); + free(proto); #endif if (ret == -ENOTSUP) - printf("Function not supported in PMD driver\n"); + fprintf(stderr, "Function not supported in PMD\n"); close_file(pkg); } @@ -14452,7 +14891,7 @@ cmd_ddp_get_list_parsed( size = PROFILE_INFO_SIZE * MAX_PROFILE_NUM + 4; p_list = (struct rte_pmd_i40e_profile_list *)malloc(size); if (!p_list) { - printf("%s: Failed to malloc buffer\n", __func__); + fprintf(stderr, "%s: Failed to malloc buffer\n", __func__); return; } @@ -14481,7 +14920,7 @@ cmd_ddp_get_list_parsed( #endif if (ret < 0) - printf("Failed to get ddp list\n"); + fprintf(stderr, "Failed to get ddp list\n"); } cmdline_parse_inst_t cmd_ddp_get_list = { @@ -14524,7 +14963,7 @@ cmd_cfg_input_set_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -14538,7 +14977,7 @@ cmd_cfg_input_set_parsed( ret = rte_pmd_i40e_inset_get(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to get input set.\n"); + fprintf(stderr, "Failed to get input set.\n"); return; } @@ -14557,20 +14996,20 @@ cmd_cfg_input_set_parsed( ret = rte_pmd_i40e_inset_field_clear(&inset.inset, res->field_idx); if (ret) { - printf("Failed to configure input set field.\n"); + fprintf(stderr, "Failed to configure input set field.\n"); return; } ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to set input set.\n"); + fprintf(stderr, "Failed to set input set.\n"); return; } #endif if (ret == -ENOTSUP) - printf("Function not supported\n"); + fprintf(stderr, "Function not supported\n"); } cmdline_parse_token_string_t cmd_cfg_input_set_port = @@ -14647,7 +15086,7 @@ cmd_clear_input_set_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -14664,14 +15103,14 @@ cmd_clear_input_set_parsed( ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to clear input set.\n"); + fprintf(stderr, "Failed to clear input set.\n"); return; } #endif if (ret == -ENOTSUP) - printf("Function not supported\n"); + fprintf(stderr, "Function not supported\n"); } cmdline_parse_token_string_t cmd_clear_input_set_port = @@ -14784,16 +15223,16 @@ cmd_show_vf_stats_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } printf("\n %s NIC statistics for port %-2d vf %-2d %s\n", @@ -14887,16 +15326,16 @@ cmd_clear_vf_stats_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14972,13 +15411,13 @@ cmd_pctype_mapping_reset_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15055,13 +15494,13 @@ cmd_pctype_mapping_get_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); return; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); return; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); return; } @@ -15180,16 +15619,16 @@ cmd_pctype_mapping_update_parsed( case 0: break; case -EINVAL: - printf("invalid pctype or flow type\n"); + fprintf(stderr, "invalid pctype or flow type\n"); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15274,13 +15713,13 @@ cmd_ptype_mapping_get_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } #ifdef RTE_NET_I40E @@ -15372,17 +15811,17 @@ cmd_ptype_mapping_replace_parsed( case 0: break; case -EINVAL: - printf("invalid ptype 0x%8x or 0x%8x\n", - res->target, res->pkt_type); + fprintf(stderr, "invalid ptype 0x%8x or 0x%8x\n", + res->target, res->pkt_type); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15451,13 +15890,13 @@ cmd_ptype_mapping_reset_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15539,16 +15978,16 @@ cmd_ptype_mapping_update_parsed( case 0: break; case -EINVAL: - printf("invalid ptype 0x%8x\n", res->sw_ptype); + fprintf(stderr, "invalid ptype 0x%8x\n", res->sw_ptype); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15738,6 +16177,7 @@ cmd_rx_offload_get_configuration_parsed( struct rte_eth_dev_info dev_info; portid_t port_id = res->port_id; struct rte_port *port = &ports[port_id]; + struct rte_eth_conf dev_conf; uint64_t port_offloads; uint64_t queue_offloads; uint16_t nb_rx_queues; @@ -15746,7 +16186,11 @@ cmd_rx_offload_get_configuration_parsed( printf("Rx Offloading Configuration of port %d :\n", port_id); - port_offloads = port->dev_conf.rxmode.offloads; + ret = eth_dev_conf_get_print_err(port_id, &dev_conf); + if (ret != 0) + return; + + port_offloads = dev_conf.rxmode.offloads; printf(" Port :"); print_rx_offloads(port_offloads); printf("\n"); @@ -15857,14 +16301,15 @@ cmd_config_per_port_rx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } single_offload = search_rx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -15962,8 +16407,9 @@ cmd_config_per_queue_rx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } @@ -15972,14 +16418,15 @@ cmd_config_per_queue_rx_offload_parsed(void *parsed_result, return; if (queue_id >= dev_info.nb_rx_queues) { - printf("Error: input queue_id should be 0 ... " - "%d\n", dev_info.nb_rx_queues - 1); + fprintf(stderr, + "Error: input queue_id should be 0 ... %d\n", + dev_info.nb_rx_queues - 1); return; } single_offload = search_rx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -16149,6 +16596,7 @@ cmd_tx_offload_get_configuration_parsed( struct rte_eth_dev_info dev_info; portid_t port_id = res->port_id; struct rte_port *port = &ports[port_id]; + struct rte_eth_conf dev_conf; uint64_t port_offloads; uint64_t queue_offloads; uint16_t nb_tx_queues; @@ -16157,7 +16605,11 @@ cmd_tx_offload_get_configuration_parsed( printf("Tx Offloading Configuration of port %d :\n", port_id); - port_offloads = port->dev_conf.txmode.offloads; + ret = eth_dev_conf_get_print_err(port_id, &dev_conf); + if (ret != 0) + return; + + port_offloads = dev_conf.txmode.offloads; printf(" Port :"); print_tx_offloads(port_offloads); printf("\n"); @@ -16272,14 +16724,15 @@ cmd_config_per_port_tx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } single_offload = search_tx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -16380,8 +16833,9 @@ cmd_config_per_queue_tx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } @@ -16390,14 +16844,15 @@ cmd_config_per_queue_tx_offload_parsed(void *parsed_result, return; if (queue_id >= dev_info.nb_tx_queues) { - printf("Error: input queue_id should be 0 ... " - "%d\n", dev_info.nb_tx_queues - 1); + fprintf(stderr, + "Error: input queue_id should be 0 ... %d\n", + dev_info.nb_tx_queues - 1); return; } single_offload = search_tx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -16514,13 +16969,13 @@ cmd_config_dynf_specific_parsed(void *parsed_result, if (flag <= 0) { if (strlcpy(desc_flag.name, res->name, RTE_MBUF_DYN_NAMESIZE) >= RTE_MBUF_DYN_NAMESIZE) { - printf("Flag name too long\n"); + fprintf(stderr, "Flag name too long\n"); return; } desc_flag.flags = 0; flag = rte_mbuf_dynflag_register(&desc_flag); if (flag < 0) { - printf("Can't register flag\n"); + fprintf(stderr, "Can't register flag\n"); return; } strcpy(dynf_names[flag], desc_flag.name); @@ -16587,7 +17042,7 @@ cmd_show_tx_metadata_parsed(void *parsed_result, struct cmd_show_tx_metadata_result *res = parsed_result; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } if (!strcmp(res->cmd_keyword, "tx_metadata")) { @@ -16642,29 +17097,29 @@ cmd_show_fec_capability_parsed(void *parsed_result, int ret; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("Invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); return; } ret = rte_eth_fec_get_capability(res->cmd_pid, NULL, 0); if (ret == -ENOTSUP) { - printf("Function not implemented\n"); + fprintf(stderr, "Function not implemented\n"); return; } else if (ret < 0) { - printf("Get FEC capability failed: %d\n", ret); + fprintf(stderr, "Get FEC capability failed: %d\n", ret); return; } num = (unsigned int)ret; speed_fec_capa = calloc(num, sizeof(*speed_fec_capa)); if (speed_fec_capa == NULL) { - printf("Failed to alloc FEC capability buffer\n"); + fprintf(stderr, "Failed to alloc FEC capability buffer\n"); return; } ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num); if (ret < 0) { - printf("Error getting FEC capability: %d\n", ret); + fprintf(stderr, "Error getting FEC capability: %d\n", ret); goto out; } @@ -16723,15 +17178,15 @@ cmd_show_fec_mode_parsed(void *parsed_result, int ret; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("Invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); return; } ret = rte_eth_fec_get(res->cmd_pid, &mode); if (ret == -ENOTSUP) { - printf("Function not implemented\n"); + fprintf(stderr, "Function not implemented\n"); return; } else if (ret < 0) { - printf("Get FEC mode failed\n"); + fprintf(stderr, "Get FEC mode failed\n"); return; } @@ -16820,22 +17275,22 @@ cmd_set_port_fec_mode_parsed( { struct cmd_set_port_fec_mode *res = parsed_result; uint16_t port_id = res->port_id; - uint32_t mode; + uint32_t fec_capa; int ret; - ret = parse_fec_mode(res->fec_value, &mode); + ret = parse_fec_mode(res->fec_value, &fec_capa); if (ret < 0) { - printf("Unknown fec mode: %s for Port %d\n", res->fec_value, - port_id); + fprintf(stderr, "Unknown fec mode: %s for port %d\n", + res->fec_value, port_id); return; } - ret = rte_eth_fec_set(port_id, mode); + ret = rte_eth_fec_set(port_id, fec_capa); if (ret == -ENOTSUP) { - printf("Function not implemented\n"); + fprintf(stderr, "Function not implemented\n"); return; } else if (ret < 0) { - printf("Set FEC mode failed\n"); + fprintf(stderr, "Set FEC mode failed\n"); return; } } @@ -16983,7 +17438,7 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result, int rc; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } @@ -16991,8 +17446,9 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result, rc = rte_eth_rx_descriptor_status(res->cmd_pid, res->cmd_qid, res->cmd_did); if (rc < 0) { - printf("Invalid input: queue id = %d, desc id = %d\n", - res->cmd_qid, res->cmd_did); + fprintf(stderr, + "Invalid input: queue id = %d, desc id = %d\n", + res->cmd_qid, res->cmd_did); return; } if (rc == RTE_ETH_RX_DESC_AVAIL) @@ -17005,8 +17461,9 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result, rc = rte_eth_tx_descriptor_status(res->cmd_pid, res->cmd_qid, res->cmd_did); if (rc < 0) { - printf("Invalid input: queue id = %d, desc id = %d\n", - res->cmd_qid, res->cmd_did); + fprintf(stderr, + "Invalid input: queue id = %d, desc id = %d\n", + res->cmd_qid, res->cmd_did); return; } if (rc == RTE_ETH_TX_DESC_FULL) @@ -17081,13 +17538,13 @@ cmd_show_rx_queue_desc_used_count_parsed(void *parsed_result, int rc; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } rc = rte_eth_rx_queue_count(res->cmd_pid, res->cmd_qid); if (rc < 0) { - printf("Invalid queueid = %d\n", res->cmd_qid); + fprintf(stderr, "Invalid queueid = %d\n", res->cmd_qid); return; } printf("Used desc count = %d\n", rc); @@ -17189,7 +17646,8 @@ cmd_set_port_ptypes_parsed( ret = rte_eth_dev_get_supported_ptypes(port_id, RTE_PTYPE_ALL_MASK, NULL, 0); if (ret <= 0) { - printf("Port %d doesn't support any ptypes.\n", port_id); + fprintf(stderr, "Port %d doesn't support any ptypes.\n", + port_id); return; } @@ -17197,7 +17655,8 @@ cmd_set_port_ptypes_parsed( ret = rte_eth_dev_set_ptypes(port_id, ptype_mask, ptypes, ret); if (ret < 0) { - printf("Unable to set requested ptypes for Port %d\n", port_id); + fprintf(stderr, "Unable to set requested ptypes for Port %d\n", + port_id); return; } @@ -17274,6 +17733,77 @@ cmdline_parse_inst_t cmd_showport_macs = { }, }; +/* *** show flow transfer proxy port ID for the given port *** */ +struct cmd_show_port_flow_transfer_proxy_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + portid_t port_id; + cmdline_fixed_string_t flow; + cmdline_fixed_string_t transfer; + cmdline_fixed_string_t proxy; +}; + +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_show = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + show, "show"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_port = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + port, "port"); +cmdline_parse_token_num_t cmd_show_port_flow_transfer_proxy_port_id = + TOKEN_NUM_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_flow = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + flow, "flow"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_transfer = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + transfer, "transfer"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_proxy = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + proxy, "proxy"); + +static void +cmd_show_port_flow_transfer_proxy_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_port_flow_transfer_proxy_result *res = parsed_result; + portid_t proxy_port_id; + int ret; + + printf("\n"); + + ret = rte_flow_pick_transfer_proxy(res->port_id, &proxy_port_id, NULL); + if (ret != 0) { + fprintf(stderr, "Failed to pick transfer proxy: %s\n", + rte_strerror(-ret)); + return; + } + + printf("Transfer proxy port ID: %u\n\n", proxy_port_id); +} + +cmdline_parse_inst_t cmd_show_port_flow_transfer_proxy = { + .f = cmd_show_port_flow_transfer_proxy_parsed, + .data = NULL, + .help_str = "show port flow transfer proxy", + .tokens = { + (void *)&cmd_show_port_flow_transfer_proxy_show, + (void *)&cmd_show_port_flow_transfer_proxy_port, + (void *)&cmd_show_port_flow_transfer_proxy_port_id, + (void *)&cmd_show_port_flow_transfer_proxy_flow, + (void *)&cmd_show_port_flow_transfer_proxy_transfer, + (void *)&cmd_show_port_flow_transfer_proxy_proxy, + NULL, + } +}; + /* ******************************************************************************** */ /* list of instructions */ @@ -17286,6 +17816,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_showqueue, (cmdline_parse_inst_t *)&cmd_showeeprom, (cmdline_parse_inst_t *)&cmd_showportall, + (cmdline_parse_inst_t *)&cmd_representor_info, (cmdline_parse_inst_t *)&cmd_showdevice, (cmdline_parse_inst_t *)&cmd_showcfg, (cmdline_parse_inst_t *)&cmd_showfwdall, @@ -17320,6 +17851,7 @@ cmdline_parse_ctx_t main_ctx[] = { #ifdef RTE_NET_BOND (cmdline_parse_inst_t *) &cmd_set_bonding_mode, (cmdline_parse_inst_t *) &cmd_show_bonding_config, + (cmdline_parse_inst_t *) &cmd_show_bonding_lacp_info, (cmdline_parse_inst_t *) &cmd_set_bonding_primary, (cmdline_parse_inst_t *) &cmd_add_bonding_slave, (cmdline_parse_inst_t *) &cmd_remove_bonding_slave, @@ -17345,12 +17877,16 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tso_show, (cmdline_parse_inst_t *)&cmd_tunnel_tso_set, (cmdline_parse_inst_t *)&cmd_tunnel_tso_show, +#ifdef RTE_LIB_GRO (cmdline_parse_inst_t *)&cmd_gro_enable, (cmdline_parse_inst_t *)&cmd_gro_flush, (cmdline_parse_inst_t *)&cmd_gro_show, +#endif +#ifdef RTE_LIB_GSO (cmdline_parse_inst_t *)&cmd_gso_enable, (cmdline_parse_inst_t *)&cmd_gso_size, (cmdline_parse_inst_t *)&cmd_gso_show, +#endif (cmdline_parse_inst_t *)&cmd_link_flow_control_set, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx, @@ -17360,7 +17896,9 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_link_flow_control_set_xon, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_macfwd, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg, + (cmdline_parse_inst_t *)&cmd_link_flow_control_show, (cmdline_parse_inst_t *)&cmd_priority_flow_control_set, + (cmdline_parse_inst_t *)&cmd_queue_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, @@ -17399,6 +17937,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_config_rss_reta, (cmdline_parse_inst_t *)&cmd_showport_reta, (cmdline_parse_inst_t *)&cmd_showport_macs, + (cmdline_parse_inst_t *)&cmd_show_port_flow_transfer_proxy, (cmdline_parse_inst_t *)&cmd_config_burst, (cmdline_parse_inst_t *)&cmd_config_thresh, (cmdline_parse_inst_t *)&cmd_config_threshold, @@ -17407,12 +17946,10 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter, (cmdline_parse_inst_t *)&cmd_queue_rate_limit, (cmdline_parse_inst_t *)&cmd_tunnel_udp_config, - (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_cleanup_txq_mbufs, (cmdline_parse_inst_t *)&cmd_dump, (cmdline_parse_inst_t *)&cmd_dump_one, #ifdef RTE_NET_I40E @@ -17426,6 +17963,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_show_port_meter_cap, (cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm, (cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm, + (cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm_rfc4115, (cmdline_parse_inst_t *)&cmd_del_port_meter_profile, (cmdline_parse_inst_t *)&cmd_create_port_meter, (cmdline_parse_inst_t *)&cmd_enable_port_meter, @@ -17551,6 +18089,8 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_show_fec_mode, (cmdline_parse_inst_t *)&cmd_set_fec_mode, (cmdline_parse_inst_t *)&cmd_show_capability, + (cmdline_parse_inst_t *)&cmd_set_flex_is_pattern, + (cmdline_parse_inst_t *)&cmd_set_flex_spec_pattern, NULL, }; @@ -17562,8 +18102,9 @@ cmdline_read_from_file(const char *filename) cl = cmdline_file_new(main_ctx, "testpmd> ", filename); if (cl == NULL) { - printf("Failed to create file based cmdline context: %s\n", - filename); + fprintf(stderr, + "Failed to create file based cmdline context: %s\n", + filename); return; } @@ -17590,7 +18131,7 @@ prompt(void) ret = atexit(prompt_exit); if (ret != 0) - printf("Cannot set exit function for cmdline\n"); + fprintf(stderr, "Cannot set exit function for cmdline\n"); cmdline_interact(testpmd_cl); if (ret != 0)