nic_stats_border, port_id, nic_stats_border);
if ((!port->rx_queue_stats_mapping_enabled) && (!port->tx_queue_stats_mapping_enabled)) {
- printf(" RX-packets: %-10"PRIu64" RX-errors: %-10"PRIu64"RX-bytes: "
- "%-"PRIu64"\n"
- " TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64"TX-bytes: "
+ printf(" RX-packets: %-10"PRIu64" RX-missed: %-10"PRIu64" RX-bytes: "
+ "%-"PRIu64"\n",
+ stats.ipackets, stats.imissed, stats.ibytes);
+ printf(" RX-badcrc: %-10"PRIu64" RX-badlen: %-10"PRIu64" RX-errors: "
+ "%-"PRIu64"\n",
+ stats.ibadcrc, stats.ibadlen, stats.ierrors);
+ printf(" RX-nombuf: %-10"PRIu64"\n",
+ stats.rx_nombuf);
+ printf(" TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64" TX-bytes: "
"%-"PRIu64"\n",
- stats.ipackets, stats.ierrors, stats.ibytes,
stats.opackets, stats.oerrors, stats.obytes);
}
else {
printf(" RX-packets: %10"PRIu64" RX-errors: %10"PRIu64
- " RX-bytes: %10"PRIu64"\n"
- " TX-packets: %10"PRIu64" TX-errors: %10"PRIu64
+ " RX-bytes: %10"PRIu64"\n",
+ stats.ipackets, stats.ierrors, stats.ibytes);
+ printf(" RX-badcrc: %10"PRIu64" RX-badlen: %10"PRIu64
+ " RX-errors: %10"PRIu64"\n",
+ stats.ibadcrc, stats.ibadlen, stats.ierrors);
+ printf(" RX-nombuf: %10"PRIu64"\n",
+ stats.rx_nombuf);
+ printf(" TX-packets: %10"PRIu64" TX-errors: %10"PRIu64
" TX-bytes: %10"PRIu64"\n",
- stats.ipackets, stats.ierrors, stats.ibytes,
stats.opackets, stats.oerrors, stats.obytes);
}
port_infos_display(portid_t port_id)
{
struct rte_port *port;
+ struct ether_addr mac_addr;
struct rte_eth_link link;
int vlan_offload;
struct rte_mempool * mp;
rte_eth_link_get_nowait(port_id, &link);
printf("\n%s Infos for port %-2d %s\n",
info_border, port_id, info_border);
- print_ethaddr("MAC address: ", &port->eth_addr);
+ rte_eth_macaddr_get(port_id, &mac_addr);
+ print_ethaddr("MAC address: ", &mac_addr);
printf("\nConnect to socket: %u", port->socket_id);
if (port_numa[port_id] != NUMA_NO_CONFIG) {
}
}
-static int
+int
port_id_is_invalid(portid_t port_id)
{
if (port_id < nb_ports)
display_port_reg_value(port_id, reg_off, reg_v);
}
+void
+port_mtu_set(portid_t port_id, uint16_t mtu)
+{
+ int diag;
+
+ if (port_id_is_invalid(port_id))
+ return;
+ diag = rte_eth_dev_set_mtu(port_id, mtu);
+ if (diag == 0)
+ return;
+ printf("Set MTU failed. diag=%d\n", diag);
+}
+
/*
* RX/TX ring descriptors display functions.
*/
-static int
+int
rx_queue_id_is_invalid(queueid_t rxq_id)
{
if (rxq_id < nb_rxq)
return 1;
}
-static int
+int
tx_queue_id_is_invalid(queueid_t txq_id)
{
if (txq_id < nb_txq)
char mz_name[RTE_MEMZONE_NAMESIZE];
const struct rte_memzone *mz;
- rte_snprintf(mz_name, sizeof(mz_name), "%s_%s_%d_%d",
+ snprintf(mz_name, sizeof(mz_name), "%s_%s_%d_%d",
ports[port_id].dev_info.driver_name, ring_name, port_id, q_id);
mz = rte_memzone_lookup(mz_name);
if (mz == NULL)
} words;
};
-struct igb_ring_desc {
+struct igb_ring_desc_32_bytes {
union igb_ring_dword lo_dword;
union igb_ring_dword hi_dword;
+ union igb_ring_dword resv1;
+ union igb_ring_dword resv2;
};
+struct igb_ring_desc_16_bytes {
+ union igb_ring_dword lo_dword;
+ union igb_ring_dword hi_dword;
+};
+
+static void
+ring_rxd_display_dword(union igb_ring_dword dword)
+{
+ printf(" 0x%08X - 0x%08X\n", (unsigned)dword.words.lo,
+ (unsigned)dword.words.hi);
+}
+
static void
-ring_descriptor_display(const struct rte_memzone *ring_mz, uint16_t desc_id)
+ring_rx_descriptor_display(const struct rte_memzone *ring_mz,
+#ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC
+ uint8_t port_id,
+#else
+ __rte_unused uint8_t port_id,
+#endif
+ uint16_t desc_id)
+{
+ struct igb_ring_desc_16_bytes *ring =
+ (struct igb_ring_desc_16_bytes *)ring_mz->addr;
+#ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC
+ struct rte_eth_dev_info dev_info;
+
+ memset(&dev_info, 0, sizeof(dev_info));
+ rte_eth_dev_info_get(port_id, &dev_info);
+ if (strstr(dev_info.driver_name, "i40e") != NULL) {
+ /* 32 bytes RX descriptor, i40e only */
+ struct igb_ring_desc_32_bytes *ring =
+ (struct igb_ring_desc_32_bytes *)ring_mz->addr;
+
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].lo_dword));
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].hi_dword));
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].resv1));
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].resv2));
+ return;
+ }
+#endif
+ /* 16 bytes RX descriptor */
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].lo_dword));
+ ring_rxd_display_dword(rte_le_to_cpu_64(
+ ring[desc_id].hi_dword));
+}
+
+static void
+ring_tx_descriptor_display(const struct rte_memzone *ring_mz, uint16_t desc_id)
{
- struct igb_ring_desc *ring;
- struct igb_ring_desc rd;
+ struct igb_ring_desc_16_bytes *ring;
+ struct igb_ring_desc_16_bytes txd;
- ring = (struct igb_ring_desc *) ring_mz->addr;
- rd.lo_dword = rte_le_to_cpu_64(ring[desc_id].lo_dword);
- rd.hi_dword = rte_le_to_cpu_64(ring[desc_id].hi_dword);
+ ring = (struct igb_ring_desc_16_bytes *)ring_mz->addr;
+ txd.lo_dword = rte_le_to_cpu_64(ring[desc_id].lo_dword);
+ txd.hi_dword = rte_le_to_cpu_64(ring[desc_id].hi_dword);
printf(" 0x%08X - 0x%08X / 0x%08X - 0x%08X\n",
- (unsigned)rd.lo_dword.words.lo, (unsigned)rd.lo_dword.words.hi,
- (unsigned)rd.hi_dword.words.lo, (unsigned)rd.hi_dword.words.hi);
+ (unsigned)txd.lo_dword.words.lo,
+ (unsigned)txd.lo_dword.words.hi,
+ (unsigned)txd.hi_dword.words.lo,
+ (unsigned)txd.hi_dword.words.hi);
}
void
rx_mz = ring_dma_zone_lookup("rx_ring", port_id, rxq_id);
if (rx_mz == NULL)
return;
- ring_descriptor_display(rx_mz, rxd_id);
+ ring_rx_descriptor_display(rx_mz, port_id, rxd_id);
}
void
tx_mz = ring_dma_zone_lookup("tx_ring", port_id, txq_id);
if (tx_mz == NULL)
return;
- ring_descriptor_display(tx_mz, txd_id);
+ ring_tx_descriptor_display(tx_mz, txd_id);
}
void
ports[port_id].tx_ol_flags &= ~PKT_TX_VLAN_PKT;
}
+void
+tx_vlan_pvid_set(portid_t port_id, uint16_t vlan_id, int on)
+{
+ if (port_id_is_invalid(port_id))
+ return;
+
+ rte_eth_dev_set_vlan_pvid(port_id, vlan_id, on);
+}
+
void
set_qmap(portid_t port_id, uint8_t is_rx, uint16_t queue_id, uint8_t map_value)
{
"diag=%d\n", port_id, diag);
}
+int
+set_queue_rate_limit(portid_t port_id, uint16_t queue_idx, uint16_t rate)
+{
+ int diag;
+ struct rte_eth_link link;
+
+ if (port_id_is_invalid(port_id))
+ return 1;
+ rte_eth_link_get_nowait(port_id, &link);
+ if (rate > link.link_speed) {
+ printf("Invalid rate value:%u bigger than link speed: %u\n",
+ rate, link.link_speed);
+ return 1;
+ }
+ diag = rte_eth_set_queue_rate_limit(port_id, queue_idx, rate);
+ if (diag == 0)
+ return diag;
+ printf("rte_eth_set_queue_rate_limit for port_id=%d failed diag=%d\n",
+ port_id, diag);
+ return diag;
+}
+
+int
+set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate, uint64_t q_msk)
+{
+ int diag;
+ struct rte_eth_link link;
+
+ if (q_msk == 0)
+ return 0;
+
+ if (port_id_is_invalid(port_id))
+ return 1;
+ rte_eth_link_get_nowait(port_id, &link);
+ if (rate > link.link_speed) {
+ printf("Invalid rate value:%u bigger than link speed: %u\n",
+ rate, link.link_speed);
+ return 1;
+ }
+ diag = rte_eth_set_vf_rate_limit(port_id, vf, rate, q_msk);
+ if (diag == 0)
+ return diag;
+ printf("rte_eth_set_vf_rate_limit for port_id=%d failed diag=%d\n",
+ port_id, diag);
+ return diag;
+}
+
+void
+get_ethertype_filter(uint8_t port_id, uint16_t index)
+{
+ struct rte_ethertype_filter filter;
+ int ret = 0;
+ uint16_t rx_queue;
+
+ memset(&filter, 0, sizeof(filter));
+ ret = rte_eth_dev_get_ethertype_filter(port_id, index,
+ &filter, &rx_queue);
+ if (ret < 0) {
+ if (ret == (-ENOENT))
+ printf("filter[%d] is not enabled\n", index);
+ else
+ printf("get ethertype filter fails(%s)\n", strerror(-ret));
+ return;
+ } else {
+ printf("filter[%d]:\n", index);
+ printf(" ethertype: 0x%04x\n",
+ rte_le_to_cpu_32(filter.ethertype));
+ printf(" priority: %s, %d\n",
+ filter.priority_en ? "enable" : "disable",
+ filter.priority);
+ printf(" queue: %d\n", rx_queue);
+ }
+}
+
+void
+get_syn_filter(uint8_t port_id)
+{
+ struct rte_syn_filter filter;
+ int ret = 0;
+ uint16_t rx_queue;
+
+ memset(&filter, 0, sizeof(filter));
+ ret = rte_eth_dev_get_syn_filter(port_id, &filter, &rx_queue);
+
+ if (ret < 0) {
+ if (ret == (-ENOENT))
+ printf("syn filter is not enabled\n");
+ else
+ printf("get syn filter fails(%s)\n", strerror(-ret));
+ return;
+ }
+ printf("syn filter: priority: %s, queue: %d\n",
+ filter.hig_pri ? "high" : "low",
+ rx_queue);
+}
+void
+get_2tuple_filter(uint8_t port_id, uint16_t index)
+{
+ struct rte_2tuple_filter filter;
+ int ret = 0;
+ uint16_t rx_queue;
+
+ memset(&filter, 0, sizeof(filter));
+ ret = rte_eth_dev_get_2tuple_filter(port_id, index,
+ &filter, &rx_queue);
+ if (ret < 0) {
+ if (ret == (-ENOENT))
+ printf("filter[%d] is not enabled\n", index);
+ else
+ printf("get 2tuple filter fails(%s)\n", strerror(-ret));
+ return;
+ } else {
+ printf("filter[%d]:\n", index);
+ printf(" Destination Port: 0x%04x mask: %d\n",
+ rte_be_to_cpu_16(filter.dst_port),
+ filter.dst_port_mask ? 0 : 1);
+ printf(" protocol: 0x%02x mask:%d tcp_flags: 0x%02x\n",
+ filter.protocol, filter.protocol_mask ? 0 : 1,
+ filter.tcp_flags);
+ printf(" priority: %d queue: %d\n",
+ filter.priority, rx_queue);
+ }
+}
+
+void
+get_5tuple_filter(uint8_t port_id, uint16_t index)
+{
+ struct rte_5tuple_filter filter;
+ int ret = 0;
+ uint16_t rx_queue;
+
+ memset(&filter, 0, sizeof(filter));
+ ret = rte_eth_dev_get_5tuple_filter(port_id, index,
+ &filter, &rx_queue);
+ if (ret < 0) {
+ if (ret == (-ENOENT))
+ printf("filter[%d] is not enabled\n", index);
+ else
+ printf("get 5tuple filter fails(%s)\n", strerror(-ret));
+ return;
+ } else {
+ printf("filter[%d]:\n", index);
+ printf(" Destination IP: 0x%08x mask: %d\n",
+ (unsigned)rte_be_to_cpu_32(filter.dst_ip),
+ filter.dst_ip_mask ? 0 : 1);
+ printf(" Source IP: 0x%08x mask: %d\n",
+ (unsigned)rte_be_to_cpu_32(filter.src_ip),
+ filter.src_ip_mask ? 0 : 1);
+ printf(" Destination Port: 0x%04x mask: %d\n",
+ rte_be_to_cpu_16(filter.dst_port),
+ filter.dst_port_mask ? 0 : 1);
+ printf(" Source Port: 0x%04x mask: %d\n",
+ rte_be_to_cpu_16(filter.src_port),
+ filter.src_port_mask ? 0 : 1);
+ printf(" protocol: 0x%02x mask: %d\n",
+ filter.protocol,
+ filter.protocol_mask ? 0 : 1);
+ printf(" priority: %d flags: 0x%02x queue: %d\n",
+ filter.priority, filter.tcp_flags, rx_queue);
+ }
+}
+void
+get_flex_filter(uint8_t port_id, uint16_t index)
+
+{
+ struct rte_flex_filter filter;
+ int ret = 0;
+ uint16_t rx_queue;
+ int i, j;
+
+ memset(&filter, 0, sizeof(filter));
+ ret = rte_eth_dev_get_flex_filter(port_id, index,
+ &filter, &rx_queue);
+ if (ret < 0) {
+ if (ret == (-ENOENT))
+ printf("filter[%d] is not enabled\n", index);
+ else
+ printf("get flex filter fails(%s)\n", strerror(-ret));
+ return;
+ } else {
+ printf("filter[%d]: ", index);
+ printf("\n length: %d", filter.len);
+ printf("\n dword[]: 0x");
+ for (i = 0; i < 32; i++)
+ printf("%08x ", (unsigned)rte_be_to_cpu_32(filter.dwords[i]));
+ printf("\n mask[]: 0b");
+ for (i = 0; i < 16; i++) {
+ for (j = 0; j < 8; j++)
+ printf("%c", (filter.mask[i] & (1 << j)) ? '1' : '0');
+ }
+ printf("\n priority: %d queue: %d\n",
+ filter.priority, rx_queue);
+ }
+}
git.droids-corp.org / dpdk.git / blobdiff