X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fconfig.c;h=9669cbd4cb8f7634792944fb957e20f645fcc359;hb=f6208425eb7860372ceeebeb2c4636edcfeee79b;hp=1d23a25ebe817b46a6ed210494ac2795b50f3235;hpb=44b257ffe914f43ef7f4260432559330ae848bda;p=dpdk.git diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index 1d23a25ebe..9669cbd4cb 100644 --- a/app/test-pmd/config.c +++ b/app/test-pmd/config.c @@ -49,7 +49,7 @@ #include #endif #include -#include +#include #include "testpmd.h" @@ -74,6 +74,10 @@ static const struct { }; const struct rss_type_info rss_type_table[] = { + { "all", ETH_RSS_IP | ETH_RSS_TCP | + ETH_RSS_UDP | ETH_RSS_SCTP | + ETH_RSS_L2_PAYLOAD }, + { "none", 0 }, { "ipv4", ETH_RSS_IPV4 }, { "ipv4-frag", ETH_RSS_FRAG_IPV4 }, { "ipv4-tcp", ETH_RSS_NONFRAG_IPV4_TCP }, @@ -99,14 +103,18 @@ const struct rss_type_info rss_type_table[] = { { "tcp", ETH_RSS_TCP }, { "sctp", ETH_RSS_SCTP }, { "tunnel", ETH_RSS_TUNNEL }, + { "l3-src-only", ETH_RSS_L3_SRC_ONLY }, + { "l3-dst-only", ETH_RSS_L3_DST_ONLY }, + { "l4-src-only", ETH_RSS_L4_SRC_ONLY }, + { "l4-dst-only", ETH_RSS_L4_DST_ONLY }, { NULL, 0 }, }; static void -print_ethaddr(const char *name, struct ether_addr *eth_addr) +print_ethaddr(const char *name, struct rte_ether_addr *eth_addr) { - char buf[ETHER_ADDR_FMT_SIZE]; - ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr); + char buf[RTE_ETHER_ADDR_FMT_SIZE]; + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, eth_addr); printf("%s%s", name, buf); } @@ -115,9 +123,12 @@ nic_stats_display(portid_t port_id) { static uint64_t prev_pkts_rx[RTE_MAX_ETHPORTS]; static uint64_t prev_pkts_tx[RTE_MAX_ETHPORTS]; + static uint64_t prev_bytes_rx[RTE_MAX_ETHPORTS]; + static uint64_t prev_bytes_tx[RTE_MAX_ETHPORTS]; static uint64_t prev_cycles[RTE_MAX_ETHPORTS]; - uint64_t diff_pkts_rx, diff_pkts_tx, diff_cycles; - uint64_t mpps_rx, mpps_tx; + uint64_t diff_pkts_rx, diff_pkts_tx, diff_bytes_rx, diff_bytes_tx, + diff_cycles; + uint64_t mpps_rx, mpps_tx, mbps_rx, mbps_tx; struct rte_eth_stats stats; struct rte_port *port = &ports[port_id]; uint8_t i; @@ -188,9 +199,22 @@ nic_stats_display(portid_t port_id) diff_pkts_rx * rte_get_tsc_hz() / diff_cycles : 0; mpps_tx = diff_cycles > 0 ? diff_pkts_tx * rte_get_tsc_hz() / diff_cycles : 0; + + diff_bytes_rx = (stats.ibytes > prev_bytes_rx[port_id]) ? + (stats.ibytes - prev_bytes_rx[port_id]) : 0; + diff_bytes_tx = (stats.obytes > prev_bytes_tx[port_id]) ? + (stats.obytes - prev_bytes_tx[port_id]) : 0; + prev_bytes_rx[port_id] = stats.ibytes; + prev_bytes_tx[port_id] = stats.obytes; + mbps_rx = diff_cycles > 0 ? + diff_bytes_rx * rte_get_tsc_hz() / diff_cycles : 0; + mbps_tx = diff_cycles > 0 ? + diff_bytes_tx * rte_get_tsc_hz() / diff_cycles : 0; + printf("\n Throughput (since last show)\n"); - printf(" Rx-pps: %12"PRIu64"\n Tx-pps: %12"PRIu64"\n", - mpps_rx, mpps_tx); + printf(" Rx-pps: %12"PRIu64" Rx-bps: %12"PRIu64"\n Tx-pps: %12" + PRIu64" Tx-bps: %12"PRIu64"\n", mpps_rx, mbps_rx * 8, + mpps_tx, mbps_tx * 8); printf(" %s############################%s\n", nic_stats_border, nic_stats_border); @@ -214,6 +238,10 @@ nic_xstats_display(portid_t port_id) int cnt_xstats, idx_xstat; struct rte_eth_xstat_name *xstats_names; + if (port_id_is_invalid(port_id, ENABLED_WARN)) { + print_valid_ports(); + return; + } printf("###### NIC extended statistics for port %-2d\n", port_id); if (!rte_eth_dev_is_valid_port(port_id)) { printf("Error: Invalid port number %i\n", port_id); @@ -269,7 +297,17 @@ nic_xstats_display(portid_t port_id) void nic_xstats_clear(portid_t port_id) { - rte_eth_xstats_reset(port_id); + int ret; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) { + print_valid_ports(); + return; + } + ret = rte_eth_xstats_reset(port_id); + if (ret != 0) { + printf("%s: Error: failed to reset xstats (port %u): %s", + __func__, port_id, strerror(ret)); + } } void @@ -323,6 +361,7 @@ nic_stats_mapping_display(portid_t port_id) void rx_queue_infos_display(portid_t port_id, uint16_t queue_id) { + struct rte_eth_burst_mode mode; struct rte_eth_rxq_info qinfo; int32_t rc; static const char *info_border = "*********************"; @@ -350,12 +389,20 @@ rx_queue_infos_display(portid_t port_id, uint16_t queue_id) printf("\nRX scattered packets: %s", (qinfo.scattered_rx != 0) ? "on" : "off"); printf("\nNumber of RXDs: %hu", qinfo.nb_desc); + + if (rte_eth_rx_burst_mode_get(port_id, queue_id, &mode) == 0) + printf("\nBurst mode: %s%s", + mode.info, + mode.flags & RTE_ETH_BURST_FLAG_PER_QUEUE ? + " (per queue)" : ""); + printf("\n"); } void tx_queue_infos_display(portid_t port_id, uint16_t queue_id) { + struct rte_eth_burst_mode mode; struct rte_eth_txq_info qinfo; int32_t rc; static const char *info_border = "*********************"; @@ -379,14 +426,96 @@ tx_queue_infos_display(portid_t port_id, uint16_t queue_id) printf("\nTX deferred start: %s", (qinfo.conf.tx_deferred_start != 0) ? "on" : "off"); printf("\nNumber of TXDs: %hu", qinfo.nb_desc); + + if (rte_eth_tx_burst_mode_get(port_id, queue_id, &mode) == 0) + printf("\nBurst mode: %s%s", + mode.info, + mode.flags & RTE_ETH_BURST_FLAG_PER_QUEUE ? + " (per queue)" : ""); + printf("\n"); } +static int bus_match_all(const struct rte_bus *bus, const void *data) +{ + RTE_SET_USED(bus); + RTE_SET_USED(data); + return 0; +} + +void +device_infos_display(const char *identifier) +{ + static const char *info_border = "*********************"; + struct rte_bus *start = NULL, *next; + struct rte_dev_iterator dev_iter; + char name[RTE_ETH_NAME_MAX_LEN]; + struct rte_ether_addr mac_addr; + struct rte_device *dev; + struct rte_devargs da; + portid_t port_id; + char devstr[128]; + + memset(&da, 0, sizeof(da)); + if (!identifier) + goto skip_parse; + + if (rte_devargs_parsef(&da, "%s", identifier)) { + printf("cannot parse identifier\n"); + if (da.args) + free(da.args); + return; + } + +skip_parse: + while ((next = rte_bus_find(start, bus_match_all, NULL)) != NULL) { + + start = next; + if (identifier && da.bus != next) + continue; + + /* Skip buses that don't have iterate method */ + if (!next->dev_iterate) + continue; + + snprintf(devstr, sizeof(devstr), "bus=%s", next->name); + RTE_DEV_FOREACH(dev, devstr, &dev_iter) { + + if (!dev->driver) + continue; + /* Check for matching device if identifier is present */ + if (identifier && + strncmp(da.name, dev->name, strlen(dev->name))) + continue; + printf("\n%s Infos for device %s %s\n", + info_border, dev->name, info_border); + printf("Bus name: %s", dev->bus->name); + printf("\nDriver name: %s", dev->driver->name); + printf("\nDevargs: %s", + dev->devargs ? dev->devargs->args : ""); + printf("\nConnect to socket: %d", dev->numa_node); + printf("\n"); + + /* List ports with matching device name */ + RTE_ETH_FOREACH_DEV_OF(port_id, dev) { + printf("\n\tPort id: %-2d", port_id); + if (eth_macaddr_get_print_err(port_id, + &mac_addr) == 0) + print_ethaddr("\n\tMAC address: ", + &mac_addr); + rte_eth_dev_get_name_by_port(port_id, name); + printf("\n\tDevice name: %s", name); + printf("\n"); + } + } + }; +} + void port_infos_display(portid_t port_id) { struct rte_port *port; - struct ether_addr mac_addr; + struct rte_ether_addr mac_addr; struct rte_eth_link link; struct rte_eth_dev_info dev_info; int vlan_offload; @@ -394,22 +523,30 @@ port_infos_display(portid_t port_id) static const char *info_border = "*********************"; uint16_t mtu; char name[RTE_ETH_NAME_MAX_LEN]; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) { print_valid_ports(); return; } port = &ports[port_id]; - rte_eth_link_get_nowait(port_id, &link); - memset(&dev_info, 0, sizeof(dev_info)); - rte_eth_dev_info_get(port_id, &dev_info); + ret = eth_link_get_nowait_print_err(port_id, &link); + if (ret < 0) + return; + + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + printf("\n%s Infos for port %-2d %s\n", info_border, port_id, info_border); - rte_eth_macaddr_get(port_id, &mac_addr); - print_ethaddr("MAC address: ", &mac_addr); + if (eth_macaddr_get_print_err(port_id, &mac_addr) == 0) + print_ethaddr("MAC address: ", &mac_addr); rte_eth_dev_get_name_by_port(port_id, name); printf("\nDevice name: %s", name); printf("\nDriver name: %s", dev_info.driver_name); + if (dev_info.device->devargs && dev_info.device->devargs->args) + printf("\nDevargs: %s", dev_info.device->devargs->args); printf("\nConnect to socket: %u", port->socket_id); if (port_numa[port_id] != NUMA_NO_CONFIG) { @@ -441,19 +578,24 @@ port_infos_display(portid_t port_id) if (vlan_offload >= 0){ printf("VLAN offload: \n"); if (vlan_offload & ETH_VLAN_STRIP_OFFLOAD) - printf(" strip on \n"); + printf(" strip on, "); else - printf(" strip off \n"); + printf(" strip off, "); if (vlan_offload & ETH_VLAN_FILTER_OFFLOAD) - printf(" filter on \n"); + printf("filter on, "); else - printf(" filter off \n"); + printf("filter off, "); if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD) - printf(" qinq(extend) on \n"); + printf("extend on, "); else - printf(" qinq(extend) off \n"); + printf("extend off, "); + + if (vlan_offload & ETH_QINQ_STRIP_OFFLOAD) + printf("qinq strip on\n"); + else + printf("qinq strip off\n"); } if (dev_info.hash_key_size > 0) @@ -461,12 +603,12 @@ port_infos_display(portid_t port_id) if (dev_info.reta_size > 0) printf("Redirection table size: %u\n", dev_info.reta_size); if (!dev_info.flow_type_rss_offloads) - printf("No flow type is supported.\n"); + printf("No RSS offload flow type is supported.\n"); else { uint16_t i; char *p; - printf("Supported flow types:\n"); + printf("Supported RSS offload flow types:\n"); for (i = RTE_ETH_FLOW_UNKNOWN + 1; i < sizeof(dev_info.flow_type_rss_offloads) * CHAR_BIT; i++) { if (!(dev_info.flow_type_rss_offloads & (1ULL << i))) @@ -482,6 +624,8 @@ port_infos_display(portid_t port_id) printf("Minimum size of RX buffer: %u\n", dev_info.min_rx_bufsize); printf("Maximum configurable length of RX packet: %u\n", dev_info.max_rx_pktlen); + printf("Maximum configurable size of LRO aggregated packet: %u\n", + dev_info.max_lro_pkt_size); if (dev_info.max_vfs) printf("Maximum number of VFs: %u\n", dev_info.max_vfs); if (dev_info.max_vmdq_pools) @@ -503,6 +647,10 @@ port_infos_display(portid_t port_id) printf("Min possible number of TXDs per queue: %hu\n", dev_info.tx_desc_lim.nb_min); printf("TXDs number alignment: %hu\n", dev_info.tx_desc_lim.nb_align); + printf("Max segment number per packet: %hu\n", + dev_info.tx_desc_lim.nb_seg_max); + printf("Max segment number per MTU/TSO: %hu\n", + dev_info.tx_desc_lim.nb_mtu_seg_max); /* Show switch info only if valid switch domain and port id is set */ if (dev_info.switch_info.domain_id != @@ -517,16 +665,65 @@ port_infos_display(portid_t port_id) } } +void +port_summary_header_display(void) +{ + uint16_t port_number; + + port_number = rte_eth_dev_count_avail(); + printf("Number of available ports: %i\n", port_number); + printf("%-4s %-17s %-12s %-14s %-8s %s\n", "Port", "MAC Address", "Name", + "Driver", "Status", "Link"); +} + +void +port_summary_display(portid_t port_id) +{ + struct rte_ether_addr mac_addr; + struct rte_eth_link link; + struct rte_eth_dev_info dev_info; + char name[RTE_ETH_NAME_MAX_LEN]; + int ret; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) { + print_valid_ports(); + return; + } + + ret = eth_link_get_nowait_print_err(port_id, &link); + if (ret < 0) + return; + + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + + rte_eth_dev_get_name_by_port(port_id, name); + ret = eth_macaddr_get_print_err(port_id, &mac_addr); + if (ret != 0) + return; + + printf("%-4d %02X:%02X:%02X:%02X:%02X:%02X %-12s %-14s %-8s %uMbps\n", + port_id, mac_addr.addr_bytes[0], mac_addr.addr_bytes[1], + mac_addr.addr_bytes[2], mac_addr.addr_bytes[3], + mac_addr.addr_bytes[4], mac_addr.addr_bytes[5], name, + dev_info.driver_name, (link.link_status) ? ("up") : ("down"), + (unsigned int) link.link_speed); +} + void port_offload_cap_display(portid_t port_id) { struct rte_eth_dev_info dev_info; static const char *info_border = "************"; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; - rte_eth_dev_info_get(port_id, &dev_info); + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; printf("\n%s Port %d supported offload features: %s\n", info_border, port_id, info_border); @@ -543,7 +740,7 @@ port_offload_cap_display(portid_t port_id) if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_QINQ_STRIP) { printf("Double VLANs stripped: "); if (ports[port_id].dev_conf.rxmode.offloads & - DEV_RX_OFFLOAD_VLAN_EXTEND) + DEV_RX_OFFLOAD_QINQ_STRIP) printf("on\n"); else printf("off\n"); @@ -576,6 +773,15 @@ port_offload_cap_display(portid_t port_id) printf("off\n"); } + if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_SCTP_CKSUM) { + printf("RX SCTP checksum: "); + if (ports[port_id].dev_conf.rxmode.offloads & + DEV_RX_OFFLOAD_SCTP_CKSUM) + printf("on\n"); + else + printf("off\n"); + } + if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) { printf("RX Outer IPv4 checksum: "); if (ports[port_id].dev_conf.rxmode.offloads & @@ -585,6 +791,15 @@ port_offload_cap_display(portid_t port_id) printf("off\n"); } + if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_OUTER_UDP_CKSUM) { + printf("RX Outer UDP checksum: "); + if (ports[port_id].dev_conf.rxmode.offloads & + DEV_RX_OFFLOAD_OUTER_UDP_CKSUM) + printf("on\n"); + else + printf("off\n"); + } + if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_LRO) { printf("Large receive offload: "); if (ports[port_id].dev_conf.rxmode.offloads & @@ -755,6 +970,16 @@ port_offload_cap_display(portid_t port_id) else printf("off\n"); } + + if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) { + printf("TX Outer UDP checksum: "); + if (ports[port_id].dev_conf.txmode.offloads & + DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) + printf("on\n"); + else + printf("off\n"); + } + } int @@ -991,9 +1216,21 @@ void port_mtu_set(portid_t port_id, uint16_t mtu) { int diag; + struct rte_eth_dev_info dev_info; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; + + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + + if (mtu > dev_info.max_mtu || mtu < dev_info.min_mtu) { + printf("Set MTU failed. MTU:%u is not in valid range, min:%u - max:%u\n", + mtu, dev_info.min_mtu, dev_info.max_mtu); + return; + } diag = rte_eth_dev_set_mtu(port_id, mtu); if (diag == 0) return; @@ -1066,7 +1303,7 @@ port_flow_complain(struct rte_flow_error *error) errstr = "unknown type"; else errstr = errstrlist[error->type]; - printf("Caught error type %d (%s): %s%s: %s\n", + printf("%s(): Caught PMD error type %d (%s): %s%s: %s\n", __func__, error->type, errstr, error->cause ? (snprintf(buf, sizeof(buf), "cause: %p, ", error->cause), buf) : "", @@ -1204,6 +1441,33 @@ port_flow_flush(portid_t port_id) return ret; } +/** Dump all flow rules. */ +int +port_flow_dump(portid_t port_id, const char *file_name) +{ + int ret = 0; + FILE *file = stdout; + struct rte_flow_error error; + + if (file_name && strlen(file_name)) { + file = fopen(file_name, "w"); + if (!file) { + printf("Failed to create file %s: %s\n", file_name, + strerror(errno)); + return -errno; + } + } + ret = rte_flow_dev_dump(port_id, file, &error); + if (ret) { + port_flow_complain(&error); + printf("Failed to dump flow: %s\n", strerror(-ret)); + } else + printf("Flow dump finished\n"); + if (file_name && strlen(file_name)) + fclose(file); + return ret; +} + /** Query a flow rule. */ int port_flow_query(portid_t port_id, uint32_t rule, @@ -1412,8 +1676,8 @@ ring_dma_zone_lookup(const char *ring_name, portid_t port_id, uint16_t q_id) char mz_name[RTE_MEMZONE_NAMESIZE]; const struct rte_memzone *mz; - snprintf(mz_name, sizeof(mz_name), "%s_%s_%d_%d", - ports[port_id].dev_info.driver_name, ring_name, port_id, q_id); + snprintf(mz_name, sizeof(mz_name), "eth_p%d_q%d_%s", + port_id, q_id, ring_name); mz = rte_memzone_lookup(mz_name); if (mz == NULL) printf("%s ring memory zoneof (port %d, queue %d) not" @@ -1466,10 +1730,13 @@ ring_rx_descriptor_display(const struct rte_memzone *ring_mz, struct igb_ring_desc_16_bytes *ring = (struct igb_ring_desc_16_bytes *)ring_mz->addr; #ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC + int ret; struct rte_eth_dev_info dev_info; - memset(&dev_info, 0, sizeof(dev_info)); - rte_eth_dev_info_get(port_id, &dev_info); + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + if (strstr(dev_info.driver_name, "i40e") != NULL) { /* 32 bytes RX descriptor, i40e only */ struct igb_ring_desc_32_bytes *ring = @@ -1670,21 +1937,24 @@ port_rss_reta_info(portid_t port_id, * key of the port. */ void -port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key) +port_rss_hash_conf_show(portid_t port_id, int show_rss_key) { - struct rte_eth_rss_conf rss_conf; + struct rte_eth_rss_conf rss_conf = {0}; uint8_t rss_key[RSS_HASH_KEY_LENGTH]; uint64_t rss_hf; uint8_t i; int diag; struct rte_eth_dev_info dev_info; uint8_t hash_key_size; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; - memset(&dev_info, 0, sizeof(dev_info)); - rte_eth_dev_info_get(port_id, &dev_info); + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + if (dev_info.hash_key_size > 0 && dev_info.hash_key_size <= sizeof(rss_key)) hash_key_size = dev_info.hash_key_size; @@ -1693,12 +1963,6 @@ port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key) return; } - rss_conf.rss_hf = 0; - for (i = 0; rss_type_table[i].str; i++) { - if (!strcmp(rss_info, rss_type_table[i].str)) - rss_conf.rss_hf = rss_type_table[i].rss_type; - } - /* Get RSS hash key if asked to display it */ rss_conf.rss_key = (show_rss_key) ? rss_key : NULL; rss_conf.rss_key_len = hash_key_size; @@ -2158,6 +2422,8 @@ mp_alloc_to_str(uint8_t mode) return "xmem"; case MP_ALLOC_XMEM_HUGE: return "xmemhuge"; + case MP_ALLOC_XBUF: + return "xbuf"; default: return "invalid"; } @@ -2206,19 +2472,16 @@ pkt_fwd_config_display(struct fwd_config *cfg) void set_fwd_eth_peer(portid_t port_id, char *peer_addr) { - uint8_t c, new_peer_addr[6]; + struct rte_ether_addr new_peer_addr; if (!rte_eth_dev_is_valid_port(port_id)) { printf("Error: Invalid port number %i\n", port_id); return; } - if (cmdline_parse_etheraddr(NULL, peer_addr, &new_peer_addr, - sizeof(new_peer_addr)) < 0) { + if (rte_ether_unformat_addr(peer_addr, &new_peer_addr) < 0) { printf("Error: Invalid ethernet address: %s\n", peer_addr); return; } - for (c = 0; c < 6; c++) - peer_eth_addrs[port_id].addr_bytes[c] = - new_peer_addr[c]; + peer_eth_addrs[port_id] = new_peer_addr; } int @@ -2447,7 +2710,8 @@ set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs) * Check that each segment length is greater or equal than * the mbuf data sise. * Check also that the total packet length is greater or equal than the - * size of an empty UDP/IP packet (sizeof(struct ether_hdr) + 20 + 8). + * size of an empty UDP/IP packet (sizeof(struct rte_ether_hdr) + + * 20 + 8). */ tx_pkt_len = 0; for (i = 0; i < nb_segs; i++) { @@ -2458,10 +2722,10 @@ set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs) } tx_pkt_len = (uint16_t)(tx_pkt_len + seg_lengths[i]); } - if (tx_pkt_len < (sizeof(struct ether_hdr) + 20 + 8)) { + if (tx_pkt_len < (sizeof(struct rte_ether_hdr) + 20 + 8)) { printf("total packet length=%u < %d - give up\n", (unsigned) tx_pkt_len, - (int)(sizeof(struct ether_hdr) + 20 + 8)); + (int)(sizeof(struct rte_ether_hdr) + 20 + 8)); return; } @@ -2645,12 +2909,122 @@ set_pkt_forwarding_mode(const char *fwd_mode_name) printf("Invalid %s packet forwarding mode\n", fwd_mode_name); } +void +add_rx_dump_callbacks(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_rx_queues; queue++) + if (!ports[portid].rx_dump_cb[queue]) + ports[portid].rx_dump_cb[queue] = + rte_eth_add_rx_callback(portid, queue, + dump_rx_pkts, NULL); +} + +void +add_tx_dump_callbacks(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_tx_queues; queue++) + if (!ports[portid].tx_dump_cb[queue]) + ports[portid].tx_dump_cb[queue] = + rte_eth_add_tx_callback(portid, queue, + dump_tx_pkts, NULL); +} + +void +remove_rx_dump_callbacks(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_rx_queues; queue++) + if (ports[portid].rx_dump_cb[queue]) { + rte_eth_remove_rx_callback(portid, queue, + ports[portid].rx_dump_cb[queue]); + ports[portid].rx_dump_cb[queue] = NULL; + } +} + +void +remove_tx_dump_callbacks(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_tx_queues; queue++) + if (ports[portid].tx_dump_cb[queue]) { + rte_eth_remove_tx_callback(portid, queue, + ports[portid].tx_dump_cb[queue]); + ports[portid].tx_dump_cb[queue] = NULL; + } +} + +void +configure_rxtx_dump_callbacks(uint16_t verbose) +{ + portid_t portid; + +#ifndef RTE_ETHDEV_RXTX_CALLBACKS + TESTPMD_LOG(ERR, "setting rxtx callbacks is not enabled\n"); + return; +#endif + + RTE_ETH_FOREACH_DEV(portid) + { + if (verbose == 1 || verbose > 2) + add_rx_dump_callbacks(portid); + else + remove_rx_dump_callbacks(portid); + if (verbose >= 2) + add_tx_dump_callbacks(portid); + else + remove_tx_dump_callbacks(portid); + } +} + void set_verbose_level(uint16_t vb_level) { printf("Change verbose level from %u to %u\n", (unsigned int) verbose_level, (unsigned int) vb_level); verbose_level = vb_level; + configure_rxtx_dump_callbacks(verbose_level); } void @@ -2748,6 +3122,33 @@ rx_vlan_filter_set(portid_t port_id, int on) ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads; } +void +rx_vlan_qinq_strip_set(portid_t port_id, int on) +{ + int diag; + int vlan_offload; + uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads; + + if (port_id_is_invalid(port_id, ENABLED_WARN)) + return; + + vlan_offload = rte_eth_dev_get_vlan_offload(port_id); + + if (on) { + vlan_offload |= ETH_QINQ_STRIP_OFFLOAD; + port_rx_offloads |= DEV_RX_OFFLOAD_QINQ_STRIP; + } else { + vlan_offload &= ~ETH_QINQ_STRIP_OFFLOAD; + port_rx_offloads &= ~DEV_RX_OFFLOAD_QINQ_STRIP; + } + + diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload); + if (diag < 0) + printf("%s(port_pi=%d, on=%d) failed " + "diag=%d\n", __func__, port_id, on, diag); + ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads; +} + int rx_vft_set(portid_t port_id, uint16_t vlan_id, int on) { @@ -2799,20 +3200,24 @@ vlan_tpid_set(portid_t port_id, enum rte_vlan_type vlan_type, uint16_t tp_id) void tx_vlan_set(portid_t port_id, uint16_t vlan_id) { - int vlan_offload; struct rte_eth_dev_info dev_info; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (vlan_id_is_invalid(vlan_id)) return; - vlan_offload = rte_eth_dev_get_vlan_offload(port_id); - if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD) { + if (ports[port_id].dev_conf.txmode.offloads & + DEV_TX_OFFLOAD_QINQ_INSERT) { printf("Error, as QinQ has been enabled.\n"); return; } - rte_eth_dev_info_get(port_id, &dev_info); + + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) + return; + if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VLAN_INSERT) == 0) { printf("Error: vlan insert is not supported by port %d\n", port_id); @@ -2827,8 +3232,8 @@ tx_vlan_set(portid_t port_id, uint16_t vlan_id) void tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer) { - int vlan_offload; struct rte_eth_dev_info dev_info; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return; @@ -2837,12 +3242,10 @@ tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer) if (vlan_id_is_invalid(vlan_id_outer)) return; - vlan_offload = rte_eth_dev_get_vlan_offload(port_id); - if (!(vlan_offload & ETH_VLAN_EXTEND_OFFLOAD)) { - printf("Error, as QinQ hasn't been enabled.\n"); + ret = eth_dev_info_get_print_err(port_id, &dev_info); + if (ret != 0) return; - } - rte_eth_dev_info_get(port_id, &dev_info); + if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_QINQ_INSERT) == 0) { printf("Error: qinq insert not supported by port %d\n", port_id); @@ -2850,7 +3253,8 @@ tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer) } tx_vlan_reset(port_id); - ports[port_id].dev_conf.txmode.offloads |= DEV_TX_OFFLOAD_QINQ_INSERT; + ports[port_id].dev_conf.txmode.offloads |= (DEV_TX_OFFLOAD_VLAN_INSERT | + DEV_TX_OFFLOAD_QINQ_INSERT); ports[port_id].tx_vlan_id = vlan_id; ports[port_id].tx_vlan_id_outer = vlan_id_outer; } @@ -3232,10 +3636,13 @@ set_queue_rate_limit(portid_t port_id, uint16_t queue_idx, uint16_t rate) { int diag; struct rte_eth_link link; + int ret; if (port_id_is_invalid(port_id, ENABLED_WARN)) return 1; - rte_eth_link_get_nowait(port_id, &link); + ret = eth_link_get_nowait_print_err(port_id, &link); + if (ret < 0) + return 1; if (rate > link.link_speed) { printf("Invalid rate value:%u bigger than link speed: %u\n", rate, link.link_speed); @@ -3296,7 +3703,7 @@ set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate, uint64_t q_msk) static int mcast_addr_pool_extend(struct rte_port *port) { - struct ether_addr *mc_pool; + struct rte_ether_addr *mc_pool; size_t mc_pool_size; /* @@ -3313,9 +3720,9 @@ mcast_addr_pool_extend(struct rte_port *port) * The previous test guarantees that port->mc_addr_nb is a multiple * of MCAST_POOL_INC. */ - mc_pool_size = sizeof(struct ether_addr) * (port->mc_addr_nb + + mc_pool_size = sizeof(struct rte_ether_addr) * (port->mc_addr_nb + MCAST_POOL_INC); - mc_pool = (struct ether_addr *) realloc(port->mc_addr_pool, + mc_pool = (struct rte_ether_addr *) realloc(port->mc_addr_pool, mc_pool_size); if (mc_pool == NULL) { printf("allocation of pool of %u multicast addresses failed\n", @@ -3329,6 +3736,14 @@ mcast_addr_pool_extend(struct rte_port *port) } +static void +mcast_addr_pool_append(struct rte_port *port, struct rte_ether_addr *mc_addr) +{ + if (mcast_addr_pool_extend(port) != 0) + return; + rte_ether_addr_copy(mc_addr, &port->mc_addr_pool[port->mc_addr_nb - 1]); +} + static void mcast_addr_pool_remove(struct rte_port *port, uint32_t addr_idx) { @@ -3344,10 +3759,10 @@ mcast_addr_pool_remove(struct rte_port *port, uint32_t addr_idx) } memmove(&port->mc_addr_pool[addr_idx], &port->mc_addr_pool[addr_idx + 1], - sizeof(struct ether_addr) * (port->mc_addr_nb - addr_idx)); + sizeof(struct rte_ether_addr) * (port->mc_addr_nb - addr_idx)); } -static void +static int eth_port_multicast_addr_list_set(portid_t port_id) { struct rte_port *port; @@ -3356,14 +3771,15 @@ eth_port_multicast_addr_list_set(portid_t port_id) port = &ports[port_id]; diag = rte_eth_dev_set_mc_addr_list(port_id, port->mc_addr_pool, port->mc_addr_nb); - if (diag == 0) - return; - printf("rte_eth_dev_set_mc_addr_list(port=%d, nb=%u) failed. diag=%d\n", - port->mc_addr_nb, port_id, -diag); + if (diag < 0) + printf("rte_eth_dev_set_mc_addr_list(port=%d, nb=%u) failed. diag=%d\n", + port_id, port->mc_addr_nb, diag); + + return diag; } void -mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr) +mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr) { struct rte_port *port; uint32_t i; @@ -3378,20 +3794,20 @@ mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr) * in the pool of multicast addresses. */ for (i = 0; i < port->mc_addr_nb; i++) { - if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) { + if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) { printf("multicast address already filtered by port\n"); return; } } - if (mcast_addr_pool_extend(port) != 0) - return; - ether_addr_copy(mc_addr, &port->mc_addr_pool[i]); - eth_port_multicast_addr_list_set(port_id); + mcast_addr_pool_append(port, mc_addr); + if (eth_port_multicast_addr_list_set(port_id) < 0) + /* Rollback on failure, remove the address from the pool */ + mcast_addr_pool_remove(port, i); } void -mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr) +mcast_addr_remove(portid_t port_id, struct rte_ether_addr *mc_addr) { struct rte_port *port; uint32_t i; @@ -3405,7 +3821,7 @@ mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr) * Search the pool of multicast MAC addresses for the removed address. */ for (i = 0; i < port->mc_addr_nb; i++) { - if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) + if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) break; } if (i == port->mc_addr_nb) { @@ -3414,7 +3830,9 @@ mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr) } mcast_addr_pool_remove(port, i); - eth_port_multicast_addr_list_set(port_id); + if (eth_port_multicast_addr_list_set(port_id) < 0) + /* Rollback on failure, add the address back into the pool */ + mcast_addr_pool_append(port, mc_addr); } void @@ -3587,3 +4005,60 @@ port_queue_region_info_display(portid_t port_id, void *buf) printf("\n\n"); } + +void +show_macs(portid_t port_id) +{ + char buf[RTE_ETHER_ADDR_FMT_SIZE]; + struct rte_eth_dev_info dev_info; + struct rte_ether_addr *addr; + uint32_t i, num_macs = 0; + struct rte_eth_dev *dev; + + dev = &rte_eth_devices[port_id]; + + rte_eth_dev_info_get(port_id, &dev_info); + + for (i = 0; i < dev_info.max_mac_addrs; i++) { + addr = &dev->data->mac_addrs[i]; + + /* skip zero address */ + if (rte_is_zero_ether_addr(addr)) + continue; + + num_macs++; + } + + printf("Number of MAC address added: %d\n", num_macs); + + for (i = 0; i < dev_info.max_mac_addrs; i++) { + addr = &dev->data->mac_addrs[i]; + + /* skip zero address */ + if (rte_is_zero_ether_addr(addr)) + continue; + + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, addr); + printf(" %s\n", buf); + } +} + +void +show_mcast_macs(portid_t port_id) +{ + char buf[RTE_ETHER_ADDR_FMT_SIZE]; + struct rte_ether_addr *addr; + struct rte_port *port; + uint32_t i; + + port = &ports[port_id]; + + printf("Number of Multicast MAC address added: %d\n", port->mc_addr_nb); + + for (i = 0; i < port->mc_addr_nb; i++) { + addr = &port->mc_addr_pool[i]; + + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, addr); + printf(" %s\n", buf); + } +}