_(ETH_RSS_GENEVE, "geneve") \
_(ETH_RSS_NVGRE, "nvgre")
-
-#define foreach_dpdk_rx_offload_caps \
- _(DEV_RX_OFFLOAD_VLAN_STRIP, "vlan-strip") \
- _(DEV_RX_OFFLOAD_IPV4_CKSUM, "ipv4-cksum") \
- _(DEV_RX_OFFLOAD_UDP_CKSUM , "udp-cksum") \
- _(DEV_RX_OFFLOAD_TCP_CKSUM , "tcp-cksum") \
- _(DEV_RX_OFFLOAD_TCP_LRO , "rcp-lro") \
- _(DEV_RX_OFFLOAD_QINQ_STRIP, "qinq-strip") \
- _(DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM, "outer-ipv4-cksum") \
- _(DEV_RX_OFFLOAD_MACSEC_STRIP, "macsec-strip") \
- _(DEV_RX_OFFLOAD_HEADER_SPLIT, "header-split") \
- _(DEV_RX_OFFLOAD_VLAN_FILTER, "vlan-filter") \
- _(DEV_RX_OFFLOAD_VLAN_EXTEND, "vlan-extend") \
- _(DEV_RX_OFFLOAD_JUMBO_FRAME, "jumbo-frame") \
- _(DEV_RX_OFFLOAD_CRC_STRIP, "crc-strip") \
- _(DEV_RX_OFFLOAD_SCATTER, "scatter") \
- _(DEV_RX_OFFLOAD_TIMESTAMP, "timestamp") \
- _(DEV_RX_OFFLOAD_SECURITY, "security")
-
-#define foreach_dpdk_tx_offload_caps \
- _(DEV_TX_OFFLOAD_VLAN_INSERT, "vlan-insert") \
- _(DEV_TX_OFFLOAD_IPV4_CKSUM, "ipv4-cksum") \
- _(DEV_TX_OFFLOAD_UDP_CKSUM , "udp-cksum") \
- _(DEV_TX_OFFLOAD_TCP_CKSUM , "tcp-cksum") \
- _(DEV_TX_OFFLOAD_SCTP_CKSUM , "sctp-cksum") \
- _(DEV_TX_OFFLOAD_TCP_TSO , "tcp-tso") \
- _(DEV_TX_OFFLOAD_UDP_TSO , "udp-tso") \
- _(DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM, "outer-ipv4-cksum") \
- _(DEV_TX_OFFLOAD_QINQ_INSERT, "qinq-insert") \
- _(DEV_TX_OFFLOAD_VXLAN_TNL_TSO, "vxlan-tnl-tso") \
- _(DEV_TX_OFFLOAD_GRE_TNL_TSO, "gre-tnl-tso") \
- _(DEV_TX_OFFLOAD_IPIP_TNL_TSO, "ipip-tnl-tso") \
- _(DEV_TX_OFFLOAD_GENEVE_TNL_TSO, "geneve-tnl-tso") \
- _(DEV_TX_OFFLOAD_MACSEC_INSERT, "macsec-insert") \
- _(DEV_TX_OFFLOAD_MT_LOCKFREE, "mt-lockfree") \
-
#define foreach_dpdk_pkt_rx_offload_flag \
_ (PKT_RX_VLAN, "RX packet is a 802.1q VLAN packet") \
_ (PKT_RX_RSS_HASH, "RX packet with RSS hash result") \
char *devname_format;
char *device_name;
u32 i = va_arg (*args, u32);
+ dpdk_device_t *xd = vec_elt_at_index (dm->devices, i);
struct rte_eth_dev_info dev_info;
struct rte_pci_device *pci_dev;
u8 *ret;
else
devname_format = "%s%x/%x/%x";
- switch (dm->devices[i].port_type)
+ switch (xd->port_type)
{
case VNET_DPDK_PORT_TYPE_ETH_1G:
device_name = "GigabitEthernet";
break;
case VNET_DPDK_PORT_TYPE_ETH_BOND:
- return format (s, "BondEthernet%d", dm->devices[i].bond_instance_num);
+ return format (s, "BondEthernet%d", xd->bond_instance_num);
case VNET_DPDK_PORT_TYPE_ETH_SWITCH:
device_name = "EthernetSwitch";
break;
case VNET_DPDK_PORT_TYPE_AF_PACKET:
- rte_eth_dev_info_get (i, &dev_info);
- return format (s, "af_packet%d", dm->devices[i].af_packet_instance_num);
+ return format (s, "af_packet%d", xd->af_packet_instance_num);
case VNET_DPDK_PORT_TYPE_VIRTIO_USER:
device_name = "VirtioUser";
break;
}
- rte_eth_dev_info_get (i, &dev_info);
- pci_dev = RTE_DEV_TO_PCI (dev_info.device);
+ rte_eth_dev_info_get (xd->port_id, &dev_info);
+ pci_dev = dpdk_get_pci_device (&dev_info);
- if (pci_dev && dm->devices[i].port_type != VNET_DPDK_PORT_TYPE_FAILSAFE)
+ if (pci_dev && xd->port_type != VNET_DPDK_PORT_TYPE_FAILSAFE)
ret = format (s, devname_format, device_name, pci_dev->addr.bus,
pci_dev->addr.devid, pci_dev->addr.function);
else
- ret = format (s, "%s%d", device_name, dm->devices[i].port_id);
+ ret = format (s, "%s%d", device_name, xd->port_id);
- if (dm->devices[i].interface_name_suffix)
- return format (ret, "/%s", dm->devices[i].interface_name_suffix);
+ if (xd->interface_name_suffix)
+ return format (ret, "/%s", xd->interface_name_suffix);
return ret;
}
dev_type = "Cavium QLogic FastLinQ QL4xxxx";
break;
+ case VNET_DPDK_PMD_NETVSC:
+ dev_type = "Microsoft Hyper-V Netvsc";
+ break;
+
default:
case VNET_DPDK_PMD_UNKNOWN:
dev_type = "### UNKNOWN ###";
s = format (s, "%s duplex ", (l->link_duplex == ETH_LINK_FULL_DUPLEX) ?
"full" : "half");
- s = format (s, "speed %u mtu %d %s\n", l->link_speed,
- hi->max_packet_bytes, promisc ? " promisc" : "");
+ s = format (s, "mtu %d %s\n", hi->max_packet_bytes, promisc ?
+ " promisc" : "");
}
else
s = format (s, "\n");
foreach_dpdk_rss_hf return s;
}
+#undef _
+
+/* Convert to all lower case e.g "VLAN_STRIP" -> "vlan-strip"
+ Works for both vector names and null terminated c strings. */
+static u8 *
+format_offload (u8 * s, va_list * va)
+{
+ u8 *id = va_arg (*va, u8 *);
+ uword i, l;
+
+ l = ~0;
+ if (clib_mem_is_vec (id))
+ l = vec_len (id);
+
+ if (id)
+ for (i = 0; id[i] != 0 && i < l; i++)
+ {
+ u8 c = id[i];
+
+ if (c == '_')
+ c = '-';
+ else
+ c = tolower (c);
+ vec_add1 (s, c);
+ }
+
+ return s;
+}
+
+#define _(v, func) \
+if (bitmap & v) { \
+ if (format_get_indent (s) > 72) \
+ s = format(s,"\n%U", format_white_space, indent); \
+ s = format(s, "%U ", format_offload, func (v)); \
+}
+
u8 *
format_dpdk_rx_offload_caps (u8 * s, va_list * args)
{
u64 bitmap = va_arg (*args, u32);
u32 indent = format_get_indent (s);
+ uword i;
if (!bitmap)
return format (s, "none");
- foreach_dpdk_rx_offload_caps return s;
+ for (i = 0; i < 64; i++)
+ {
+ u64 mask = (u64) 1 << i;
+
+ _(mask, rte_eth_dev_rx_offload_name);
+ }
+ return s;
}
u8 *
{
u64 bitmap = va_arg (*args, u32);
u32 indent = format_get_indent (s);
+ uword i;
+
if (!bitmap)
return format (s, "none");
- foreach_dpdk_tx_offload_caps return s;
+ for (i = 0; i < 64; i++)
+ {
+ u64 mask = (u64) 1 << i;
+
+ _(mask, rte_eth_dev_tx_offload_name);
+ }
+ return s;
}
#undef _
if (rte_eth_dev_get_module_eeprom (xd->port_id, &ei) == 0)
{
- s = format (s, "%U", format_sfp_eeprom, ei.data);
+ s = format (s, "%U", format_sfp_eeprom, ei.data +
+ (mi.type == RTE_ETH_MODULE_SFF_8436 ? 0x80 : 0));
}
else
s = format (s, "eeprom read error");
rte_eth_dev_info_get (xd->port_id, &di);
s = format (s, "%U\n%Ucarrier %U",
- format_dpdk_device_type, xd->port_id,
+ format_dpdk_device_type, dev_instance,
format_white_space, indent + 2, format_dpdk_link_status, xd);
s = format (s, "%Uflags: %U\n",
format_white_space, indent + 2, format_dpdk_device_flags, xd);
retval = rte_eth_dev_rss_hash_conf_get (xd->port_id, &rss_conf);
if (retval < 0)
clib_warning ("rte_eth_dev_rss_hash_conf_get returned %d", retval);
- pci = RTE_DEV_TO_PCI (di.device);
+
+ pci = dpdk_get_pci_device (&di);
if (pci)
{
Code Review / vpp.git / blobdiff