u64 offload;
vnet_hw_if_caps_t caps;
} tx_off_caps_map[] = {
- { DEV_TX_OFFLOAD_IPV4_CKSUM, VNET_HW_IF_CAP_TX_IP4_CKSUM },
- { DEV_TX_OFFLOAD_TCP_CKSUM, VNET_HW_IF_CAP_TX_TCP_CKSUM },
- { DEV_TX_OFFLOAD_UDP_CKSUM, VNET_HW_IF_CAP_TX_UDP_CKSUM },
- { DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM, VNET_HW_IF_CAP_TX_IP4_OUTER_CKSUM },
- { DEV_TX_OFFLOAD_OUTER_UDP_CKSUM, VNET_HW_IF_CAP_TX_UDP_OUTER_CKSUM },
- { DEV_TX_OFFLOAD_TCP_TSO, VNET_HW_IF_CAP_TCP_GSO },
- { DEV_TX_OFFLOAD_VXLAN_TNL_TSO, VNET_HW_IF_CAP_VXLAN_TNL_GSO }
+ { RTE_ETH_TX_OFFLOAD_IPV4_CKSUM, VNET_HW_IF_CAP_TX_IP4_CKSUM },
+ { RTE_ETH_TX_OFFLOAD_TCP_CKSUM, VNET_HW_IF_CAP_TX_TCP_CKSUM },
+ { RTE_ETH_TX_OFFLOAD_UDP_CKSUM, VNET_HW_IF_CAP_TX_UDP_CKSUM },
+ { RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM, VNET_HW_IF_CAP_TX_IP4_OUTER_CKSUM },
+ { RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM, VNET_HW_IF_CAP_TX_UDP_OUTER_CKSUM },
+ { RTE_ETH_TX_OFFLOAD_TCP_TSO, VNET_HW_IF_CAP_TCP_GSO },
+ { RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO, VNET_HW_IF_CAP_VXLAN_TNL_GSO }
};
void
dpdk_device_error (dpdk_device_t * xd, char *str, int rv)
{
- dpdk_log_err ("Interface %U error %d: %s",
- format_dpdk_device_name, xd->port_id, rv, rte_strerror (rv));
+ dpdk_log_err ("Interface %U error %d: %s", format_dpdk_device_name,
+ xd->device_index, rv, rte_strerror (rv));
xd->errors = clib_error_return (xd->errors, "%s[port:%d, errno:%d]: %s",
str, xd->port_id, rv, rte_strerror (rv));
}
{
vlib_main_t *vm = vlib_get_main ();
vnet_main_t *vnm = vnet_get_main ();
- vlib_thread_main_t *tm = vlib_get_thread_main ();
vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, xd->sw_if_index);
vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, xd->hw_if_index);
u16 buf_sz = vlib_buffer_get_default_data_size (vm);
struct rte_eth_dev_info dev_info;
struct rte_eth_conf conf = {};
u64 rxo, txo;
- u16 mtu;
+ u32 max_frame_size;
int rv;
int j;
format_dpdk_rte_device, dev_info.device);
/* create rx and tx offload wishlist */
- rxo = DEV_RX_OFFLOAD_IPV4_CKSUM;
+ rxo = RTE_ETH_RX_OFFLOAD_IPV4_CKSUM;
txo = 0;
if (xd->conf.enable_tcp_udp_checksum)
- rxo |= DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM;
+ rxo |= RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM;
if (xd->conf.disable_tx_checksum_offload == 0 &&
xd->conf.enable_outer_checksum_offload)
- txo |= DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM | DEV_TX_OFFLOAD_OUTER_UDP_CKSUM;
+ txo |=
+ RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM | RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM;
if (xd->conf.disable_tx_checksum_offload == 0)
- txo |= DEV_TX_OFFLOAD_IPV4_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM |
- DEV_TX_OFFLOAD_UDP_CKSUM;
+ txo |= RTE_ETH_TX_OFFLOAD_IPV4_CKSUM | RTE_ETH_TX_OFFLOAD_TCP_CKSUM |
+ RTE_ETH_TX_OFFLOAD_UDP_CKSUM;
if (xd->conf.disable_multi_seg == 0)
{
- txo |= DEV_TX_OFFLOAD_MULTI_SEGS;
- rxo |= DEV_RX_OFFLOAD_SCATTER;
+ txo |= RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+ rxo |= RTE_ETH_RX_OFFLOAD_SCATTER;
#if RTE_VERSION < RTE_VERSION_NUM(21, 11, 0, 0)
rxo |= DEV_RX_OFFLOAD_JUMBO_FRAME;
#endif
}
if (xd->conf.enable_lro)
- rxo |= DEV_RX_OFFLOAD_TCP_LRO;
+ rxo |= RTE_ETH_RX_OFFLOAD_TCP_LRO;
/* per-device offload config */
if (xd->conf.enable_tso)
- txo |= DEV_TX_OFFLOAD_TCP_CKSUM | DEV_TX_OFFLOAD_TCP_TSO |
- DEV_TX_OFFLOAD_VXLAN_TNL_TSO;
+ txo |= RTE_ETH_TX_OFFLOAD_TCP_CKSUM | RTE_ETH_TX_OFFLOAD_TCP_TSO |
+ RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO;
if (xd->conf.disable_rx_scatter)
- rxo &= ~DEV_RX_OFFLOAD_SCATTER;
+ rxo &= ~RTE_ETH_RX_OFFLOAD_SCATTER;
/* mask unsupported offloads */
rxo &= dev_info.rx_offload_capa;
dpdk_log_debug ("[%u] Configured TX offloads: %U", xd->port_id,
format_dpdk_tx_offload_caps, txo);
- /* Enable flow director when flows exist */
- if (xd->supported_flow_actions &&
- (xd->flags & DPDK_DEVICE_FLAG_RX_FLOW_OFFLOAD) != 0)
- conf.fdir_conf.mode = RTE_FDIR_MODE_PERFECT;
-
/* finalize configuration */
conf.rxmode.offloads = rxo;
conf.txmode.offloads = txo;
- if (rxo & DEV_RX_OFFLOAD_TCP_LRO)
+ if (rxo & RTE_ETH_RX_OFFLOAD_TCP_LRO)
conf.rxmode.max_lro_pkt_size = xd->conf.max_lro_pkt_size;
if (xd->conf.enable_lsc_int)
if (xd->conf.enable_rxq_int)
conf.intr_conf.rxq = 1;
- conf.rxmode.mq_mode = ETH_MQ_RX_NONE;
+ conf.rxmode.mq_mode = RTE_ETH_MQ_RX_NONE;
if (xd->conf.n_rx_queues > 1)
{
if (xd->conf.disable_rss == 0)
{
- conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
+ conf.rxmode.mq_mode = RTE_ETH_MQ_RX_RSS;
conf.rx_adv_conf.rss_conf.rss_hf = xd->conf.rss_hf;
}
}
{
conf.rxmode.max_rx_pkt_len = dev_info.max_rx_pktlen;
xd->max_supported_frame_size = dev_info.max_rx_pktlen;
- mtu = xd->max_supported_frame_size - xd->driver_frame_overhead;
}
else
{
- mtu = 1500;
- xd->max_supported_frame_size = mtu + xd->driver_frame_overhead;
+ xd->max_supported_frame_size =
+ clib_min (1500 + xd->driver_frame_overhead, buf_sz);
}
#else
if (xd->conf.disable_multi_seg)
xd->max_supported_frame_size = dev_info.max_rx_pktlen;
#endif
- mtu = clib_min (xd->max_supported_frame_size - xd->driver_frame_overhead,
- ethernet_main.default_mtu);
- mtu = mtu + hi->frame_overhead - xd->driver_frame_overhead;
+ max_frame_size = clib_min (xd->max_supported_frame_size,
+ ethernet_main.default_mtu + hi->frame_overhead);
#if RTE_VERSION >= RTE_VERSION_NUM(21, 11, 0, 0)
- conf.rxmode.mtu = mtu;
+ conf.rxmode.mtu = max_frame_size - xd->driver_frame_overhead;
#endif
retry:
}
#if RTE_VERSION < RTE_VERSION_NUM(21, 11, 0, 0)
- rte_eth_dev_set_mtu (xd->port_id, mtu);
+ rte_eth_dev_set_mtu (xd->port_id,
+ max_frame_size - xd->driver_frame_overhead);
#endif
hi->max_frame_size = 0;
- vnet_hw_interface_set_max_frame_size (vnm, xd->hw_if_index,
- mtu + hi->frame_overhead);
- dpdk_log_debug ("[%u] mtu %u max_frame_size %u max max_frame_size %u "
+ vnet_hw_interface_set_max_frame_size (vnm, xd->hw_if_index, max_frame_size);
+ dpdk_log_debug ("[%u] max_frame_size %u max max_frame_size %u "
"driver_frame_overhead %u",
- xd->port_id, mtu, hi->max_frame_size,
+ xd->port_id, hi->max_frame_size,
xd->max_supported_frame_size, xd->driver_frame_overhead);
vec_validate_aligned (xd->tx_queues, xd->conf.n_tx_queues - 1,
if (rv < 0)
dpdk_device_error (xd, "rte_eth_tx_queue_setup", rv);
- if (xd->conf.n_tx_queues < tm->n_vlib_mains)
- clib_spinlock_init (&vec_elt (xd->tx_queues, j).lock);
+ clib_spinlock_init (&vec_elt (xd->tx_queues, j).lock);
}
vec_validate_aligned (xd->rx_queues, xd->conf.n_rx_queues - 1,
xd->buffer_flags =
(VLIB_BUFFER_TOTAL_LENGTH_VALID | VLIB_BUFFER_EXT_HDR_VALID);
- if ((rxo & (DEV_RX_OFFLOAD_TCP_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM)) ==
- (DEV_RX_OFFLOAD_TCP_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM))
+ if ((rxo & (RTE_ETH_RX_OFFLOAD_TCP_CKSUM | RTE_ETH_RX_OFFLOAD_UDP_CKSUM)) ==
+ (RTE_ETH_RX_OFFLOAD_TCP_CKSUM | RTE_ETH_RX_OFFLOAD_UDP_CKSUM))
xd->buffer_flags |=
(VNET_BUFFER_F_L4_CHECKSUM_COMPUTED | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
dpdk_device_flag_set (xd, DPDK_DEVICE_FLAG_RX_IP4_CKSUM,
- rxo & DEV_RX_OFFLOAD_IPV4_CKSUM);
+ rxo & RTE_ETH_RX_OFFLOAD_IPV4_CKSUM);
dpdk_device_flag_set (xd, DPDK_DEVICE_FLAG_MAYBE_MULTISEG,
- rxo & DEV_RX_OFFLOAD_SCATTER);
+ rxo & RTE_ETH_RX_OFFLOAD_SCATTER);
dpdk_device_flag_set (
xd, DPDK_DEVICE_FLAG_TX_OFFLOAD,
- (txo & (DEV_TX_OFFLOAD_TCP_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM)) ==
- (DEV_TX_OFFLOAD_TCP_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM));
+ (txo & (RTE_ETH_TX_OFFLOAD_TCP_CKSUM | RTE_ETH_TX_OFFLOAD_UDP_CKSUM)) ==
+ (RTE_ETH_TX_OFFLOAD_TCP_CKSUM | RTE_ETH_TX_OFFLOAD_UDP_CKSUM));
/* unconditionally set mac filtering cap */
caps.val = caps.mask = VNET_HW_IF_CAP_MAC_FILTER;
if (rte_eth_dev_rx_intr_enable (xd->port_id, 0))
{
dpdk_log_info ("probe for interrupt mode for device %U. Failed.\n",
- format_dpdk_device_name, xd->port_id);
+ format_dpdk_device_name, xd->device_index);
}
else
{
if (!(xd->flags & DPDK_DEVICE_FLAG_INT_UNMASKABLE))
rte_eth_dev_rx_intr_disable (xd->port_id, 0);
dpdk_log_info ("Probe for interrupt mode for device %U. Success.\n",
- format_dpdk_device_name, xd->port_id);
+ format_dpdk_device_name, xd->device_index);
}
if (xd->flags & DPDK_DEVICE_FLAG_INT_SUPPORTED)
f.flags = UNIX_FILE_EVENT_EDGE_TRIGGERED;
f.file_descriptor = rxq->efd;
f.private_data = rxq->queue_index;
- f.description =
- format (0, "%U queue %u", format_dpdk_device_name, xd->port_id, q);
+ f.description = format (0, "%U queue %u", format_dpdk_device_name,
+ xd->device_index, q);
rxq->clib_file_index = clib_file_add (&file_main, &f);
vnet_hw_if_set_rx_queue_file_index (vnm, rxq->queue_index,
rxq->clib_file_index);
rte_eth_allmulticast_enable (xd->port_id);
- dpdk_log_info ("Interface %U started",
- format_dpdk_device_name, xd->port_id);
+ dpdk_log_info ("Interface %U started", format_dpdk_device_name,
+ xd->device_index);
}
void
rte_eth_dev_stop (xd->port_id);
clib_memset (&xd->link, 0, sizeof (struct rte_eth_link));
- dpdk_log_info ("Interface %U stopped",
- format_dpdk_device_name, xd->port_id);
+ dpdk_log_info ("Interface %U stopped", format_dpdk_device_name,
+ xd->device_index);
}
void vl_api_force_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
rte_eth_link_get_nowait (port_id, &link);
u8 link_up = link.link_status;
if (link_up)
- dpdk_log_info ("Port %d Link Up - speed %u Mbps - %s",
- port_id, (unsigned) link.link_speed,
- (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
- "full-duplex" : "half-duplex");
+ dpdk_log_info ("Port %d Link Up - speed %u Mbps - %s", port_id,
+ (unsigned) link.link_speed,
+ (link.link_duplex == RTE_ETH_LINK_FULL_DUPLEX) ?
+ "full-duplex" :
+ "half-duplex");
else
dpdk_log_info ("Port %d Link Down\n\n", port_id);
const struct rte_bus *bus;
bus = rte_bus_find_by_device (info->device);
+#if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0)
+ if (bus && !strcmp (rte_bus_name (bus), "pci"))
+#else
if (bus && !strcmp (bus->name, "pci"))
+#endif
return RTE_DEV_TO_PCI (info->device);
else
return NULL;
const struct rte_bus *bus;
bus = rte_bus_find_by_device (info->device);
+#if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0)
+ if (bus && !strcmp (rte_bus_name (bus), "vmbus"))
+#else
if (bus && !strcmp (bus->name, "vmbus"))
+#endif
return container_of (info->device, struct rte_vmbus_device, device);
else
return NULL;
Code Review / vpp.git / blobdiff