Each virtio device could have multiple queues, say 2 or 4, at most 8.
Enabling this feature allows virtio device/port on guest has the ability to
use different vCPU to receive/transmit packets from/to each queue.

In multiple queues mode, virtio device readiness means all queues of
this virtio device are ready, cleanup/destroy a virtio device also
requires clearing all queues belong to it.

Signed-off-by: Changchun Ouyang <changchun.ouyang at intel.com>
---
 lib/librte_vhost/rte_virtio_net.h             |  15 +++-
 lib/librte_vhost/vhost_rxtx.c                 |  32 +++----
 lib/librte_vhost/vhost_user/virtio-net-user.c |  41 ++++-----
 lib/librte_vhost/virtio-net.c                 | 117 +++++++++++++++++---------
 4 files changed, 131 insertions(+), 74 deletions(-)

diff --git a/lib/librte_vhost/rte_virtio_net.h 
b/lib/librte_vhost/rte_virtio_net.h
index 2fc1c44..5fb6006 100644
--- a/lib/librte_vhost/rte_virtio_net.h
+++ b/lib/librte_vhost/rte_virtio_net.h
@@ -58,6 +58,10 @@
 /* Backend value set by guest. */
 #define VIRTIO_DEV_STOPPED -1

+/**
+ * Maximum number of virtqueues per device.
+ */
+#define VIRTIO_MAX_VIRTQUEUES 8

 /* Enum for virtqueue management. */
 enum {VIRTIO_RXQ, VIRTIO_TXQ, VIRTIO_QNUM};
@@ -95,13 +99,14 @@ struct vhost_virtqueue {
  * Device structure contains all configuration information relating to the 
device.
  */
 struct virtio_net {
-       struct vhost_virtqueue  *virtqueue[VIRTIO_QNUM];        /**< Contains 
all virtqueue information. */
        struct virtio_memory    *mem;           /**< QEMU memory and memory 
region information. */
+       struct vhost_virtqueue  *virtqueue[VIRTIO_QNUM * 
VIRTIO_MAX_VIRTQUEUES]; /**< Contains all virtqueue information. */
        uint64_t                features;       /**< Negotiated feature set. */
        uint64_t                device_fh;      /**< device identifier. */
        uint32_t                flags;          /**< Device flags. Only used to 
check if device is running on data core. */
 #define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)
        char                    ifname[IF_NAME_SZ];     /**< Name of the tap 
device or socket path. */
+       uint32_t                num_virt_queues;
        void                    *priv;          /**< private context */
 } __rte_cache_aligned;

@@ -215,4 +220,12 @@ uint16_t rte_vhost_enqueue_burst(struct virtio_net *dev, 
uint16_t queue_id,
 uint16_t rte_vhost_dequeue_burst(struct virtio_net *dev, uint16_t queue_id,
        struct rte_mempool *mbuf_pool, struct rte_mbuf **pkts, uint16_t count);

+/**
+ * This function get the queue number of one vhost device.
+ * @param q_number
+ *  queue number one vhost device.
+ * @return
+ *  0 if success, -1 if q_number exceed the max.
+ */
+int rte_vhost_q_num_get(uint32_t q_number);
 #endif /* _VIRTIO_NET_H_ */
diff --git a/lib/librte_vhost/vhost_rxtx.c b/lib/librte_vhost/vhost_rxtx.c
index 535c7a1..d8dd5ec 100644
--- a/lib/librte_vhost/vhost_rxtx.c
+++ b/lib/librte_vhost/vhost_rxtx.c
@@ -67,12 +67,12 @@ virtio_dev_rx(struct virtio_net *dev, uint16_t queue_id,
        uint8_t success = 0;

        LOG_DEBUG(VHOST_DATA, "(%"PRIu64") virtio_dev_rx()\n", dev->device_fh);
-       if (unlikely(queue_id != VIRTIO_RXQ)) {
-               LOG_DEBUG(VHOST_DATA, "mq isn't supported in this version.\n");
-               return 0;
+       if (unlikely(queue_id >= VIRTIO_QNUM * dev->num_virt_queues)) {
+               LOG_DEBUG(VHOST_DATA, "queue id: %d invalid.\n", queue_id);
+               return -1;
        }

-       vq = dev->virtqueue[VIRTIO_RXQ];
+       vq = dev->virtqueue[queue_id];
        count = (count > MAX_PKT_BURST) ? MAX_PKT_BURST : count;

        /*
@@ -185,8 +185,9 @@ virtio_dev_rx(struct virtio_net *dev, uint16_t queue_id,
 }

 static inline uint32_t __attribute__((always_inline))
-copy_from_mbuf_to_vring(struct virtio_net *dev, uint16_t res_base_idx,
-       uint16_t res_end_idx, struct rte_mbuf *pkt)
+copy_from_mbuf_to_vring(struct virtio_net *dev, uint16_t queue_id,
+       uint16_t res_base_idx, uint16_t res_end_idx,
+       struct rte_mbuf *pkt)
 {
        uint32_t vec_idx = 0;
        uint32_t entry_success = 0;
@@ -214,9 +215,9 @@ copy_from_mbuf_to_vring(struct virtio_net *dev, uint16_t 
res_base_idx,
         * Convert from gpa to vva
         * (guest physical addr -> vhost virtual addr)
         */
-       vq = dev->virtqueue[VIRTIO_RXQ];
        vb_addr =
                gpa_to_vva(dev, vq->buf_vec[vec_idx].buf_addr);
+       vq = dev->virtqueue[queue_id];
        vb_hdr_addr = vb_addr;

        /* Prefetch buffer address. */
@@ -404,11 +405,12 @@ virtio_dev_merge_rx(struct virtio_net *dev, uint16_t 
queue_id,

        LOG_DEBUG(VHOST_DATA, "(%"PRIu64") virtio_dev_merge_rx()\n",
                dev->device_fh);
-       if (unlikely(queue_id != VIRTIO_RXQ)) {
-               LOG_DEBUG(VHOST_DATA, "mq isn't supported in this version.\n");
+       if (unlikely(queue_id >= VIRTIO_QNUM * dev->num_virt_queues)) {
+               LOG_DEBUG(VHOST_DATA, "queue id: %d invalid.\n", queue_id);
+               return -1;
        }

-       vq = dev->virtqueue[VIRTIO_RXQ];
+       vq = dev->virtqueue[queue_id];
        count = RTE_MIN((uint32_t)MAX_PKT_BURST, count);

        if (count == 0)
@@ -490,7 +492,7 @@ virtio_dev_merge_rx(struct virtio_net *dev, uint16_t 
queue_id,

                res_end_idx = res_cur_idx;

-               entry_success = copy_from_mbuf_to_vring(dev, res_base_idx,
+               entry_success = copy_from_mbuf_to_vring(dev, queue_id, 
res_base_idx,
                        res_end_idx, pkts[pkt_idx]);

                rte_compiler_barrier();
@@ -537,12 +539,12 @@ rte_vhost_dequeue_burst(struct virtio_net *dev, uint16_t 
queue_id,
        uint16_t free_entries, entry_success = 0;
        uint16_t avail_idx;

-       if (unlikely(queue_id != VIRTIO_TXQ)) {
-               LOG_DEBUG(VHOST_DATA, "mq isn't supported in this version.\n");
-               return 0;
+       if (unlikely(queue_id >= VIRTIO_QNUM * dev->num_virt_queues)) {
+               LOG_DEBUG(VHOST_DATA, "queue id:%d invalid.\n", queue_id);
+               return -1;
        }

-       vq = dev->virtqueue[VIRTIO_TXQ];
+       vq = dev->virtqueue[queue_id];
        avail_idx =  *((volatile uint16_t *)&vq->avail->idx);

        /* If there are no available buffers then return. */
diff --git a/lib/librte_vhost/vhost_user/virtio-net-user.c 
b/lib/librte_vhost/vhost_user/virtio-net-user.c
index 465d3ef..031712c 100644
--- a/lib/librte_vhost/vhost_user/virtio-net-user.c
+++ b/lib/librte_vhost/vhost_user/virtio-net-user.c
@@ -209,22 +209,29 @@ static int
 virtio_is_ready(struct virtio_net *dev)
 {
        struct vhost_virtqueue *rvq, *tvq;
+       uint32_t q_idx;

        /* mq support in future.*/
-       rvq = dev->virtqueue[VIRTIO_RXQ];
-       tvq = dev->virtqueue[VIRTIO_TXQ];
-       if (rvq && tvq && rvq->desc && tvq->desc &&
-               (rvq->kickfd != (eventfd_t)-1) &&
-               (rvq->callfd != (eventfd_t)-1) &&
-               (tvq->kickfd != (eventfd_t)-1) &&
-               (tvq->callfd != (eventfd_t)-1)) {
-               RTE_LOG(INFO, VHOST_CONFIG,
-                       "virtio is now ready for processing.\n");
-               return 1;
+       for (q_idx = 0; q_idx < dev->num_virt_queues; q_idx++) {
+                uint32_t virt_rx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_RXQ;
+                uint32_t virt_tx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_TXQ;
+
+               rvq = dev->virtqueue[virt_rx_q_idx];
+               tvq = dev->virtqueue[virt_tx_q_idx];
+               if ((rvq == NULL) || (tvq == NULL) ||
+                       (rvq->desc == NULL) || (tvq->desc == NULL) ||
+                       (rvq->kickfd == (eventfd_t)-1) ||
+                       (rvq->callfd == (eventfd_t)-1) ||
+                       (tvq->kickfd == (eventfd_t)-1) ||
+                       (tvq->callfd == (eventfd_t)-1)) {
+                       RTE_LOG(INFO, VHOST_CONFIG,
+                               "virtio isn't ready for processing.\n");
+                       return 0;
+               }
        }
        RTE_LOG(INFO, VHOST_CONFIG,
-               "virtio isn't ready for processing.\n");
-       return 0;
+               "virtio is now ready for processing.\n");
+       return 1;
 }

 void
@@ -290,13 +297,9 @@ user_get_vring_base(struct vhost_device_ctx ctx,
         * sent and only sent in vhost_vring_stop.
         * TODO: cleanup the vring, it isn't usable since here.
         */
-       if (((int)dev->virtqueue[VIRTIO_RXQ]->kickfd) >= 0) {
-               close(dev->virtqueue[VIRTIO_RXQ]->kickfd);
-               dev->virtqueue[VIRTIO_RXQ]->kickfd = (eventfd_t)-1;
-       }
-       if (((int)dev->virtqueue[VIRTIO_TXQ]->kickfd) >= 0) {
-               close(dev->virtqueue[VIRTIO_TXQ]->kickfd);
-               dev->virtqueue[VIRTIO_TXQ]->kickfd = (eventfd_t)-1;
+       if (((int)dev->virtqueue[state->index]->kickfd) >= 0) {
+               close(dev->virtqueue[state->index]->kickfd);
+               dev->virtqueue[state->index]->kickfd = (eventfd_t)-1;
        }

        return 0;
diff --git a/lib/librte_vhost/virtio-net.c b/lib/librte_vhost/virtio-net.c
index 4672e67..55b7440 100644
--- a/lib/librte_vhost/virtio-net.c
+++ b/lib/librte_vhost/virtio-net.c
@@ -66,9 +66,11 @@ static struct virtio_net_config_ll *ll_root;
 /* Features supported by this lib. */
 #define VHOST_SUPPORTED_FEATURES ((1ULL << VIRTIO_NET_F_MRG_RXBUF) | \
                                (1ULL << VIRTIO_NET_F_CTRL_VQ) | \
-                               (1ULL << VIRTIO_NET_F_CTRL_RX))
+                               (1ULL << VIRTIO_NET_F_CTRL_RX) | \
+                               (1ULL << VIRTIO_NET_F_MQ))
 static uint64_t VHOST_FEATURES = VHOST_SUPPORTED_FEATURES;

+static uint32_t q_num = 1;

 /*
  * Converts QEMU virtual address to Vhost virtual address. This function is
@@ -177,6 +179,8 @@ add_config_ll_entry(struct virtio_net_config_ll *new_ll_dev)
 static void
 cleanup_device(struct virtio_net *dev)
 {
+       uint32_t q_idx;
+
        /* Unmap QEMU memory file if mapped. */
        if (dev->mem) {
                munmap((void *)(uintptr_t)dev->mem->mapped_address,
@@ -185,14 +189,18 @@ cleanup_device(struct virtio_net *dev)
        }

        /* Close any event notifiers opened by device. */
-       if ((int)dev->virtqueue[VIRTIO_RXQ]->callfd >= 0)
-               close((int)dev->virtqueue[VIRTIO_RXQ]->callfd);
-       if ((int)dev->virtqueue[VIRTIO_RXQ]->kickfd >= 0)
-               close((int)dev->virtqueue[VIRTIO_RXQ]->kickfd);
-       if ((int)dev->virtqueue[VIRTIO_TXQ]->callfd >= 0)
-               close((int)dev->virtqueue[VIRTIO_TXQ]->callfd);
-       if ((int)dev->virtqueue[VIRTIO_TXQ]->kickfd >= 0)
-               close((int)dev->virtqueue[VIRTIO_TXQ]->kickfd);
+       for (q_idx = 0; q_idx < dev->num_virt_queues; q_idx++) {
+               uint32_t virt_rx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_RXQ;
+               uint32_t virt_tx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_TXQ;
+               if ((int)dev->virtqueue[virt_rx_q_idx]->callfd >= 0)
+                       close((int)dev->virtqueue[virt_rx_q_idx]->callfd);
+               if ((int)dev->virtqueue[virt_rx_q_idx]->kickfd >= 0)
+                       close((int)dev->virtqueue[virt_rx_q_idx]->kickfd);
+               if ((int)dev->virtqueue[virt_tx_q_idx]->callfd >= 0)
+                       close((int)dev->virtqueue[virt_tx_q_idx]->callfd);
+               if ((int)dev->virtqueue[virt_tx_q_idx]->kickfd >= 0)
+                       close((int)dev->virtqueue[virt_tx_q_idx]->kickfd);
+       }
 }

 /*
@@ -201,7 +209,10 @@ cleanup_device(struct virtio_net *dev)
 static void
 free_device(struct virtio_net_config_ll *ll_dev)
 {
-       /* Free any malloc'd memory */
+       /*
+        * Free any malloc'd memory, just need free once even in multi Q case
+        * as they are malloc'd once.
+        */
        free(ll_dev->dev.virtqueue[VIRTIO_RXQ]);
        free(ll_dev->dev.virtqueue[VIRTIO_TXQ]);
        free(ll_dev);
@@ -243,6 +254,7 @@ static void
 init_device(struct virtio_net *dev)
 {
        uint64_t vq_offset;
+       uint32_t q_idx;

        /*
         * Virtqueues have already been malloced so
@@ -253,17 +265,24 @@ init_device(struct virtio_net *dev)
        /* Set everything to 0. */
        memset((void *)(uintptr_t)((uint64_t)(uintptr_t)dev + vq_offset), 0,
                (sizeof(struct virtio_net) - (size_t)vq_offset));
-       memset(dev->virtqueue[VIRTIO_RXQ], 0, sizeof(struct vhost_virtqueue));
-       memset(dev->virtqueue[VIRTIO_TXQ], 0, sizeof(struct vhost_virtqueue));

-       dev->virtqueue[VIRTIO_RXQ]->kickfd = (eventfd_t)-1;
-       dev->virtqueue[VIRTIO_RXQ]->callfd = (eventfd_t)-1;
-       dev->virtqueue[VIRTIO_TXQ]->kickfd = (eventfd_t)-1;
-       dev->virtqueue[VIRTIO_TXQ]->callfd = (eventfd_t)-1;
+       dev->num_virt_queues = q_num;
+
+       for (q_idx = 0; q_idx < dev->num_virt_queues; q_idx++) {
+               uint32_t virt_rx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_RXQ;
+               uint32_t virt_tx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_TXQ;
+               memset(dev->virtqueue[virt_rx_q_idx], 0, sizeof(struct 
vhost_virtqueue));
+               memset(dev->virtqueue[virt_tx_q_idx], 0, sizeof(struct 
vhost_virtqueue));

-       /* Backends are set to -1 indicating an inactive device. */
-       dev->virtqueue[VIRTIO_RXQ]->backend = VIRTIO_DEV_STOPPED;
-       dev->virtqueue[VIRTIO_TXQ]->backend = VIRTIO_DEV_STOPPED;
+               dev->virtqueue[virt_rx_q_idx]->kickfd = (eventfd_t)-1;
+               dev->virtqueue[virt_rx_q_idx]->callfd = (eventfd_t)-1;
+               dev->virtqueue[virt_tx_q_idx]->kickfd = (eventfd_t)-1;
+               dev->virtqueue[virt_tx_q_idx]->callfd = (eventfd_t)-1;
+
+               /* Backends are set to -1 indicating an inactive device. */
+               dev->virtqueue[virt_rx_q_idx]->backend = VIRTIO_DEV_STOPPED;
+               dev->virtqueue[virt_tx_q_idx]->backend = VIRTIO_DEV_STOPPED;
+       }
 }

 /*
@@ -276,6 +295,7 @@ new_device(struct vhost_device_ctx ctx)
 {
        struct virtio_net_config_ll *new_ll_dev;
        struct vhost_virtqueue *virtqueue_rx, *virtqueue_tx;
+       uint32_t q_idx;

        /* Setup device and virtqueues. */
        new_ll_dev = malloc(sizeof(struct virtio_net_config_ll));
@@ -286,7 +306,7 @@ new_device(struct vhost_device_ctx ctx)
                return -1;
        }

-       virtqueue_rx = malloc(sizeof(struct vhost_virtqueue));
+       virtqueue_rx = malloc(sizeof(struct vhost_virtqueue) * q_num);
        if (virtqueue_rx == NULL) {
                free(new_ll_dev);
                RTE_LOG(ERR, VHOST_CONFIG,
@@ -295,7 +315,7 @@ new_device(struct vhost_device_ctx ctx)
                return -1;
        }

-       virtqueue_tx = malloc(sizeof(struct vhost_virtqueue));
+       virtqueue_tx = malloc(sizeof(struct vhost_virtqueue) * q_num);
        if (virtqueue_tx == NULL) {
                free(virtqueue_rx);
                free(new_ll_dev);
@@ -305,8 +325,13 @@ new_device(struct vhost_device_ctx ctx)
                return -1;
        }

-       new_ll_dev->dev.virtqueue[VIRTIO_RXQ] = virtqueue_rx;
-       new_ll_dev->dev.virtqueue[VIRTIO_TXQ] = virtqueue_tx;
+       memset(new_ll_dev->dev.virtqueue, 0, sizeof(new_ll_dev->dev.virtqueue));
+       for (q_idx = 0; q_idx < q_num; q_idx++) {
+               uint32_t virt_rx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_RXQ;
+               uint32_t virt_tx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_TXQ;
+               new_ll_dev->dev.virtqueue[virt_rx_q_idx] = virtqueue_rx + q_idx;
+               new_ll_dev->dev.virtqueue[virt_tx_q_idx] = virtqueue_tx + q_idx;
+       }

        /* Initialise device and virtqueues. */
        init_device(&new_ll_dev->dev);
@@ -429,6 +454,7 @@ static int
 set_features(struct vhost_device_ctx ctx, uint64_t *pu)
 {
        struct virtio_net *dev;
+       uint32_t q_idx;

        dev = get_device(ctx);
        if (dev == NULL)
@@ -440,22 +466,26 @@ set_features(struct vhost_device_ctx ctx, uint64_t *pu)
        dev->features = *pu;

        /* Set the vhost_hlen depending on if VIRTIO_NET_F_MRG_RXBUF is set. */
-       if (dev->features & (1 << VIRTIO_NET_F_MRG_RXBUF)) {
-               LOG_DEBUG(VHOST_CONFIG,
-                       "(%"PRIu64") Mergeable RX buffers enabled\n",
-                       dev->device_fh);
-               dev->virtqueue[VIRTIO_RXQ]->vhost_hlen =
-                       sizeof(struct virtio_net_hdr_mrg_rxbuf);
-               dev->virtqueue[VIRTIO_TXQ]->vhost_hlen =
-                       sizeof(struct virtio_net_hdr_mrg_rxbuf);
-       } else {
-               LOG_DEBUG(VHOST_CONFIG,
-                       "(%"PRIu64") Mergeable RX buffers disabled\n",
-                       dev->device_fh);
-               dev->virtqueue[VIRTIO_RXQ]->vhost_hlen =
-                       sizeof(struct virtio_net_hdr);
-               dev->virtqueue[VIRTIO_TXQ]->vhost_hlen =
-                       sizeof(struct virtio_net_hdr);
+       for (q_idx = 0; q_idx < dev->num_virt_queues; q_idx++) {
+               uint32_t virt_rx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_RXQ;
+               uint32_t virt_tx_q_idx = q_idx * VIRTIO_QNUM + VIRTIO_TXQ;
+               if (dev->features & (1 << VIRTIO_NET_F_MRG_RXBUF)) {
+                       LOG_DEBUG(VHOST_CONFIG,
+                               "(%"PRIu64") Mergeable RX buffers enabled\n",
+                               dev->device_fh);
+                       dev->virtqueue[virt_rx_q_idx]->vhost_hlen =
+                               sizeof(struct virtio_net_hdr_mrg_rxbuf);
+                       dev->virtqueue[virt_tx_q_idx]->vhost_hlen =
+                               sizeof(struct virtio_net_hdr_mrg_rxbuf);
+               } else {
+                       LOG_DEBUG(VHOST_CONFIG,
+                               "(%"PRIu64") Mergeable RX buffers disabled\n",
+                               dev->device_fh);
+                       dev->virtqueue[virt_rx_q_idx]->vhost_hlen =
+                               sizeof(struct virtio_net_hdr);
+                       dev->virtqueue[virt_tx_q_idx]->vhost_hlen =
+                               sizeof(struct virtio_net_hdr);
+               }
        }
        return 0;
 }
@@ -736,6 +766,15 @@ int rte_vhost_feature_enable(uint64_t feature_mask)
        return -1;
 }

+int rte_vhost_q_num_get(uint32_t q_number)
+{
+       if (q_number > VIRTIO_MAX_VIRTQUEUES)
+               return -1;
+
+       q_num = q_number;
+       return 0;
+}
+
 /*
  * Register ops so that we can add/remove device to data core.
  */
-- 
1.8.4.2

Reply via email to