{
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;
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);
void
nic_xstats_clear(portid_t port_id)
{
- rte_eth_xstats_reset(port_id);
+ int ret;
+
+ 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
nic_stats_mapping_border, nic_stats_mapping_border);
}
+static void
+burst_mode_options_display(uint64_t options)
+{
+ int offset;
+
+ while (options != 0) {
+ offset = rte_bsf64(options);
+
+ printf(" %s",
+ rte_eth_burst_mode_option_name(1ULL << offset));
+
+ options &= ~(1ULL << offset);
+ }
+}
+
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 = "*********************";
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:");
+ burst_mode_options_display(mode.options);
+ }
+
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 = "*********************";
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:");
+ burst_mode_options_display(mode.options);
+ }
+
printf("\n");
}
/* List ports with matching device name */
RTE_ETH_FOREACH_DEV_OF(port_id, dev) {
- rte_eth_macaddr_get(port_id, &mac_addr);
printf("\n\tPort id: %-2d", port_id);
- print_ethaddr("\n\tMAC address: ", &mac_addr);
+ 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");
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 (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)
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;
}
- rte_eth_link_get_nowait(port_id, &link);
- 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;
+
rte_eth_dev_get_name_by_port(port_id, name);
- rte_eth_macaddr_get(port_id, &mac_addr);
+ 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],
{
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);
{
int diag;
struct rte_eth_dev_info dev_info;
+ 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;
+
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);
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 =
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;
- 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;
{
struct rte_eth_dev_info dev_info;
uint16_t queue;
+ int ret;
if (port_id_is_invalid(portid, ENABLED_WARN))
return;
- rte_eth_dev_info_get(portid, &dev_info);
+ 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] =
{
struct rte_eth_dev_info dev_info;
uint16_t queue;
+ int ret;
if (port_id_is_invalid(portid, ENABLED_WARN))
return;
- rte_eth_dev_info_get(portid, &dev_info);
+
+ 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] =
{
struct rte_eth_dev_info dev_info;
uint16_t queue;
+ int ret;
if (port_id_is_invalid(portid, ENABLED_WARN))
return;
- rte_eth_dev_info_get(portid, &dev_info);
+
+ 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,
{
struct rte_eth_dev_info dev_info;
uint16_t queue;
+ int ret;
if (port_id_is_invalid(portid, ENABLED_WARN))
return;
- rte_eth_dev_info_get(portid, &dev_info);
+
+ 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[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)
{
tx_vlan_set(portid_t port_id, uint16_t vlan_id)
{
struct rte_eth_dev_info dev_info;
+ int ret;
if (port_id_is_invalid(port_id, ENABLED_WARN))
return;
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);
tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer)
{
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_outer))
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_QINQ_INSERT) == 0) {
printf("Error: qinq insert not supported by port %d\n",
port_id);
{
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);
git.droids-corp.org / dpdk.git / blobdiff