X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=c43c85c591bd69c521e48d0144c3e9b6199500ef;hb=9da077adb34630d388e0ededdd7ce4214d764284;hp=826256b0b346c4f4d9fb21f208ea56bb57174b01;hpb=b225783dda7a254fc49bc4d43b8b58f67e03be1d;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 826256b0b3..c43c85c591 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -24,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -35,7 +34,9 @@ #include #include #include +#ifdef RTE_LIB_GRO #include +#endif #include #include @@ -162,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" @@ -249,6 +253,9 @@ 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" @@ -456,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" @@ -466,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" @@ -477,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" @@ -613,6 +624,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" @@ -1472,51 +1486,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 { 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) { + 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 { 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; } @@ -1874,45 +1888,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 (strcmp(res->name, "max-pkt-len") != 0) { + printf("Unknown parameter\n"); + return; + } + if (!all_ports_stopped()) { fprintf(stderr, "Please stop all ports first\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) { - fprintf(stderr, - "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; + RTE_ETH_FOREACH_DEV(port_id) { + struct rte_port *port = &ports[port_id]; - ret = eth_dev_info_get_print_err(pid, &port->dev_info); - if (ret != 0) { - fprintf(stderr, - "rte_eth_dev_info_get() failed for port %u\n", - pid); - return; - } - - 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 { - fprintf(stderr, "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(); @@ -2167,33 +2174,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; 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")) @@ -2207,46 +2214,46 @@ 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 = ETH_RSS_IPV4_CHKSUM; + rss_conf.rss_hf = RTE_ETH_RSS_IPV4_CHKSUM; 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 && @@ -2983,8 +2990,8 @@ parse_reta_config(const char *str, 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; } @@ -3013,10 +3020,10 @@ cmd_set_rss_reta_parsed(void *parsed_result, } 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) { + 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", - ETH_RSS_RETA_SIZE_512); + RTE_ETH_RSS_RETA_SIZE_512); return; } @@ -3087,8 +3094,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, '('); @@ -3133,7 +3140,7 @@ 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) { fprintf(stderr, "Invalid redirection table size: %u (1-%u)\n", res->size, max_reta_size); @@ -3273,7 +3280,7 @@ cmd_config_dcb_parsed(void *parsed_result, return; } - if ((res->num_tcs != ETH_4_TCS) && (res->num_tcs != ETH_8_TCS)) { + 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; @@ -3654,7 +3661,7 @@ parse_item_list(const 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++) { @@ -4277,9 +4284,9 @@ 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 { fprintf(stderr, "Unknown vlan type\n"); return; @@ -4616,55 +4623,55 @@ 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) { + 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 & DEV_TX_OFFLOAD_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_CKSUM) == 0) { + 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 & DEV_TX_OFFLOAD_TCP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_CKSUM) == 0) { + 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 & DEV_TX_OFFLOAD_SCTP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_SCTP_CKSUM) == 0) { + 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 & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) == 0) { + 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 & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) == 0) { fprintf(stderr, "Warning: hardware outer UDP checksum enabled but not supported by port %d\n", @@ -4714,8 +4721,8 @@ 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 { fprintf(stderr, "IP checksum offload is not supported by port %u\n", @@ -4723,8 +4730,8 @@ cmd_csum_parsed(void *parsed_result, } } 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 { fprintf(stderr, "UDP checksum offload is not supported by port %u\n", @@ -4732,8 +4739,8 @@ cmd_csum_parsed(void *parsed_result, } } 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 { fprintf(stderr, "TCP checksum offload is not supported by port %u\n", @@ -4741,8 +4748,8 @@ cmd_csum_parsed(void *parsed_result, } } 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 { fprintf(stderr, "SCTP checksum offload is not supported by port %u\n", @@ -4750,9 +4757,9 @@ cmd_csum_parsed(void *parsed_result, } } 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 { fprintf(stderr, "Outer IP checksum offload is not supported by port %u\n", @@ -4760,9 +4767,9 @@ cmd_csum_parsed(void *parsed_result, } } 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 { fprintf(stderr, "Outer UDP checksum offload is not supported by port %u\n", @@ -4917,7 +4924,7 @@ 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) { + (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; @@ -4925,11 +4932,11 @@ cmd_tso_set_parsed(void *parsed_result, 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); } @@ -4941,7 +4948,7 @@ 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) { + (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); @@ -5012,27 +5019,27 @@ 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)) + 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 & DEV_TX_OFFLOAD_GRE_TNL_TSO)) + 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 & DEV_TX_OFFLOAD_IPIP_TNL_TSO)) + 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 & DEV_TX_OFFLOAD_GENEVE_TNL_TSO)) + 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 & DEV_TX_OFFLOAD_IP_TNL_TSO)) + 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 & DEV_TX_OFFLOAD_UDP_TNL_TSO)) + 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); @@ -5060,20 +5067,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); @@ -5096,7 +5103,7 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, 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)) + 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"); } @@ -5151,6 +5158,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; @@ -5294,7 +5302,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; @@ -5461,6 +5471,7 @@ cmdline_parse_inst_t cmd_gso_show = { NULL, }, }; +#endif /* RTE_LIB_GSO */ /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ struct cmd_set_flush_rx { @@ -6089,6 +6100,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; @@ -6118,7 +6309,8 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, } 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); @@ -7048,9 +7240,9 @@ cmd_link_flow_ctrl_show_parsed(void *parsed_result, 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 = true; - 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 = true; printf("\n%s Flow control infos for port %-2d %s\n", @@ -7328,12 +7520,12 @@ 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 */ @@ -7346,11 +7538,11 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, 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; } @@ -7418,12 +7610,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)); @@ -7888,6 +8080,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; @@ -8940,13 +9263,13 @@ 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); @@ -9346,7 +9669,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, @@ -9412,13 +9735,13 @@ 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 { fprintf(stderr, "Invalid tunnel type\n"); return; @@ -10128,6 +10451,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++) { @@ -11549,7 +11876,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 @@ -11560,7 +11887,7 @@ 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: @@ -11646,7 +11973,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 @@ -11654,7 +11981,7 @@ 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: @@ -15717,6 +16044,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; @@ -15725,7 +16053,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"); @@ -16131,6 +16463,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; @@ -16139,7 +16472,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"); @@ -17263,6 +17600,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 */ @@ -17275,6 +17683,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, @@ -17309,6 +17718,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, @@ -17334,12 +17744,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, @@ -17389,6 +17803,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, @@ -17539,6 +17954,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, };