#include <rte_malloc.h>
#include <rte_memcpy.h>
#include <rte_memory.h>
+#include <rte_ring.h>
#include "virtual_pmd.h"
static const char *virtual_ethdev_driver_name = "Virtual PMD";
struct virtual_ethdev_private {
+ struct eth_dev_ops dev_ops;
struct rte_eth_stats eth_stats;
- struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST];
- int rx_pkt_burst_len;
+ struct rte_ring *rx_queue;
+ struct rte_ring *tx_queue;
int tx_burst_fail_count;
};
}
static void virtual_ethdev_stop(struct rte_eth_dev *eth_dev __rte_unused)
{
- eth_dev->data->dev_link.link_status = 0;
+ void *pkt = NULL;
+ struct virtual_ethdev_private *prv = eth_dev->data->dev_private;
+
+ eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
eth_dev->data->dev_started = 0;
+ while (rte_ring_dequeue(prv->rx_queue, &pkt) != -ENOENT)
+ rte_pktmbuf_free(pkt);
+
+ while (rte_ring_dequeue(prv->tx_queue, &pkt) != -ENOENT)
+ rte_pktmbuf_free(pkt);
}
static void
dev_info->max_tx_queues = (uint16_t)512;
dev_info->min_rx_bufsize = 0;
- dev_info->pci_dev = NULL;
}
static int
int wait_to_complete __rte_unused)
{
if (!bonded_eth_dev->data->dev_started)
- bonded_eth_dev->data->dev_link.link_status = 0;
+ bonded_eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
return 0;
}
virtual_ethdev_stats_reset(struct rte_eth_dev *dev)
{
struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ void *pkt = NULL;
- dev_private->rx_pkt_burst_len = 0;
+ while (rte_ring_dequeue(dev_private->tx_queue, &pkt) == -ENOBUFS)
+ rte_pktmbuf_free(pkt);
/* Reset internal statistics */
memset(&dev_private->eth_stats, 0, sizeof(dev_private->eth_stats));
{}
-static struct eth_dev_ops virtual_ethdev_default_dev_ops = {
- .dev_configure = virtual_ethdev_configure_success,
- .dev_start = virtual_ethdev_start_success,
- .dev_stop = virtual_ethdev_stop,
- .dev_close = virtual_ethdev_close,
- .dev_infos_get = virtual_ethdev_info_get,
- .rx_queue_setup = virtual_ethdev_rx_queue_setup_success,
- .tx_queue_setup = virtual_ethdev_tx_queue_setup_success,
- .rx_queue_release = virtual_ethdev_rx_queue_release,
- .tx_queue_release = virtual_ethdev_tx_queue_release,
- .link_update = virtual_ethdev_link_update_success,
- .stats_get = virtual_ethdev_stats_get,
- .stats_reset = virtual_ethdev_stats_reset,
- .promiscuous_enable = virtual_ethdev_promiscuous_mode_enable,
- .promiscuous_disable = virtual_ethdev_promiscuous_mode_disable
+static const struct eth_dev_ops virtual_ethdev_default_dev_ops = {
+ .dev_configure = virtual_ethdev_configure_success,
+ .dev_start = virtual_ethdev_start_success,
+ .dev_stop = virtual_ethdev_stop,
+ .dev_close = virtual_ethdev_close,
+ .dev_infos_get = virtual_ethdev_info_get,
+ .rx_queue_setup = virtual_ethdev_rx_queue_setup_success,
+ .tx_queue_setup = virtual_ethdev_tx_queue_setup_success,
+ .rx_queue_release = virtual_ethdev_rx_queue_release,
+ .tx_queue_release = virtual_ethdev_tx_queue_release,
+ .link_update = virtual_ethdev_link_update_success,
+ .stats_get = virtual_ethdev_stats_get,
+ .stats_reset = virtual_ethdev_stats_reset,
+ .promiscuous_enable = virtual_ethdev_promiscuous_mode_enable,
+ .promiscuous_disable = virtual_ethdev_promiscuous_mode_disable
};
void
virtual_ethdev_start_fn_set_success(uint8_t port_id, uint8_t success)
{
- struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ struct eth_dev_ops *dev_ops = &dev_private->dev_ops;
if (success)
- vrtl_eth_dev->dev_ops->dev_start = virtual_ethdev_start_success;
+ dev_ops->dev_start = virtual_ethdev_start_success;
else
- vrtl_eth_dev->dev_ops->dev_start = virtual_ethdev_start_fail;
+ dev_ops->dev_start = virtual_ethdev_start_fail;
}
void
virtual_ethdev_configure_fn_set_success(uint8_t port_id, uint8_t success)
{
- struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ struct eth_dev_ops *dev_ops = &dev_private->dev_ops;
if (success)
- vrtl_eth_dev->dev_ops->dev_configure = virtual_ethdev_configure_success;
+ dev_ops->dev_configure = virtual_ethdev_configure_success;
else
- vrtl_eth_dev->dev_ops->dev_configure = virtual_ethdev_configure_fail;
+ dev_ops->dev_configure = virtual_ethdev_configure_fail;
}
void
virtual_ethdev_rx_queue_setup_fn_set_success(uint8_t port_id, uint8_t success)
{
- struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ struct eth_dev_ops *dev_ops = &dev_private->dev_ops;
if (success)
- vrtl_eth_dev->dev_ops->rx_queue_setup =
- virtual_ethdev_rx_queue_setup_success;
+ dev_ops->rx_queue_setup = virtual_ethdev_rx_queue_setup_success;
else
- vrtl_eth_dev->dev_ops->rx_queue_setup =
- virtual_ethdev_rx_queue_setup_fail;
+ dev_ops->rx_queue_setup = virtual_ethdev_rx_queue_setup_fail;
}
void
virtual_ethdev_tx_queue_setup_fn_set_success(uint8_t port_id, uint8_t success)
{
- struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ struct eth_dev_ops *dev_ops = &dev_private->dev_ops;
if (success)
- vrtl_eth_dev->dev_ops->tx_queue_setup =
- virtual_ethdev_tx_queue_setup_success;
+ dev_ops->tx_queue_setup = virtual_ethdev_tx_queue_setup_success;
else
- vrtl_eth_dev->dev_ops->tx_queue_setup =
- virtual_ethdev_tx_queue_setup_fail;
+ dev_ops->tx_queue_setup = virtual_ethdev_tx_queue_setup_fail;
}
void
virtual_ethdev_link_update_fn_set_success(uint8_t port_id, uint8_t success)
{
- struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private = dev->data->dev_private;
+ struct eth_dev_ops *dev_ops = &dev_private->dev_ops;
if (success)
- vrtl_eth_dev->dev_ops->link_update = virtual_ethdev_link_update_success;
+ dev_ops->link_update = virtual_ethdev_link_update_success;
else
- vrtl_eth_dev->dev_ops->link_update = virtual_ethdev_link_update_fail;
+ dev_ops->link_update = virtual_ethdev_link_update_fail;
}
struct virtual_ethdev_queue *pq_map;
struct virtual_ethdev_private *dev_private;
- int i;
+ int rx_count, i;
pq_map = (struct virtual_ethdev_queue *)queue;
-
vrtl_eth_dev = &rte_eth_devices[pq_map->port_id];
-
dev_private = vrtl_eth_dev->data->dev_private;
- if (dev_private->rx_pkt_burst_len > 0) {
- if (dev_private->rx_pkt_burst_len < nb_pkts) {
+ rx_count = rte_ring_dequeue_burst(dev_private->rx_queue, (void **) bufs,
+ nb_pkts);
- for (i = 0; i < dev_private->rx_pkt_burst_len; i++) {
- bufs[i] = dev_private->rx_pkt_burst[i];
- dev_private->rx_pkt_burst[i] = NULL;
- }
+ /* increments ipackets count */
+ dev_private->eth_stats.ipackets += rx_count;
- dev_private->eth_stats.ipackets = dev_private->rx_pkt_burst_len;
- }
- /* reset private burst values */
- dev_private->rx_pkt_burst_len = 0;
- }
+ /* increments ibytes count */
+ for (i = 0; i < rx_count; i++)
+ dev_private->eth_stats.ibytes += rte_pktmbuf_pkt_len(bufs[i]);
- return dev_private->eth_stats.ipackets;
+ return rx_count;
}
static uint16_t
vrtl_eth_dev = &rte_eth_devices[tx_q->port_id];
dev_private = vrtl_eth_dev->data->dev_private;
- if (vrtl_eth_dev->data->dev_link.link_status) {
- /* increment opacket count */
- dev_private->eth_stats.opackets += nb_pkts;
+ if (!vrtl_eth_dev->data->dev_link.link_status)
+ nb_pkts = 0;
+ else
+ nb_pkts = rte_ring_enqueue_burst(dev_private->tx_queue, (void **)bufs,
+ nb_pkts);
- /* free packets in burst */
- for (i = 0; i < nb_pkts; i++)
- rte_pktmbuf_free(bufs[i]);
+ /* increment opacket count */
+ dev_private->eth_stats.opackets += nb_pkts;
- return nb_pkts;
- }
+ /* increment obytes count */
+ for (i = 0; i < nb_pkts; i++)
+ dev_private->eth_stats.obytes += rte_pktmbuf_pkt_len(bufs[i]);
- return 0;
+ return nb_pkts;
}
static uint16_t
dev_private->tx_burst_fail_count = packet_fail_count;
}
+void
+virtual_ethdev_set_link_status(uint8_t port_id, uint8_t link_status)
+{
+ struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+
+ vrtl_eth_dev->data->dev_link.link_status = link_status;
+}
+
void
virtual_ethdev_simulate_link_status_interrupt(uint8_t port_id,
uint8_t link_status)
vrtl_eth_dev->data->dev_link.link_status = link_status;
- _rte_eth_dev_callback_process(vrtl_eth_dev, RTE_ETH_EVENT_INTR_LSC);
+ _rte_eth_dev_callback_process(vrtl_eth_dev, RTE_ETH_EVENT_INTR_LSC, NULL);
}
-
-
-void
+int
virtual_ethdev_add_mbufs_to_rx_queue(uint8_t port_id,
struct rte_mbuf **pkt_burst, int burst_length)
{
- struct virtual_ethdev_private *dev_private = NULL;
struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
+ struct virtual_ethdev_private *dev_private =
+ vrtl_eth_dev->data->dev_private;
- int i;
-
- dev_private = vrtl_eth_dev->data->dev_private;
+ return rte_ring_enqueue_burst(dev_private->rx_queue, (void **)pkt_burst,
+ burst_length);
+}
- for (i = 0; i < burst_length; i++)
- dev_private->rx_pkt_burst[i] = pkt_burst[i];
+int
+virtual_ethdev_get_mbufs_from_tx_queue(uint8_t port_id,
+ struct rte_mbuf **pkt_burst, int burst_length)
+{
+ struct virtual_ethdev_private *dev_private;
+ struct rte_eth_dev *vrtl_eth_dev = &rte_eth_devices[port_id];
- dev_private->rx_pkt_burst_len = burst_length;
+ dev_private = vrtl_eth_dev->data->dev_private;
+ return rte_ring_dequeue_burst(dev_private->tx_queue, (void **)pkt_burst,
+ burst_length);
}
static uint8_t
return ++sockets;
}
-
int
virtual_ethdev_create(const char *name, struct ether_addr *mac_addr,
- uint8_t socket_id)
+ uint8_t socket_id, uint8_t isr_support)
{
struct rte_pci_device *pci_dev = NULL;
struct rte_eth_dev *eth_dev = NULL;
struct eth_driver *eth_drv = NULL;
struct rte_pci_driver *pci_drv = NULL;
- struct eth_dev_ops *dev_ops = NULL;
struct rte_pci_id *id_table = NULL;
struct virtual_ethdev_private *dev_private = NULL;
+ char name_buf[RTE_RING_NAMESIZE];
/* now do all data allocation - for eth_dev structure, dummy pci driver
if (pci_drv == NULL)
goto err;
- dev_ops = rte_zmalloc_socket(name, sizeof(*dev_ops), 0, socket_id);
- if (dev_ops == NULL)
- goto err;
-
id_table = rte_zmalloc_socket(name, sizeof(*id_table), 0, socket_id);
if (id_table == NULL)
goto err;
+ id_table->device_id = 0xBEEF;
dev_private = rte_zmalloc_socket(name, sizeof(*dev_private), 0, socket_id);
if (dev_private == NULL)
goto err;
+ snprintf(name_buf, sizeof(name_buf), "%s_rxQ", name);
+ dev_private->rx_queue = rte_ring_create(name_buf, MAX_PKT_BURST, socket_id,
+ 0);
+ if (dev_private->rx_queue == NULL)
+ goto err;
+
+ snprintf(name_buf, sizeof(name_buf), "%s_txQ", name);
+ dev_private->tx_queue = rte_ring_create(name_buf, MAX_PKT_BURST, socket_id,
+ 0);
+ if (dev_private->tx_queue == NULL)
+ goto err;
+
/* reserve an ethdev entry */
eth_dev = rte_eth_dev_allocate(name);
if (eth_dev == NULL)
goto err;
- pci_dev->numa_node = socket_id;
- pci_drv->name = virtual_ethdev_driver_name;
+ pci_dev->device.numa_node = socket_id;
+ pci_drv->driver.name = virtual_ethdev_driver_name;
pci_drv->id_table = id_table;
- pci_drv->drv_flags = RTE_PCI_DRV_INTR_LSC;
+
+ if (isr_support)
+ pci_drv->drv_flags |= RTE_PCI_DRV_INTR_LSC;
+ else
+ pci_drv->drv_flags &= ~RTE_PCI_DRV_INTR_LSC;
+
eth_drv->pci_drv = (struct rte_pci_driver)(*pci_drv);
eth_dev->driver = eth_drv;
eth_dev->data->nb_rx_queues = (uint16_t)1;
eth_dev->data->nb_tx_queues = (uint16_t)1;
- TAILQ_INIT(&(eth_dev->callbacks));
-
- eth_dev->data->dev_link.link_status = 0;
- eth_dev->data->dev_link.link_speed = ETH_LINK_SPEED_10000;
+ eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
+ eth_dev->data->dev_link.link_speed = ETH_SPEED_NUM_10G;
eth_dev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX;
eth_dev->data->mac_addrs = rte_zmalloc(name, ETHER_ADDR_LEN, 0);
memcpy(eth_dev->data->mac_addrs, mac_addr,
sizeof(*eth_dev->data->mac_addrs));
- eth_dev->data->mac_addrs->addr_bytes[5] = eth_dev->data->port_id;
eth_dev->data->dev_started = 0;
eth_dev->data->promiscuous = 0;
eth_dev->data->scattered_rx = 0;
eth_dev->data->all_multicast = 0;
- memset(dev_private, 0, sizeof(*dev_private));
eth_dev->data->dev_private = dev_private;
- eth_dev->dev_ops = dev_ops;
-
/* Copy default device operation functions */
- memcpy(eth_dev->dev_ops, &virtual_ethdev_default_dev_ops,
- sizeof(*eth_dev->dev_ops));
-
- eth_dev->pci_dev = pci_dev;
- eth_dev->pci_dev->driver = ð_drv->pci_drv;
+ dev_private->dev_ops = virtual_ethdev_default_dev_ops;
+ eth_dev->dev_ops = &dev_private->dev_ops;
- eth_dev->pci_dev->driver->id_table->device_id = 0xBEEF;
+ pci_dev->device.driver = ð_drv->pci_drv.driver;
+ eth_dev->device = &pci_dev->device;
eth_dev->rx_pkt_burst = virtual_ethdev_rx_burst_success;
eth_dev->tx_pkt_burst = virtual_ethdev_tx_burst_success;
return eth_dev->data->port_id;
err:
- if (pci_dev)
- rte_free(pci_dev);
- if (pci_drv)
- rte_free(pci_drv);
- if (eth_drv)
- rte_free(eth_drv);
- if (dev_ops)
- rte_free(dev_ops);
- if (id_table)
- rte_free(id_table);
- if (dev_private)
- rte_free(dev_private);
+ rte_free(pci_dev);
+ rte_free(pci_drv);
+ rte_free(eth_drv);
+ rte_free(id_table);
+ rte_free(dev_private);
return -1;
}
git.droids-corp.org / dpdk.git / blobdiff