Changeset 84803 in vbox for trunk

Timestamp:

Jun 12, 2020 6:17:35 AM (5 years ago)

Author:

vboxsync

Message:

Network/DevVirtioNet_1_0.cpp: Rename API functions to refer to Virtq instead of Queue to be more Virtio like and disambiguate from other queue types. Temporarily enable build in Config.kmk to let the build machines catch errors

Location:

trunk

Files:

• Config.kmk (modified) (1 diff)
• src/VBox/Devices/Network/DevVirtioNet_1_0.cpp (modified) (55 diffs)
• src/VBox/Devices/Storage/DevVirtioSCSI.cpp (modified) (65 diffs)
• src/VBox/Devices/VirtIO/Virtio_1_0.cpp (modified) (53 diffs)
• src/VBox/Devices/VirtIO/Virtio_1_0.h (modified) (11 diffs)

trunk/Config.kmk

@@ -465 +465 @@
 # Enable the Virtio SCSI device.
 VBOX_WITH_VIRTIO_SCSI = 1
+#TODO: PAUL! REMOVE THIS !
+VBOX_WITH_VIRTIO_NET_1_0 = 1 
 # HDA emulation is Intel HDA by default.
 VBOX_WITH_INTEL_HDA = 1

trunk/src/VBox/Devices/Network/DevVirtioNet_1_0.cpp

@@ -61 +61 @@
 #define VIRTIONET_SAVED_STATE_VERSION          UINT32_C(1)
 #define VIRTIONET_MAX_QPAIRS                   1
-#define VIRTIONET_MAX_QUEUES                   (VIRTIONET_MAX_QPAIRS * 2 + 1)
+#define VIRTIONET_MAX_VIRTQS                   (VIRTIONET_MAX_QPAIRS * 2 + 1)
 #define VIRTIONET_MAX_FRAME_SIZE               65535 + 18     /**< Max IP pkt size + Ethernet header with VLAN tag  */
 #define VIRTIONET_MAC_FILTER_LEN               32
@@ -67 +67 @@
 #define VIRTIONET_PREALLOCATE_RX_SEG_COUNT     32
 
-#define VIRTQNAME(idxQueue)       (pThis->aQueues[idxQueue]->szName)
-#define CBVIRTQNAME(idxQueue)     RTStrNLen(VIRTQNAME(idxQueue), sizeof(VIRTQNAME(idxQueue)))
+#define VIRTQNAME(idxVirtq)       (pThis->aVirtqs[idxVirtq]->szName)
+#define CBVIRTQNAME(idxVirtq)     RTStrNLen(VIRTQNAME(idxVirtq), sizeof(VIRTQNAME(idxVirtq)))
 #define FEATURE_ENABLED(feature)  RT_BOOL(pThis->fNegotiatedFeatures & VIRTIONET_F_##feature)
 #define FEATURE_DISABLED(feature) (!FEATURE_ENABLED(feature))
 #define FEATURE_OFFERED(feature)  VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_##feature
 
-#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, idxQueue) \
-            (virtioCoreQueueAvailCount(pDevIns, pVirtio, idxQueue) == 0)
+#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, idxVirtq) \
+            (virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq) == 0)
 
 #define SET_LINK_UP(pState) \
@@ -90 +90 @@
 
 /* Macros to calculate queue specific index number VirtIO 1.0, 5.1.2 */
-#define IS_TX_QUEUE(n)    ((n) != CTRLQIDX && ((n) & 1))
-#define IS_RX_QUEUE(n)    ((n) != CTRLQIDX && !IS_TX_QUEUE(n))
-#define IS_CTRL_QUEUE(n)  ((n) == CTRLQIDX)
+#define IS_TX_VIRTQ(n)    ((n) != CTRLQIDX && ((n) & 1))
+#define IS_RX_VIRTQ(n)    ((n) != CTRLQIDX && !IS_TX_VIRTQ(n))
+#define IS_CTRL_VIRTQ(n)  ((n) == CTRLQIDX)
 #define RXQIDX(qPairIdx)  (qPairIdx * 2)
 #define TXQIDX(qPairIdx)  (qPairIdx * 2 + 1)
@@ -306 +306 @@
 struct VIRTIONETWORKERR3;
 
-typedef struct VIRTIONETQUEUE
+typedef struct VIRTIONETVIRTQ
 {
     struct VIRTIONETWORKER         *pWorker;                    /**< Pointer to R0 worker struct                      */
@@ -312 +312 @@
     uint16_t                       idx;                         /**< Index of this queue                              */
     uint16_t                       align;
-    char                           szName[VIRTIO_MAX_QUEUE_NAME_SIZE]; /**< Queue name                                */
-    bool                           fCtlQueue;                   /**< If set this queue is the control queue           */
+    char                           szName[VIRTIO_MAX_VIRTQ_NAME_SIZE]; /**< Virtq name                                */
+    bool                           fCtlVirtq;                   /**< If set this queue is the control queue           */
     bool                           fHasWorker;                  /**< If set this queue has an associated worker       */
     bool                           fAttachedToVirtioCore;       /**< Set if queue attached to virtio core             */
     uint8_t                        pad;
-} VIRTIONETQUEUE, *PVIRTIONETQUEUE;
+} VIRTIONETVIRTQ, *PVIRTIONETVIRTQ;
 
 /**
@@ -325 +325 @@
 {
     SUPSEMEVENT                     hEvtProcess;                /**< handle of associated sleep/wake-up semaphore      */
-    PVIRTIONETQUEUE                 pQueue;                     /**< pointer to queue                                  */
+    PVIRTIONETVIRTQ                 pVirtq;                     /**< pointer to queue                                  */
     uint16_t                        idx;                        /**< Index of this worker                              */
     bool volatile                   fSleeping;                  /**< Flags whether worker thread is sleeping or not    */
@@ -341 +341 @@
 {
     R3PTRTYPE(PPDMTHREAD)           pThread;                    /**< pointer to worker thread's handle                 */
-    PVIRTIONETQUEUE                 pQueue;                     /**< pointer to queue                                  */
+    PVIRTIONETVIRTQ                 pVirtq;                     /**< pointer to queue                                  */
     uint16_t                        idx;                        /**< Index of this worker                              */
     uint16_t                        pad;
@@ -362 +362 @@
 
     /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
-    VIRTIONETWORKER         aWorkers[VIRTIONET_MAX_QUEUES];
+    VIRTIONETWORKER         aWorkers[VIRTIONET_MAX_VIRTQS];
 
     /** Track which VirtIO queues we've attached to */
-    VIRTIONETQUEUE          aQueues[VIRTIONET_MAX_QUEUES];
+    VIRTIONETVIRTQ          aVirtqs[VIRTIONET_MAX_VIRTQS];
 
     /** PDM device Instance name */
@@ -377 +377 @@
 
     /** Number of virtqueues total (which includes each queue of each pair plus one control queue */
-    uint16_t                cVirtQueues;
+    uint16_t                cVirtVirtqs;
 
     /** Number of worker threads (one for the control queue and one for each Tx queue) */
@@ -485 +485 @@
 
     /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
-    VIRTIONETWORKERR3               aWorkers[VIRTIONET_MAX_QUEUES];
+    VIRTIONETWORKERR3               aWorkers[VIRTIONET_MAX_VIRTQS];
 
     /** The device instance.
@@ -613 +613 @@
 
 /**
- * @callback_method_impl{VIRTIOCORER0,pfnQueueNotified}
- */
-static DECLCALLBACK(void) virtioNetQueueNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+ * @callback_method_impl{VIRTIOCORER0,pfnVirtqNotified}
+ */
+static DECLCALLBACK(void) virtioNetVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     RT_NOREF(pVirtio);
     PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
 
-    PVIRTIONETQUEUE  pQueue = &pThis->aQueues[idxQueue];
-    PVIRTIONETWORKER pWorker = pQueue->pWorker;
+    PVIRTIONETVIRTQ  pVirtq = &pThis->aVirtqs[idxVirtq];
+    PVIRTIONETWORKER pWorker = pVirtq->pWorker;
 
 #if defined (IN_RING3) && defined (LOG_ENABLED)
@@ -627 +627 @@
 #endif
 
-    if (IS_RX_QUEUE(idxQueue))
-    {
-        uint16_t cBufsAvailable = virtioCoreQueueAvailCount(pDevIns, pVirtio, idxQueue);
+    if (IS_RX_VIRTQ(idxVirtq))
+    {
+        uint16_t cBufsAvailable = virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq);
 
         if (cBufsAvailable)
         {
             Log10Func(("%s %u empty bufs added to %s by guest (notifying leaf device)\n",
-                        pThis->szInst, cBufsAvailable, pQueue->szName));
+                        pThis->szInst, cBufsAvailable, pVirtq->szName));
             virtioNetWakeupRxBufWaiter(pDevIns);
         }
         else
             LogRel(("%s \n\n***WARNING: %s notified but no empty bufs added by guest! (skip notifying of leaf device)\n\n",
-                    pThis->szInst, pQueue->szName));
-    }
-    else if (IS_TX_QUEUE(idxQueue) || IS_CTRL_QUEUE(idxQueue))
+                    pThis->szInst, pVirtq->szName));
+    }
+    else if (IS_TX_VIRTQ(idxVirtq) || IS_CTRL_VIRTQ(idxVirtq))
     {
         /* Wake queue's worker thread up if sleeping (e.g. a Tx queue, or the control queue */
@@ -648 +648 @@
             if (ASMAtomicReadBool(&pWorker->fSleeping))
             {
-                Log10Func(("%s %s has available buffers - waking worker.\n", pThis->szInst, pQueue->szName));
+                Log10Func(("%s %s has available buffers - waking worker.\n", pThis->szInst, pVirtq->szName));
                 int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
                 AssertRC(rc);
@@ -654 +654 @@
             else
             {
-                Log10Func(("%s %s has available buffers - worker already awake\n", pThis->szInst, pQueue->szName));
+                Log10Func(("%s %s has available buffers - worker already awake\n", pThis->szInst, pVirtq->szName));
             }
         }
         else
         {
-            Log10Func(("%s %s has available buffers - waking worker.\n", pThis->szInst, pQueue->szName));
+            Log10Func(("%s %s has available buffers - waking worker.\n", pThis->szInst, pVirtq->szName));
         }
     }
     else
-        LogRelFunc(("%s unrecognized queue %s (idx=%d) notified\n", pQueue->szName, idxQueue));
+        LogRelFunc(("%s unrecognized queue %s (idx=%d) notified\n", pVirtq->szName, idxVirtq));
 }
 
@@ -677 +677 @@
 
     Log10Func(("%s\n", pThis->szInst));
+    RT_NOREF(pThis);
 
     return PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
@@ -684 +685 @@
 DECLINLINE(void) virtioNetR3SetVirtqNames(PVIRTIONET pThis)
 {
-    RTStrCopy(pThis->aQueues[CTRLQIDX].szName, VIRTIO_MAX_QUEUE_NAME_SIZE, "controlq");
+    RTStrCopy(pThis->aVirtqs[CTRLQIDX].szName, VIRTIO_MAX_VIRTQ_NAME_SIZE, "controlq");
     for (uint16_t qPairIdx = 0; qPairIdx < pThis->cVirtqPairs; qPairIdx++)
     {
-        RTStrPrintf(pThis->aQueues[RXQIDX(qPairIdx)].szName, VIRTIO_MAX_QUEUE_NAME_SIZE, "receiveq<%d>",  qPairIdx);
-        RTStrPrintf(pThis->aQueues[TXQIDX(qPairIdx)].szName, VIRTIO_MAX_QUEUE_NAME_SIZE, "transmitq<%d>", qPairIdx);
+        RTStrPrintf(pThis->aVirtqs[RXQIDX(qPairIdx)].szName, VIRTIO_MAX_VIRTQ_NAME_SIZE, "receiveq<%d>",  qPairIdx);
+        RTStrPrintf(pThis->aVirtqs[TXQIDX(qPairIdx)].szName, VIRTIO_MAX_VIRTQ_NAME_SIZE, "transmitq<%d>", qPairIdx);
     }
 }
@@ -813 +814 @@
     bool fState    = pszArgs && (*pszArgs == 's' || *pszArgs == 'S'); /* "state"    */
     bool fPointers = pszArgs && (*pszArgs == 'p' || *pszArgs == 'P'); /* "pointers" */
-    bool fQueues   = pszArgs && (*pszArgs == 'q' || *pszArgs == 'Q'); /* "queues    */
+    bool fVirtqs   = pszArgs && (*pszArgs == 'q' || *pszArgs == 'Q'); /* "queues    */
 
     /* Show basic information. */
@@ -836 +837 @@
 
     /* Show queues (and associate worker info if applicable) */
-    if (fAll || fQueues)
-    {
-        pHlp->pfnPrintf(pHlp, "Queue information:\n\n");
-
-        for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
+    if (fAll || fVirtqs)
+    {
+        pHlp->pfnPrintf(pHlp, "Virtq information:\n\n");
+
+        for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
         {
-            PVIRTIONETQUEUE pQueue = &pThis->aQueues[idxQueue];
-
-            if (pQueue->fHasWorker)
+            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[idxVirtq];
+
+            if (pVirtq->fHasWorker)
             {
-                PVIRTIONETWORKER pWorker = pQueue->pWorker;
-                PVIRTIONETWORKERR3 pWorkerR3 = pQueue->pWorkerR3;
+                PVIRTIONETWORKER pWorker = pVirtq->pWorker;
+                PVIRTIONETWORKERR3 pWorkerR3 = pVirtq->pWorkerR3;
 
                 if (pWorker->fAssigned)
                 {
                     pHlp->pfnPrintf(pHlp, "    %-15s (pThread: %p %s) ",
-                        pQueue->szName,
+                        pVirtq->szName,
                         pWorkerR3->pThread,
                         virtioNetThreadStateName(pWorkerR3->pThread));
-                    if (pQueue->fAttachedToVirtioCore)
+                    if (pVirtq->fAttachedToVirtioCore)
                     {
                         pHlp->pfnPrintf(pHlp, "worker: ");
@@ -868 +869 @@
             else
             {
-                pHlp->pfnPrintf(pHlp, "    %-15s (INetworkDown's thread) %s", pQueue->szName,
-                    pQueue->fAttachedToVirtioCore  ? "" : "not attached to virtio core");
+                pHlp->pfnPrintf(pHlp, "    %-15s (INetworkDown's thread) %s", pVirtq->szName,
+                    pVirtq->fAttachedToVirtioCore  ? "" : "not attached to virtio core");
             }
             pHlp->pfnPrintf(pHlp, "\n");
-            virtioCoreR3QueueInfo(pDevIns, pHlp, pszArgs, idxQueue);
+            virtioCoreR3VirtqInfo(pDevIns, pHlp, pszArgs, idxVirtq);
             pHlp->pfnPrintf(pHlp, "    ---------------------------------------------------------------------\n");
             pHlp->pfnPrintf(pHlp, "\n");
@@ -900 +901 @@
         pHlp->pfnPrintf(pHlp, "    uDeviceStatus ............. 0x%x\n", pThis->Virtio.uDeviceStatus);
         pHlp->pfnPrintf(pHlp, "    cVirtqPairs .,............. %d\n",  pThis->cVirtqPairs);
-        pHlp->pfnPrintf(pHlp, "    cVirtQueues .,............. %d\n",  pThis->cVirtQueues);
+        pHlp->pfnPrintf(pHlp, "    cVirtVirtqs .,............. %d\n",  pThis->cVirtVirtqs);
         pHlp->pfnPrintf(pHlp, "    cWorkers .................. %d\n",  pThis->cWorkers);
         pHlp->pfnPrintf(pHlp, "    MMIO mapping name ......... %d\n",  pThisCC->Virtio.pcszMmioName);
@@ -1135 +1136 @@
     pHlp->pfnSSMGetU64(     pSSM, &pThis->fNegotiatedFeatures);
 
-    pHlp->pfnSSMGetU16(     pSSM, &pThis->cVirtQueues);
+    pHlp->pfnSSMGetU16(     pSSM, &pThis->cVirtVirtqs);
     pHlp->pfnSSMGetU16(     pSSM, &pThis->cWorkers);
 
-    for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
-        pHlp->pfnSSMGetBool(pSSM, &pThis->aQueues[idxQueue].fAttachedToVirtioCore);
+    for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
+        pHlp->pfnSSMGetBool(pSSM, &pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore);
 
     int rc;
@@ -1199 +1200 @@
     {
         PVIRTIONETWORKER pWorker = &pThis->aWorkers[idxWorker];
-        PVIRTIONETQUEUE  pQueue  = pWorker->pQueue;
-        if (pQueue->fAttachedToVirtioCore)
+        PVIRTIONETVIRTQ  pVirtq  = pWorker->pVirtq;
+        if (pVirtq->fAttachedToVirtioCore)
         {
-            Log7Func(("%s Waking %s worker.\n", pThis->szInst, pQueue->szName));
+            Log7Func(("%s Waking %s worker.\n", pThis->szInst, pVirtq->szName));
             rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
             AssertRCReturn(rc, rc);
@@ -1224 +1225 @@
     pHlp->pfnSSMPutU64(     pSSM, pThis->fNegotiatedFeatures);
 
-    pHlp->pfnSSMPutU16(     pSSM, pThis->cVirtQueues);
+    pHlp->pfnSSMPutU16(     pSSM, pThis->cVirtVirtqs);
     pHlp->pfnSSMPutU16(     pSSM, pThis->cWorkers);
 
-    for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
-        pHlp->pfnSSMPutBool(pSSM, pThis->aQueues[idxQueue].fAttachedToVirtioCore);
+    for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
+        pHlp->pfnSSMPutBool(pSSM, pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore);
 
     /* Save config area */
@@ -1470 +1471 @@
  * @thread  RX
  */
-static int virtioNetR3CheckRxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETQUEUE pRxQueue)
+static int virtioNetR3CheckRxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETVIRTQ pRxVirtq)
 {
     int rc = VERR_INVALID_STATE;
@@ -1477 +1478 @@
         Log8Func(("%s No Rx bufs available. (VirtIO core not ready)\n", pThis->szInst));
 
-    else if (!virtioCoreIsQueueEnabled(&pThis->Virtio, pRxQueue->idx))
-        Log8Func(("%s No Rx bufs available. (%s not enabled)\n",  pThis->szInst, pRxQueue->szName));
-
-    else if (IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, pRxQueue->idx))
-        Log8Func(("%s No Rx bufs available. (%s empty)\n",  pThis->szInst, pRxQueue->szName));
+    else if (!virtioCoreIsVirtqEnabled(&pThis->Virtio, pRxVirtq->idx))
+        Log8Func(("%s No Rx bufs available. (%s not enabled)\n",  pThis->szInst, pRxVirtq->szName));
+
+    else if (IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, pRxVirtq->idx))
+        Log8Func(("%s No Rx bufs available. (%s empty)\n",  pThis->szInst, pRxVirtq->szName));
 
     else
     {
-        Log8Func(("%s Empty guest buffers available in %s\n",  pThis->szInst,pRxQueue->szName));
+        Log8Func(("%s Empty guest buffers available in %s\n",  pThis->szInst,pRxVirtq->szName));
         rc = VINF_SUCCESS;
     }
-    virtioCoreQueueNotifyEnable(&pThis->Virtio, pRxQueue->idx, rc == VERR_INVALID_STATE /* fEnable */);
+    virtioCoreVirtqNotifyEnable(&pThis->Virtio, pRxVirtq->idx, rc == VERR_INVALID_STATE /* fEnable */);
     return rc;
 }
 
-static bool virtioNetR3RxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETQUEUE *pRxQueue)
-{
-    for (int idxQueuePair = 0; idxQueuePair < pThis->cVirtqPairs; idxQueuePair++)
-    {
-        PVIRTIONETQUEUE pThisRxQueue = &pThis->aQueues[RXQIDX(idxQueuePair)];
-        if (RT_SUCCESS(virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pThisRxQueue)))
+static bool virtioNetR3RxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETVIRTQ *pRxVirtq)
+{
+    for (int idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++)
+    {
+        PVIRTIONETVIRTQ pThisRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
+        if (RT_SUCCESS(virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pThisRxVirtq)))
         {
-            if (pRxQueue)
-                *pRxQueue = pThisRxQueue;
+            if (pRxVirtq)
+                *pRxVirtq = pThisRxVirtq;
             return true;
         }
@@ -1516 +1517 @@
     PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
 
-    if (virtioNetR3RxBufsAvail(pDevIns, pThis, NULL /* pRxQueue */))
+    if (virtioNetR3RxBufsAvail(pDevIns, pThis, NULL /* pRxVirtq */))
     {
         Log10Func(("%s Rx bufs now available, releasing waiter...\n", pThis->szInst));
@@ -1530 +1531 @@
 
     do {
-        if (virtioNetR3RxBufsAvail(pDevIns, pThis, NULL /* pRxQueue */))
+        if (virtioNetR3RxBufsAvail(pDevIns, pThis, NULL /* pRxVirtq */))
         {
             Log10Func(("%s Rx bufs now available, releasing waiter...\n", pThis->szInst));
@@ -1730 +1731 @@
                                        VIRTIONET_PKT_HDR_T *rxPktHdr, uint16_t cSegsAllocated,
                                        PRTSGBUF pVirtSegBufToGuest, PRTSGSEG paVirtSegsToGuest,
-                                       PVIRTIONETQUEUE pRxQueue)
+                                       PVIRTIONETVIRTQ pRxVirtq)
 {
     uint8_t fAddPktHdr = true;
@@ -1740 +1741 @@
         PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
 
-        int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, pRxQueue->idx, &pDescChain, true);
+        int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, pRxVirtq->idx, &pDescChain, true);
         AssertMsgReturn(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE, ("%Rrc\n", rc), rc);
 
@@ -1801 +1802 @@
             Log7Func(("Send Rx pkt to guest...\n"));
             STAM_PROFILE_START(&pThis->StatReceiveStore, a);
-            virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, pRxQueue->idx,
+            virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, pRxVirtq->idx,
                                  pVirtSegBufToGuest, pDescChain, true /* fFence */);
             STAM_PROFILE_STOP(&pThis->StatReceiveStore, a);
@@ -1825 +1826 @@
                   rc);
 
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, pRxQueue->idx);
+    virtioCoreVirtqSync(pDevIns, &pThis->Virtio, pRxVirtq->idx);
 
     return VINF_SUCCESS;
@@ -1843 +1844 @@
  * @param   cb              Number of bytes available in the buffer.
  * @param   pGso            Pointer to Global Segmentation Offload structure
- * @param   idxRxQueue      Rx queue to work with
+ * @param   idxRxVirtq      Rx queue to work with
  * @thread  RX
  */
 static int virtioNetR3HandleRxPacket(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso, PVIRTIONETQUEUE pRxQueue)
+                                const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso, PVIRTIONETVIRTQ pRxVirtq)
 {
     RT_NOREF(pThisCC);
@@ -1898 +1899 @@
 
     int rc = virtioNetR3CopyRxPktToGuest(pDevIns, pThis, pvBuf, cb, &rxPktHdr, cSegsAllocated,
-                                        pVirtSegBufToGuest, paVirtSegsToGuest, pRxQueue);
+                                        pVirtSegBufToGuest, paVirtSegsToGuest, pRxVirtq);
 
     RTMemFree(paVirtSegsToGuest);
@@ -1960 +1961 @@
               selection algorithm feasible or even necessary to prevent starvation? */
 
-    for (int idxQueuePair = 0; idxQueuePair < pThis->cVirtqPairs; idxQueuePair++)
-    {
-
-        PVIRTIONETQUEUE pRxQueue = &pThis->aQueues[RXQIDX(idxQueuePair)];
-        if (RT_SUCCESS(!virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pRxQueue)))
+    for (int idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++)
+    {
+
+        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
+        if (RT_SUCCESS(!virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pRxVirtq)))
         {
             /* Drop packets if VM is not running or cable is disconnected. */
@@ -1976 +1977 @@
             if (virtioNetR3AddressFilter(pThis, pvBuf, cb))
             {
-                rc = virtioNetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso, pRxQueue);
+                rc = virtioNetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso, pRxVirtq);
                 STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, cb);
             }
@@ -2282 +2283 @@
     RTSgBufInit(pReturnSegBuf, paReturnSegs, cSegs);
 
-    virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, CTRLQIDX, pReturnSegBuf, pDescChain, true /* fFence */);
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, CTRLQIDX);
+    virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, CTRLQIDX, pReturnSegBuf, pDescChain, true /* fFence */);
+    virtioCoreVirtqSync(pDevIns, &pThis->Virtio, CTRLQIDX);
 
     for (int i = 0; i < cSegs; i++)
@@ -2394 +2395 @@
 
 static void virtioNetR3TransmitPendingPackets(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                         PVIRTIONETQUEUE pTxQueue, bool fOnWorkerThread)
+                                         PVIRTIONETVIRTQ pTxVirtq, bool fOnWorkerThread)
 {
 
@@ -2432 +2433 @@
     }
 
-    int cPkts = virtioCoreQueueAvailCount(pVirtio->pDevInsR3, pVirtio, pTxQueue->idx);
+    int cPkts = virtioCoreVirtqAvailCount(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx);
     if (!cPkts)
     {
-        LogFunc(("%s No packets to send found on %s\n", pThis->szInst, pTxQueue->szName));
+        LogFunc(("%s No packets to send found on %s\n", pThis->szInst, pTxVirtq->szName));
 
         if (pDrv)
@@ -2449 +2450 @@
     int rc;
     PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-    while ((rc = virtioCoreR3QueuePeek(pVirtio->pDevInsR3, pVirtio, pTxQueue->idx, &pDescChain)) == VINF_SUCCESS)
-    {
-        Log10Func(("%s fetched descriptor chain from %s\n", pThis->szInst, pTxQueue->szName));
+    while ((rc = virtioCoreR3VirtqPeek(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, &pDescChain)) == VINF_SUCCESS)
+    {
+        Log10Func(("%s fetched descriptor chain from %s\n", pThis->szInst, pTxVirtq->szName));
 
         PVIRTIOSGBUF pSgPhysSend = pDescChain->pSgPhysSend;
@@ -2535 +2536 @@
 
             /* Remove this descriptor chain from the available ring */
-            virtioCoreR3QueueSkip(pVirtio, pTxQueue->idx);
+            virtioCoreR3VirtqSkip(pVirtio, pTxVirtq->idx);
 
             /* No data to return to guest, but call is needed put elem (e.g. desc chain) on used ring */
-            virtioCoreR3QueuePut(pVirtio->pDevInsR3, pVirtio, pTxQueue->idx, NULL, pDescChain, true /* fFence */);
+            virtioCoreR3VirtqPut(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, NULL, pDescChain, true /* fFence */);
 
             /* Update used ring idx and notify guest that we've transmitted the data it sent */
-            virtioCoreQueueSync(pVirtio->pDevInsR3, pVirtio, pTxQueue->idx);
+            virtioCoreVirtqSync(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx);
         }
 
@@ -2564 +2565 @@
     PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
-    PVIRTIONETQUEUE pTxQueue  = &pThis->aQueues[TXQIDX(0)];
+    PVIRTIONETVIRTQ pTxVirtq  = &pThis->aVirtqs[TXQIDX(0)];
     STAM_COUNTER_INC(&pThis->StatTransmitByNetwork);
 
     /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
           selection algorithm feasible or even necessary */
-    virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pTxQueue, true /*fOnWorkerThread*/);
+    virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pTxVirtq, true /*fOnWorkerThread*/);
 }
 
@@ -2745 +2746 @@
 static int virtioNetR3CreateOneWorkerThread(PPDMDEVINS pDevIns, PVIRTIONET pThis, uint16_t idxWorker,
                                             PVIRTIONETWORKER pWorker, PVIRTIONETWORKERR3 pWorkerR3,
-                                            PVIRTIONETQUEUE pQueue)
+                                            PVIRTIONETVIRTQ pVirtq)
 {
     Log10Func(("%s\n", pThis->szInst));
+    RT_NOREF(pThis);
 
     int rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pWorker->hEvtProcess);
@@ -2755 +2757 @@
                                    N_("DevVirtioNET: Failed to create SUP event semaphore"));
 
-    LogFunc(("creating thread for queue %s\n", pQueue->szName));
+    LogFunc(("creating thread for queue %s\n", pVirtq->szName));
 
     rc = PDMDevHlpThreadCreate(pDevIns, &pWorkerR3->pThread,
                                (void *)pWorker, virtioNetR3WorkerThread,
-                               virtioNetR3WakeupWorker, 0, RTTHREADTYPE_IO, pQueue->szName);
+                               virtioNetR3WakeupWorker, 0, RTTHREADTYPE_IO, pVirtq->szName);
     if (RT_FAILURE(rc))
         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
-                                   N_("Error creating thread for Virtual Queue %s\n"), pQueue->idx);
-
-    pWorker->pQueue    = pWorkerR3->pQueue = pQueue;
-    pWorker->idx       = pWorkerR3->idx    = idxWorker;
-    pQueue->pWorker    = pWorker;
-    pQueue->pWorkerR3  = pWorkerR3;
+                                   N_("Error creating thread for Virtual Virtq %s\n"), pVirtq->idx);
+
+    pWorker->pVirtq    = pWorkerR3->pVirtq   = pVirtq;
+    pWorker->idx       = pWorkerR3->idx      = idxWorker;
+    pVirtq->pWorker    = pWorker;
+    pVirtq->pWorkerR3  = pWorkerR3;
     pWorker->fAssigned = true;
 
-    LogFunc(("%s pThread: %p\n", pQueue->szName, pWorkerR3->pThread));
+    LogFunc(("%s pThread: %p\n", pVirtq->szName, pWorkerR3->pThread));
 
     return rc;
@@ -2782 +2784 @@
     Log10Func(("%s\n", pThis->szInst));
 
-    PVIRTIONETQUEUE pCtlQueue = &pThis->aQueues[CTRLQIDX];
+    PVIRTIONETVIRTQ pCtlVirtq = &pThis->aVirtqs[CTRLQIDX];
     int rc = virtioNetR3CreateOneWorkerThread(pDevIns, pThis, CTRLQIDX /* idxWorker */,
-                                              &pThis->aWorkers[CTRLWIDX], &pThisCC->aWorkers[CTRLWIDX], pCtlQueue);
+                                              &pThis->aWorkers[CTRLWIDX], &pThisCC->aWorkers[CTRLWIDX], pCtlVirtq);
     AssertRCReturn(rc, rc);
 
-    pCtlQueue->fHasWorker = true;
+    pCtlVirtq->fHasWorker = true;
 
     uint16_t idxWorker = CTRLWIDX + 1;
-    for (uint16_t idxQueuePair = 0; idxQueuePair < pThis->cVirtqPairs; idxQueuePair++, idxWorker++)
-    {
-        PVIRTIONETQUEUE pTxQueue = &pThis->aQueues[TXQIDX(idxQueuePair)];
-        PVIRTIONETQUEUE pRxQueue = &pThis->aQueues[RXQIDX(idxQueuePair)];
+    for (uint16_t idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++, idxWorker++)
+    {
+        PVIRTIONETVIRTQ pTxVirtq = &pThis->aVirtqs[TXQIDX(idxVirtqPair)];
+        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
 
         rc = virtioNetR3CreateOneWorkerThread(pDevIns, pThis, idxWorker, &pThis->aWorkers[idxWorker],
-                                              &pThisCC->aWorkers[idxWorker], pTxQueue);
+                                              &pThisCC->aWorkers[idxWorker], pTxVirtq);
         AssertRCReturn(rc, rc);
 
-        pTxQueue->fHasWorker = true;
-        pRxQueue->fHasWorker = false;
-    }
-    pThis->cWorkers = pThis->cVirtqPairs + 1;
+        pTxVirtq->fHasWorker = true;
+        pRxVirtq->fHasWorker = false;
+    }
+    pThis->cWorkers = pThis->cVirtqPairs + 1 /* Control virtq */;
     return rc;
 }
@@ -2814 +2816 @@
     PVIRTIONETCC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
     PVIRTIONETWORKER   pWorker   = (PVIRTIONETWORKER)pThread->pvUser;
-    PVIRTIONETQUEUE    pQueue    = pWorker->pQueue;
+    PVIRTIONETVIRTQ    pVirtq    = pWorker->pVirtq;
 
     if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
         return VINF_SUCCESS;
 
-    LogFunc(("%s worker thread started for %s\n", pThis->szInst, pQueue->szName));
-
- /** @todo Race w/guest enabling/disabling guest notifications cyclically.
-           See BugRef #8651, Comment #82 */
-
-    virtioCoreQueueNotifyEnable(&pThis->Virtio, pQueue->idx, true /* fEnable */);
+    LogFunc(("%s worker thread started for %s\n", pThis->szInst, pVirtq->szName));
+
+    /** @todo Race w/guest enabling/disabling guest notifications cyclically.
+              See BugRef #8651, Comment #82 */
+    virtioCoreVirtqNotifyEnable(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
 
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        if (IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, pQueue->idx))
+        if (IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, pVirtq->idx))
         {
             /* Atomic interlocks avoid missing alarm while going to sleep & notifier waking the awoken */
@@ -2835 +2836 @@
             if (!fNotificationSent)
             {
-                Log10Func(("%s %s worker sleeping...\n\n", pThis->szInst, pQueue->szName));
+                Log10Func(("%s %s worker sleeping...\n\n", pThis->szInst, pVirtq->szName));
                 Assert(ASMAtomicReadBool(&pWorker->fSleeping));
                 int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
@@ -2853 +2854 @@
         if (!pThisCC->fQuiescing)
         {
-             if (pQueue->fCtlQueue)
+             if (pVirtq->fCtlVirtq)
              {
-                 Log10Func(("%s %s worker woken. Fetching desc chain\n", pThis->szInst, pQueue->szName));
+                 Log10Func(("%s %s worker woken. Fetching desc chain\n", pThis->szInst, pVirtq->szName));
                  PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-                 int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, pQueue->idx, &pDescChain, true);
+                 int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, pVirtq->idx, &pDescChain, true);
                  if (rc == VERR_NOT_AVAILABLE)
                  {
-                    Log10Func(("%s %s worker woken. Nothing found in queue/n", pThis->szInst, pQueue->szName));
+                    Log10Func(("%s %s worker woken. Nothing found in queue/n", pThis->szInst, pVirtq->szName));
                     continue;
                  }
@@ -2868 +2869 @@
              else /* Must be Tx queue */
              {
-                 Log10Func(("%s %s worker woken. Queue has data to transmit\n",  pThis->szInst, pQueue->szName));
-                 virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pQueue, false /* fOnWorkerThread */);
+                 Log10Func(("%s %s worker woken. Virtq has data to transmit\n",  pThis->szInst, pVirtq->szName));
+                 virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pVirtq, false /* fOnWorkerThread */);
              }
 
              /* Rx queues aren't handled by our worker threads. Instead, the PDM network
               * leaf driver invokes PDMINETWORKDOWN.pfnWaitReceiveAvail() callback,
-              * which waits until notified directly by virtioNetQueueNotified()
+              * which waits until notified directly by virtioNetVirtqNotified()
               * that guest IN buffers have been added to receive virt queue.
               */
         }
     }
-    Log10(("%s %s worker thread exiting\n", pThis->szInst, pQueue->szName));
+    Log10(("%s %s worker thread exiting\n", pThis->szInst, pVirtq->szName));
     return VINF_SUCCESS;
 }
@@ -2898 +2899 @@
                  pThis->szInst));
 
-        pThis->fNegotiatedFeatures = virtioCoreGetAcceptedFeatures(pVirtio);
+        pThis->fNegotiatedFeatures = virtioCoreGetNegotiatedFeatures(pVirtio);
 
 #ifdef LOG_ENABLED
@@ -2910 +2911 @@
         pThisCC->fQuiescing = false;
 
-        for (unsigned idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
+        for (unsigned idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
         {
-            PVIRTIONETQUEUE pQueue = &pThis->aQueues[idxQueue];
-            pQueue->idx = idxQueue;
-            (void) virtioCoreR3QueueAttach(&pThis->Virtio, pQueue->idx, pQueue->szName);
-            pQueue->fAttachedToVirtioCore = true;
-            if (IS_VIRTQ_EMPTY(pThisCC->pDevIns, &pThis->Virtio, pQueue->idx))
-                virtioCoreQueueNotifyEnable(&pThis->Virtio, pQueue->idx, true /* fEnable */);
+            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[idxVirtq];
+            pVirtq->idx = idxVirtq;
+            (void) virtioCoreR3VirtqAttach(&pThis->Virtio, pVirtq->idx, pVirtq->szName);
+            pVirtq->fAttachedToVirtioCore = true;
+            if (IS_VIRTQ_EMPTY(pThisCC->pDevIns, &pThis->Virtio, pVirtq->idx))
+                virtioCoreVirtqNotifyEnable(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
         }
     }
@@ -2943 +2944 @@
         pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, true);
 
-        for (uint16_t idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
-            pThis->aQueues[idxQueue].fAttachedToVirtioCore = false;
+        for (uint16_t idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
+            pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore = false;
     }
 }
@@ -3153 +3154 @@
 
     /* Initialize the generic Virtio core: */
-    pThisCC->Virtio.pfnQueueNotified        = virtioNetQueueNotified;
+    pThisCC->Virtio.pfnVirtqNotified        = virtioNetVirtqNotified;
     pThisCC->Virtio.pfnStatusChanged        = virtioNetR3StatusChanged;
     pThisCC->Virtio.pfnDevCapRead           = virtioNetR3DevCapRead;
@@ -3192 +3193 @@
                          ? pThis->virtioNetConfig.uMaxVirtqPairs  :  1;
 
-    pThis->cVirtQueues += pThis->cVirtqPairs * 2 + 1;
+    pThis->cVirtVirtqs += pThis->cVirtqPairs * 2 + 1;
 
     /* Create Link Up Timer */
@@ -3202 +3203 @@
      */
     virtioNetR3SetVirtqNames(pThis);
-    pThis->aQueues[CTRLQIDX].fCtlQueue = true;
+    pThis->aVirtqs[CTRLQIDX].fCtlVirtq = true;
 
     /*
@@ -3290 +3291 @@
     PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
     PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-    pThisCC->Virtio.pfnQueueNotified = virtioNetQueueNotified;
+    pThisCC->Virtio.pfnVirtqNotified = virtioNetVirtqNotified;
     return virtioCoreRZInit(pDevIns, &pThis->Virtio);
 }

trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp

@@ -81 +81 @@
 #define VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED       VIRTIOSCSI_HOST_SCSI_FEATURES_NONE
 
-#define VIRTIOSCSI_REQ_QUEUE_CNT                    4           /**< T.B.D. Consider increasing                      */
-#define VIRTIOSCSI_QUEUE_CNT                        (VIRTIOSCSI_REQ_QUEUE_CNT + 2)
+#define VIRTIOSCSI_REQ_VIRTQ_CNT                    4           /**< T.B.D. Consider increasing                      */
+#define VIRTIOSCSI_VIRTQ_CNT                        (VIRTIOSCSI_REQ_VIRTQ_CNT + 2)
 #define VIRTIOSCSI_MAX_TARGETS                      256         /**< T.B.D. Figure out a a good value for this.      */
 #define VIRTIOSCSI_MAX_LUN                          256         /**< VirtIO specification, section 5.6.4             */
@@ -112 +112 @@
 #define VIRTQ_REQ_BASE                              2           /**< Spec-defined base index of request queues       */
 
-#define VIRTQNAME(idxQueue) (pThis->aszVirtqNames[idxQueue])            /**< Macro to get queue name from its index          */
-#define CBVIRTQNAME(idxQueue) RTStrNLen(VIRTQNAME(idxQueue), sizeof(VIRTQNAME(idxQueue)))
-
-#define IS_REQ_QUEUE(idxQueue) (idxQueue >= VIRTQ_REQ_BASE && idxQueue < VIRTIOSCSI_QUEUE_CNT)
+#define VIRTQNAME(idxVirtq) (pThis->aszVirtqNames[idxVirtq])            /**< Macro to get queue name from its index          */
+#define CBVIRTQNAME(idxVirtq) RTStrNLen(VIRTQNAME(idxVirtq), sizeof(VIRTQNAME(idxVirtq)))
+
+#define IS_REQ_VIRTQ(idxVirtq) (idxVirtq >= VIRTQ_REQ_BASE && idxVirtq < VIRTIOSCSI_VIRTQ_CNT)
 
 #define VIRTIO_IS_IN_DIRECTION(pMediaExTxDirEnumValue) \
@@ -123 +123 @@
     ((pMediaExTxDirEnumValue) == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE)
 
-#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, idxQueue) \
-            (virtioCoreQueueAvailCount(pDevIns, pVirtio, idxQueue) == 0)
+#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, idxVirtq) \
+            (virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq) == 0)
 
 
@@ -137 +137 @@
 typedef struct virtio_scsi_config
 {
-    uint32_t uNumQueues;                                        /**< num_queues       \# of req q's exposed by dev   */
+    uint32_t uNumVirtqs;                                        /**< num_queues       \# of req q's exposed by dev   */
     uint32_t uSegMax;                                           /**< seg_max          Max \# of segs allowed in cmd  */
     uint32_t uMaxSectors;                                       /**< max_sectors      Hint to guest max xfer to use  */
@@ -427 +427 @@
 
     /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
-    VIRTIOSCSIWORKER                aWorkers[VIRTIOSCSI_QUEUE_CNT];
+    VIRTIOSCSIWORKER                aWorkers[VIRTIOSCSI_VIRTQ_CNT];
 
     /** Instance name */
@@ -433 +433 @@
 
     /** Device-specific spec-based VirtIO VIRTQNAMEs */
-    char                            aszVirtqNames[VIRTIOSCSI_QUEUE_CNT][VIRTIO_MAX_QUEUE_NAME_SIZE];
+    char                            aszVirtqNames[VIRTIOSCSI_VIRTQ_CNT][VIRTIO_MAX_VIRTQ_NAME_SIZE];
 
     /** Track which VirtIO queues we've attached to */
-    bool                            afQueueAttached[VIRTIOSCSI_QUEUE_CNT];
+    bool                            afVirtqAttached[VIRTIOSCSI_VIRTQ_CNT];
 
     /** Set if events missed due to lack of bufs avail on eventq */
@@ -488 +488 @@
 
     /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
-    VIRTIOSCSIWORKERR3              aWorkers[VIRTIOSCSI_QUEUE_CNT];
+    VIRTIOSCSIWORKERR3              aWorkers[VIRTIOSCSI_VIRTQ_CNT];
 
     /** Device base interface. */
@@ -503 +503 @@
     R3PTRTYPE(PPDMIMEDIANOTIFY)     pMediaNotify;
 
-    /** Queue to send tasks to R3. - HC ptr */
-    R3PTRTYPE(PPDMQUEUE)            pNotifierQueueR3;
+    /** Virtq to send tasks to R3. - HC ptr */
+    R3PTRTYPE(PPDMQUEUE)            pNotifierVirtqR3;
 
     /** True if in the process of quiescing I/O */
@@ -557 +557 @@
     PDMMEDIAEXIOREQ                hIoReq;                      /**< Handle of I/O request                             */
     PVIRTIOSCSITARGET              pTarget;                     /**< Target                                            */
-    uint16_t                       idxQueue;                        /**< Index of queue this request arrived on            */
+    uint16_t                       idxVirtq;                        /**< Index of queue this request arrived on            */
     PVIRTIO_DESC_CHAIN_T           pDescChain;                  /**< Prepared desc chain pulled from virtq avail ring  */
     size_t                         cbDataIn;                    /**< size of dataout buffer                            */
@@ -573 +573 @@
 
 /**
- * callback_method_impl{VIRTIOCORER0,pfnQueueNotified}
+ * callback_method_impl{VIRTIOCORER0,pfnVirtqNotified}
  * @todo this causes burn if I prefix with at-sign. This callback is in VIRTIOCORER0 and VIRTIOCORER3
  */
-static DECLCALLBACK(void) virtioScsiNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+static DECLCALLBACK(void) virtioScsiNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
 
@@ -582 +582 @@
     PVIRTIOSCSI pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
 
-    AssertReturnVoid(idxQueue < VIRTIOSCSI_QUEUE_CNT);
-    PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[idxQueue];
+    AssertReturnVoid(idxVirtq < VIRTIOSCSI_VIRTQ_CNT);
+    PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[idxVirtq];
 
 #if defined (IN_RING3) && defined (LOG_ENABLED)
@@ -589 +589 @@
 #endif
 
-    if (idxQueue == CONTROLQ_IDX || IS_REQ_QUEUE(idxQueue))
-    {
-        Log6Func(("%s has available data\n", VIRTQNAME(idxQueue)));
+    if (idxVirtq == CONTROLQ_IDX || IS_REQ_VIRTQ(idxVirtq))
+    {
+        Log6Func(("%s has available data\n", VIRTQNAME(idxVirtq)));
         /* Wake queue's worker thread up if sleeping */
         if (!ASMAtomicXchgBool(&pWorker->fNotified, true))
@@ -597 +597 @@
             if (ASMAtomicReadBool(&pWorker->fSleeping))
             {
-                Log6Func(("waking %s worker.\n", VIRTQNAME(idxQueue)));
+                Log6Func(("waking %s worker.\n", VIRTQNAME(idxVirtq)));
                 int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
                 AssertRC(rc);
@@ -603 +603 @@
         }
     }
-    else if (idxQueue == EVENTQ_IDX)
-    {
-        Log3Func(("Driver queued buffer(s) to %s\n", VIRTQNAME(idxQueue)));
+    else if (idxVirtq == EVENTQ_IDX)
+    {
+        Log3Func(("Driver queued buffer(s) to %s\n", VIRTQNAME(idxVirtq)));
 //        if (ASMAtomicXchgBool(&pThis->fEventsMissed, false))
 //            virtioScsiR3ReportEventsMissed(pDevIns, pThis, 0);
     }
     else
-        LogFunc(("Unexpected queue idx (ignoring): %d\n", idxQueue));
+        LogFunc(("Unexpected queue idx (ignoring): %d\n", idxVirtq));
 }
 
@@ -619 +619 @@
 DECLINLINE(void) virtioScsiSetVirtqNames(PVIRTIOSCSI pThis)
 {
-    RTStrCopy(pThis->aszVirtqNames[CONTROLQ_IDX], VIRTIO_MAX_QUEUE_NAME_SIZE, "controlq");
-    RTStrCopy(pThis->aszVirtqNames[EVENTQ_IDX],   VIRTIO_MAX_QUEUE_NAME_SIZE, "eventq");
-    for (uint16_t idxQueue = VIRTQ_REQ_BASE; idxQueue < VIRTQ_REQ_BASE + VIRTIOSCSI_REQ_QUEUE_CNT; idxQueue++)
-        RTStrPrintf(pThis->aszVirtqNames[idxQueue], VIRTIO_MAX_QUEUE_NAME_SIZE,
-                    "requestq<%d>", idxQueue - VIRTQ_REQ_BASE);
+    RTStrCopy(pThis->aszVirtqNames[CONTROLQ_IDX], VIRTIO_MAX_VIRTQ_NAME_SIZE, "controlq");
+    RTStrCopy(pThis->aszVirtqNames[EVENTQ_IDX],   VIRTIO_MAX_VIRTQ_NAME_SIZE, "eventq");
+    for (uint16_t idxVirtq = VIRTQ_REQ_BASE; idxVirtq < VIRTQ_REQ_BASE + VIRTIOSCSI_REQ_VIRTQ_CNT; idxVirtq++)
+        RTStrPrintf(pThis->aszVirtqNames[idxVirtq], VIRTIO_MAX_VIRTQ_NAME_SIZE,
+                    "requestq<%d>", idxVirtq - VIRTQ_REQ_BASE);
 }
 
@@ -755 +755 @@
 
     PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-    int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, EVENTQ_IDX, &pDescChain, true);
+    int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, EVENTQ_IDX, &pDescChain, true);
     if (rc == VERR_NOT_AVAILABLE)
     {
@@ -783 +783 @@
     RTSgBufInit(&ReqSgBuf, aReqSegs, RT_ELEMENTS(aReqSegs));
 
-    rc = virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, EVENTQ_IDX, &ReqSgBuf, pDescChain, true /*fFence*/);
+    rc = virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, EVENTQ_IDX, &ReqSgBuf, pDescChain, true /*fFence*/);
     if (rc == VINF_SUCCESS)
-        virtioCoreQueueSync(pDevIns, &pThis->Virtio, EVENTQ_IDX, false);
+        virtioCoreVirtqSync(pDevIns, &pThis->Virtio, EVENTQ_IDX, false);
     else
         LogRel(("Error writing control message to guest\n"));
@@ -811 +811 @@
  * @param   pThis       VirtIO SCSI shared instance data.
  * @param   pThisCC     VirtIO SCSI ring-3 instance data.
- * @param   idxQueue        Queue index
+ * @param   idxVirtq        Virtq index
  * @param   pDescChain  Pointer to pre-processed descriptor chain pulled from virtq
  * @param   pRespHdr    Response header
@@ -819 +819 @@
  * @returns VINF_SUCCESS
  */
-static int virtioScsiR3ReqErr(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC, uint16_t idxQueue,
+static int virtioScsiR3ReqErr(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC, uint16_t idxVirtq,
                               PVIRTIO_DESC_CHAIN_T pDescChain, REQ_RESP_HDR_T *pRespHdr, uint8_t *pbSense,
                               size_t cbSenseCfg)
@@ -853 +853 @@
         pRespHdr->uResponse = VIRTIOSCSI_S_RESET;
 
-    virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, idxQueue, &ReqSgBuf, pDescChain, true /* fFence */);
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, idxQueue);
+    virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, idxVirtq, &ReqSgBuf, pDescChain, true /* fFence */);
+    virtioCoreVirtqSync(pDevIns, &pThis->Virtio, idxVirtq);
 
     if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThisCC->fQuiescing)
@@ -872 +872 @@
  * @param   pThis       VirtIO SCSI shared instance data.
  * @param   pThisCC     VirtIO SCSI ring-3 instance data.
- * @param   idxQueue        Queue index
+ * @param   idxVirtq        Virtq index
  * @param   pDescChain  Pointer to pre-processed descriptor chain pulled from virtq
  * @param   cbResidual  The number of residual bytes or something like that.
@@ -883 +883 @@
  * @returns VINF_SUCCESS
  */
-static int virtioScsiR3ReqErr4(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC, uint16_t idxQueue,
+static int virtioScsiR3ReqErr4(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC, uint16_t idxVirtq,
                                PVIRTIO_DESC_CHAIN_T pDescChain, size_t cbResidual, uint8_t bStatus, uint8_t bResponse,
                                uint8_t *pbSense, size_t cbSense, size_t cbSenseCfg)
@@ -894 +894 @@
     RespHdr.uResponse        = bResponse;
 
-    return virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, idxQueue, pDescChain, &RespHdr, pbSense, cbSenseCfg);
+    return virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, &RespHdr, pbSense, cbSenseCfg);
 }
 
@@ -1016 +1016 @@
         respHdr.uResidual  = pReq->cbDataIn & UINT32_MAX;
 
-        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, pReq->idxQueue, pReq->pDescChain, &respHdr, abSense,
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, pReq->idxVirtq, pReq->pDescChain, &respHdr, abSense,
                            RT_MIN(pThis->virtioScsiConfig.uSenseSize, VIRTIOSCSI_SENSE_SIZE_MAX));
     }
@@ -1042 +1042 @@
                         VERR_BUFFER_OVERFLOW);
 
-        virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, pReq->idxQueue, &ReqSgBuf, pReq->pDescChain, true /* fFence TBD */);
-        virtioCoreQueueSync(pDevIns, &pThis->Virtio, pReq->idxQueue);
+        virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, pReq->idxVirtq, &ReqSgBuf, pReq->pDescChain, true /* fFence TBD */);
+        virtioCoreVirtqSync(pDevIns, &pThis->Virtio, pReq->idxVirtq);
 
         Log2(("-----------------------------------------------------------------------------------------\n"));
@@ -1058 +1058 @@
 /**
  * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
- *
+
  * Copy virtual memory from VSCSI layer to guest physical memory
  */
@@ -1144 +1144 @@
  */
 static int virtioScsiR3ReqSubmit(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
-                                 uint16_t idxQueue, PVIRTIO_DESC_CHAIN_T pDescChain)
+                                 uint16_t idxVirtq, PVIRTIO_DESC_CHAIN_T pDescChain)
 {
 
@@ -1194 +1194 @@
     if (uType == 0xc1 && uTarget == 0x01)
     {
-        LogRel(("* * * REPORT LUNS LU ACCESSED * * * "));
+        LogRel(("* * * WARNING: REPORT LUNS LU ACCESSED. FEATURE NOT IMPLEMENTED SEE DevVirtioScsi.cpp * * * "));
         /* Force rejection. */ /** @todo figure out right way to handle. Note this is a very
          * vague and confusing part of the VirtIO spec (which deviates from the SCSI standard).
          * I have not been able to determine how to implement this properly.  I've checked the
-         * source code of Guest drivers, and so far none seem to use it. If logs show
-         * this warning, implementing it can be re-visited */
+         * source code of Guest drivers, and so far none seem to use it. If this message is logged,
+         * meaning a guest expects this feature, implementing it can be re-visited */
         uScsiLun = 0xff;
     }
@@ -1232 +1232 @@
     {
         Log2Func(("Error submitting request, bad LUN format\n"));
-        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxQueue, pDescChain, cbDataIn + cbDataOut, 0 /*bStatus*/,
+        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, cbDataIn + cbDataOut, 0 /*bStatus*/,
                                    VIRTIOSCSI_S_FAILURE, NULL /*pbSense*/, 0 /*cbSense*/, cbSenseCfg);
     }
@@ -1247 +1247 @@
                               0, SCSI_SENSE_ILLEGAL_REQUEST,
                               0, 0, 0, 0, 10, SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED, 0, 0 };
-        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxQueue, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
+        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
                                    VIRTIOSCSI_S_BAD_TARGET, abSense, sizeof(abSense), cbSenseCfg);
     }
@@ -1258 +1258 @@
                               0, SCSI_SENSE_ILLEGAL_REQUEST,
                               0, 0, 0, 0, 10, SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED, 0, 0 };
-        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxQueue, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
+        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
                                    VIRTIOSCSI_S_OK, abSense, sizeof(abSense), cbSenseCfg);
     }
@@ -1266 +1266 @@
     {
         Log2Func(("Aborting req submission because reset is in progress\n"));
-        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxQueue, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_OK,
+        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_OK,
                                    VIRTIOSCSI_S_RESET, NULL /*pbSense*/, 0 /*cbSense*/, cbSenseCfg);
     }
@@ -1277 +1277 @@
         uint8_t abSense[] = { RT_BIT(7) | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
                               0, SCSI_SENSE_ILLEGAL_REQUEST, 0, 0, 0, 0, 10, 0, 0, 0 };
-        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxQueue, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
+        return virtioScsiR3ReqErr4(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
                                    VIRTIOSCSI_S_FAILURE, abSense, sizeof(abSense), cbSenseCfg);
     }
@@ -1295 +1295 @@
     pReq->hIoReq      = hIoReq;
     pReq->pTarget     = pTarget;
-    pReq->idxQueue        = idxQueue;
+    pReq->idxVirtq    = idxVirtq;
     pReq->cbDataIn    = cbDataIn;
     pReq->cbDataOut   = cbDataOut;
@@ -1323 +1323 @@
          */
         Assert(RT_FAILURE_NP(rc));
-        Log2Func(("Request submission error from lower-level driver\n"));
+        Log2Func(("Request-submission error from lower-level driver\n"));
         uint8_t uASC, uASCQ = 0;
         switch (rc)
@@ -1342 +1342 @@
         respHdr.uResponse  = VIRTIOSCSI_S_FAILURE;
         respHdr.uResidual  = (cbDataIn + cbDataOut) & UINT32_MAX;
-        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, idxQueue, pDescChain, &respHdr, abSense, cbSenseCfg);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, idxVirtq, pDescChain, &respHdr, abSense, cbSenseCfg);
         virtioScsiR3FreeReq(pTarget, pReq);
     }
@@ -1356 +1356 @@
  * @param   pThis       VirtIO SCSI shared instance data.
  * @param   pThisCC     VirtIO SCSI ring-3 instance data.
- * @param   idxQueue    CONTROLQ_IDX
+ * @param   idxVirtq    CONTROLQ_IDX
  * @param   pDescChain  Descriptor chain to process.
  */
 static int virtioScsiR3Ctrl(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
-                            uint16_t idxQueue, PVIRTIO_DESC_CHAIN_T pDescChain)
+                            uint16_t idxVirtq, PVIRTIO_DESC_CHAIN_T pDescChain)
 {
     AssertReturn(pDescChain->cbPhysSend >= RT_MIN(sizeof(VIRTIOSCSI_CTRL_AN_T),
@@ -1401 +1401 @@
             uint32_t uScsiLun = RT_MAKE_U16(ScsiCtrlUnion.Tmf.abScsiLun[3], ScsiCtrlUnion.Tmf.abScsiLun[2]) & 0x3fff;
             Log2Func(("[%s] (Target: %d LUN: %d)  Task Mgt Function: %s\n",
-                      VIRTQNAME(idxQueue), uTarget, uScsiLun, virtioGetTMFTypeText(ScsiCtrlUnion.Tmf.uSubtype)));
+                      VIRTQNAME(idxVirtq), uTarget, uScsiLun, virtioGetTMFTypeText(ScsiCtrlUnion.Tmf.uSubtype)));
 
             if (uTarget >= pThis->cTargets || !pThisCC->paTargetInstances[uTarget].fPresent)
@@ -1462 +1462 @@
                 virtioGetControlAsyncMaskText(szTypeText, sizeof(szTypeText), ScsiCtrlUnion.AsyncNotify.fEventsRequested);
                 Log2Func(("[%s] (Target: %d LUN: %d)  Async. Notification Query: %s\n",
-                          VIRTQNAME(idxQueue), uTarget, uScsiLun, szTypeText));
+                          VIRTQNAME(idxVirtq), uTarget, uScsiLun, szTypeText));
             }
 #endif
@@ -1487 +1487 @@
                 virtioGetControlAsyncMaskText(szTypeText, sizeof(szTypeText), ScsiCtrlUnion.AsyncNotify.fEventsRequested);
                 Log2Func(("[%s] (Target: %d LUN: %d)  Async. Notification Subscribe: %s\n",
-                          VIRTQNAME(idxQueue), uTarget, uScsiLun, szTypeText));
+                          VIRTQNAME(idxVirtq), uTarget, uScsiLun, szTypeText));
             }
 #endif
@@ -1508 +1508 @@
         default:
         {
-            LogFunc(("Unknown control type extracted from %s: %u\n", VIRTQNAME(idxQueue), ScsiCtrlUnion.Type.uType));
+            LogFunc(("Unknown control type extracted from %s: %u\n", VIRTQNAME(idxVirtq), ScsiCtrlUnion.Type.uType));
 
             bResponse = VIRTIOSCSI_S_FAILURE;
@@ -1527 +1527 @@
     RTSgBufInit(&ReqSgBuf, aReqSegs, cSegs);
 
-    virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, idxQueue, &ReqSgBuf, pDescChain, true /*fFence*/);
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, idxQueue);
+    virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, idxVirtq, &ReqSgBuf, pDescChain, true /*fFence*/);
+    virtioCoreVirtqSync(pDevIns, &pThis->Virtio, idxVirtq);
 
     return VINF_SUCCESS;
@@ -1547 +1547 @@
 static DECLCALLBACK(int) virtioScsiR3WorkerThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    uint16_t const      idxQueue  = (uint16_t)(uintptr_t)pThread->pvUser;
+    uint16_t const      idxVirtq  = (uint16_t)(uintptr_t)pThread->pvUser;
     PVIRTIOSCSI         pThis     = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
     PVIRTIOSCSICC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
-    PVIRTIOSCSIWORKER   pWorker   = &pThis->aWorkers[idxQueue];
-    PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxQueue];
+    PVIRTIOSCSIWORKER   pWorker   = &pThis->aWorkers[idxVirtq];
+    PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxVirtq];
 
     if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
@@ -1558 +1558 @@
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        if (!pWorkerR3->cRedoDescs && IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, idxQueue))
+        if (!pWorkerR3->cRedoDescs && IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, idxVirtq))
         {
             /* Atomic interlocks avoid missing alarm while going to sleep & notifier waking the awoken */
@@ -1565 +1565 @@
             if (!fNotificationSent)
             {
-                Log6Func(("%s worker sleeping...\n", VIRTQNAME(idxQueue)));
+                Log6Func(("%s worker sleeping...\n", VIRTQNAME(idxVirtq)));
                 Assert(ASMAtomicReadBool(&pWorker->fSleeping));
                 int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
@@ -1573 +1573 @@
                 if (rc == VERR_INTERRUPTED)
                     continue;
-                Log6Func(("%s worker woken\n", VIRTQNAME(idxQueue)));
+                Log6Func(("%s worker woken\n", VIRTQNAME(idxVirtq)));
                 ASMAtomicWriteBool(&pWorker->fNotified, false);
             }
@@ -1579 +1579 @@
         }
 
-        if (!pThis->afQueueAttached[idxQueue])
+        if (!pThis->afVirtqAttached[idxVirtq])
         {
-            LogFunc(("%s queue not attached, worker aborting...\n", VIRTQNAME(idxQueue)));
+            LogFunc(("%s queue not attached, worker aborting...\n", VIRTQNAME(idxVirtq)));
             break;
         }
@@ -1590 +1590 @@
              {
                   PVIRTIO_DESC_CHAIN_T pDescChain;
-                  int rc = virtioCoreR3DescChainGet(pDevIns, &pThis->Virtio, idxQueue,
+                  int rc = virtioCoreR3DescChainGet(pDevIns, &pThis->Virtio, idxVirtq,
                                                     pWorkerR3->auRedoDescs[i], &pDescChain);
                   if (RT_FAILURE(rc))
                       LogRel(("Error fetching desc chain to redo, %Rrc", rc));
 
-                  rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, idxQueue, pDescChain);
+                  rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, idxVirtq, pDescChain);
                   if (RT_FAILURE(rc))
                       LogRel(("Error submitting req packet, resetting %Rrc", rc));
@@ -1603 +1603 @@
              pWorkerR3->cRedoDescs = 0;
 
-             Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(idxQueue)));
+             Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(idxVirtq)));
              PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-             int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, idxQueue, &pDescChain, true);
+             int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, idxVirtq, &pDescChain, true);
              if (rc == VERR_NOT_AVAILABLE)
              {
-                 Log6Func(("Nothing found in %s\n", VIRTQNAME(idxQueue)));
+                 Log6Func(("Nothing found in %s\n", VIRTQNAME(idxVirtq)));
                  continue;
              }
 
              AssertRC(rc);
-             if (idxQueue == CONTROLQ_IDX)
-                 virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, idxQueue, pDescChain);
+             if (idxVirtq == CONTROLQ_IDX)
+                 virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, idxVirtq, pDescChain);
              else /* request queue index */
              {
-                 rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, idxQueue, pDescChain);
+                 rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, idxVirtq, pDescChain);
                  if (RT_FAILURE(rc))
                      LogRel(("Error submitting req packet, resetting %Rrc", rc));
@@ -1703 +1703 @@
         pThisCC->fQuiescing  = false;
 
-        for (unsigned i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
-            pThis->afQueueAttached[i] = true;
+        for (unsigned i = 0; i < VIRTIOSCSI_VIRTQ_CNT; i++)
+            pThis->afVirtqAttached[i] = true;
     }
     else
     {
         LogFunc(("VirtIO is resetting\n"));
-        for (unsigned i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
-            pThis->afQueueAttached[i] = false;
+        for (unsigned i = 0; i < VIRTIOSCSI_VIRTQ_CNT; i++)
+            pThis->afVirtqAttached[i] = false;
     }
 }
@@ -1835 +1835 @@
     AssertReturn(pv && cb <= sizeof(uint32_t), fWrite ? VINF_SUCCESS : VINF_IOM_MMIO_UNUSED_00);
 
-    if (MATCH_SCSI_CONFIG(uNumQueues))
-        SCSI_CONFIG_ACCESSOR_READONLY(uNumQueues);
+    if (MATCH_SCSI_CONFIG(uNumVirtqs))
+        SCSI_CONFIG_ACCESSOR_READONLY(uNumVirtqs);
     else
     if (MATCH_SCSI_CONFIG(uSegMax))
@@ -1967 +1967 @@
 
     virtioScsiSetVirtqNames(pThis);
-    for (int idxQueue = 0; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
-        pHlp->pfnSSMGetBool(pSSM, &pThis->afQueueAttached[idxQueue]);
-
-    pHlp->pfnSSMGetU32(pSSM,  &pThis->virtioScsiConfig.uNumQueues);
+    for (int idxVirtq = 0; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
+        pHlp->pfnSSMGetBool(pSSM, &pThis->afVirtqAttached[idxVirtq]);
+
+    pHlp->pfnSSMGetU32(pSSM,  &pThis->virtioScsiConfig.uNumVirtqs);
     pHlp->pfnSSMGetU32(pSSM,  &pThis->virtioScsiConfig.uSegMax);
     pHlp->pfnSSMGetU32(pSSM,  &pThis->virtioScsiConfig.uMaxSectors);
@@ -2007 +2007 @@
                                               cReqsRedo, VIRTQ_MAX_ENTRIES));
 
-        for (uint16_t idxQueue = VIRTQ_REQ_BASE; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
+        for (uint16_t idxVirtq = VIRTQ_REQ_BASE; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
         {
-            PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxQueue];
+            PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxVirtq];
             pWorkerR3->cRedoDescs = 0;
         }
@@ -2015 +2015 @@
         for (int i = 0; i < cReqsRedo; i++)
         {
-            uint16_t idxQueue;
-            rc = pHlp->pfnSSMGetU16(pSSM, &idxQueue);
+            uint16_t idxVirtq;
+            rc = pHlp->pfnSSMGetU16(pSSM, &idxVirtq);
             AssertRCReturn(rc, rc);
-            AssertReturn(idxQueue < VIRTIOSCSI_QUEUE_CNT,
+            AssertReturn(idxVirtq < VIRTIOSCSI_VIRTQ_CNT,
                          pHlp->pfnSSMSetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
                                                   N_("Bad queue index for re-do in saved state (%#x, max %#x)"),
-                                                  idxQueue, VIRTIOSCSI_QUEUE_CNT - 1));
+                                                  idxVirtq, VIRTIOSCSI_VIRTQ_CNT - 1));
 
             uint16_t idxHead;
@@ -2031 +2031 @@
                                                   idxHead, VIRTQ_MAX_ENTRIES - 1));
 
-            PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxQueue];
+            PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxVirtq];
             pWorkerR3->auRedoDescs[pWorkerR3->cRedoDescs++] = idxHead;
             pWorkerR3->cRedoDescs %= VIRTQ_MAX_ENTRIES;
@@ -2045 +2045 @@
      * Nudge request queue workers
      */
-    for (int idxQueue = VIRTQ_REQ_BASE; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
-    {
-        if (pThis->afQueueAttached[idxQueue])
+    for (int idxVirtq = VIRTQ_REQ_BASE; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
+    {
+        if (pThis->afVirtqAttached[idxVirtq])
         {
-            LogFunc(("Waking %s worker.\n", VIRTQNAME(idxQueue)));
-            int rc2 = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxQueue].hEvtProcess);
+            LogFunc(("Waking %s worker.\n", VIRTQNAME(idxVirtq)));
+            int rc2 = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxVirtq].hEvtProcess);
             AssertRCReturn(rc, rc2);
         }
@@ -2069 +2069 @@
     LogFunc(("SAVE EXEC!!\n"));
 
-    for (int idxQueue = 0; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
-        pHlp->pfnSSMPutBool(pSSM, pThis->afQueueAttached[idxQueue]);
-
-    pHlp->pfnSSMPutU32(pSSM,  pThis->virtioScsiConfig.uNumQueues);
+    for (int idxVirtq = 0; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
+        pHlp->pfnSSMPutBool(pSSM, pThis->afVirtqAttached[idxVirtq]);
+
+    pHlp->pfnSSMPutU32(pSSM,  pThis->virtioScsiConfig.uNumVirtqs);
     pHlp->pfnSSMPutU32(pSSM,  pThis->virtioScsiConfig.uSegMax);
     pHlp->pfnSSMPutU32(pSSM,  pThis->virtioScsiConfig.uMaxSectors);
@@ -2117 +2117 @@
                  while(--cReqsRedo)
                  {
-                    pHlp->pfnSSMPutU16(pSSM, pReq->idxQueue);
+                    pHlp->pfnSSMPutU16(pSSM, pReq->idxVirtq);
                     pHlp->pfnSSMPutU16(pSSM, pReq->pDescChain->uHeadIdx);
 
@@ -2335 +2335 @@
      * be awake due to new reqs coming in.
      */
-    for (uint16_t idxQueue = 0; idxQueue < VIRTIOSCSI_REQ_QUEUE_CNT; idxQueue++)
-    {
-        if (ASMAtomicReadBool(&pThis->aWorkers[idxQueue].fSleeping))
+    for (uint16_t idxVirtq = 0; idxVirtq < VIRTIOSCSI_REQ_VIRTQ_CNT; idxVirtq++)
+    {
+        if (ASMAtomicReadBool(&pThis->aWorkers[idxVirtq].fSleeping))
         {
-            Log6Func(("waking %s worker.\n", VIRTQNAME(idxQueue)));
-            int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxQueue].hEvtProcess);
+            Log6Func(("waking %s worker.\n", VIRTQNAME(idxVirtq)));
+            int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxVirtq].hEvtProcess);
             AssertRC(rc);
         }
@@ -2414 +2414 @@
     pThisCC->pMediaNotify = NULL;
 
-    for (unsigned idxQueue = 0; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
-    {
-        PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[idxQueue];
+    for (unsigned idxVirtq = 0; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
+    {
+        PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[idxVirtq];
         if (pWorker->hEvtProcess != NIL_SUPSEMEVENT)
         {
@@ -2423 +2423 @@
         }
 
-        if (pThisCC->aWorkers[idxQueue].pThread)
+        if (pThisCC->aWorkers[idxVirtq].pThread)
         {
             /* Destroy the thread. */
             int rcThread;
-            int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[idxQueue].pThread, &rcThread);
+            int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[idxVirtq].pThread, &rcThread);
             if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
                 AssertMsgFailed(("%s Failed to destroythread rc=%Rrc rcThread=%Rrc\n",
                                  __FUNCTION__, rc, rcThread));
-           pThisCC->aWorkers[idxQueue].pThread = NULL;
+           pThisCC->aWorkers[idxVirtq].pThread = NULL;
         }
     }
@@ -2487 +2487 @@
 
     /* Configure virtio_scsi_config that transacts via VirtIO implementation's Dev. Specific Cap callbacks */
-    pThis->virtioScsiConfig.uNumQueues      = VIRTIOSCSI_REQ_QUEUE_CNT;
+    pThis->virtioScsiConfig.uNumVirtqs      = VIRTIOSCSI_REQ_VIRTQ_CNT;
     pThis->virtioScsiConfig.uSegMax         = VIRTIOSCSI_MAX_SEG_COUNT;
     pThis->virtioScsiConfig.uMaxSectors     = VIRTIOSCSI_MAX_SECTORS_HINT;
@@ -2499 +2499 @@
 
     /* Initialize the generic Virtio core: */
-    pThisCC->Virtio.pfnQueueNotified        = virtioScsiNotified;
+    pThisCC->Virtio.pfnVirtqNotified        = virtioScsiNotified;
     pThisCC->Virtio.pfnStatusChanged        = virtioScsiR3StatusChanged;
     pThisCC->Virtio.pfnDevCapRead           = virtioScsiR3DevCapRead;
@@ -2526 +2526 @@
 
     /* Attach the queues and create worker threads for them: */
-    for (uint16_t idxQueue = 0; idxQueue < VIRTIOSCSI_QUEUE_CNT; idxQueue++)
-    {
-        rc = virtioCoreR3QueueAttach(&pThis->Virtio, idxQueue, VIRTQNAME(idxQueue));
+    for (uint16_t idxVirtq = 0; idxVirtq < VIRTIOSCSI_VIRTQ_CNT; idxVirtq++)
+    {
+        rc = virtioCoreR3VirtqAttach(&pThis->Virtio, idxVirtq, VIRTQNAME(idxVirtq));
         if (RT_FAILURE(rc))
             continue;
-        if (idxQueue == CONTROLQ_IDX || IS_REQ_QUEUE(idxQueue))
+        if (idxVirtq == CONTROLQ_IDX || IS_REQ_VIRTQ(idxVirtq))
         {
-            rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[idxQueue].pThread,
-                                       (void *)(uintptr_t)idxQueue, virtioScsiR3WorkerThread,
-                                       virtioScsiR3WorkerWakeUp, 0, RTTHREADTYPE_IO, VIRTQNAME(idxQueue));
+            rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[idxVirtq].pThread,
+                                       (void *)(uintptr_t)idxVirtq, virtioScsiR3WorkerThread,
+                                       virtioScsiR3WorkerWakeUp, 0, RTTHREADTYPE_IO, VIRTQNAME(idxVirtq));
             if (rc != VINF_SUCCESS)
             {
-                LogRel(("Error creating thread for Virtual Queue %s: %Rrc\n", VIRTQNAME(idxQueue), rc));
+                LogRel(("Error creating thread for Virtual Virtq %s: %Rrc\n", VIRTQNAME(idxVirtq), rc));
                 return rc;
             }
 
-            rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->aWorkers[idxQueue].hEvtProcess);
+            rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->aWorkers[idxVirtq].hEvtProcess);
             if (RT_FAILURE(rc))
                 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                            N_("DevVirtioSCSI: Failed to create SUP event semaphore"));
         }
-        pThis->afQueueAttached[idxQueue] = true;
+        pThis->afVirtqAttached[idxVirtq] = true;
     }
 
@@ -2666 +2666 @@
 
 
-    pThisCC->Virtio.pfnQueueNotified = virtioScsiNotified;
+    pThisCC->Virtio.pfnVirtqNotified = virtioScsiNotified;
     return virtioCoreRZInit(pDevIns, &pThis->Virtio);
 }

trunk/src/VBox/Devices/VirtIO/Virtio_1_0.cpp

@@ -42 +42 @@
 *********************************************************************************************************************************/
 #define INSTANCE(a_pVirtio)                 ((a_pVirtio)->szInstance)
-#define VIRTQNAME(a_pVirtio, a_idxQueue)    ((a_pVirtio)->virtqState[(a_idxQueue)].szVirtqName)
+#define VIRTQNAME(a_pVirtio, a_idxVirtq)    ((a_pVirtio)->aVirtqState[(a_idxVirtq)].szVirtqName)
 #define IS_DRIVER_OK(a_pVirtio)             ((a_pVirtio)->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
-#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq) \
-            (virtioCoreQueueAvailCount(pDevIns, pVirtio, pVirtq) == 0)
+#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState) \
+            (virtioCoreVirtqAvailCount(pDevIns, pVirtio, pVirtqState) == 0)
 
 /**
@@ -135 +135 @@
 /* Internal Functions */
 
-static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
+static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq);
 static int  virtioKick(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint8_t uCause, uint16_t uVec);
 
@@ -145 +145 @@
  */
 #ifdef IN_RING3
-DECLINLINE(void) virtioReadDesc(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+DECLINLINE(void) virtioReadDesc(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                                 uint32_t idxDesc, PVIRTQ_DESC_T pDesc)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[idxVirtq], 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueDesc[idxQueue] + sizeof(VIRTQ_DESC_T) * (idxDesc % cQueueItems),
+                      pVirtio->aGCPhysVirtqDesc[idxVirtq] + sizeof(VIRTQ_DESC_T) * (idxDesc % cVirtqItems),
                       pDesc, sizeof(VIRTQ_DESC_T));
 }
@@ -160 +160 @@
  */
 #ifdef IN_RING3
-DECLINLINE(uint16_t) virtioReadAvailDescIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint32_t availIdx)
+DECLINLINE(uint16_t) virtioReadAvailDescIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, uint32_t availIdx)
 {
     uint16_t uDescIdx;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[idxVirtq], 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysRead(pDevIns,
-                        pVirtio->aGCPhysQueueAvail[idxQueue]
-                      + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[availIdx % cQueueItems]),
+                        pVirtio->aGCPhysVirtqAvail[idxVirtq]
+                      + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[availIdx % cVirtqItems]),
                       &uDescIdx, sizeof(uDescIdx));
     return uDescIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     uint16_t uUsedEventIdx;
@@ -178 +178 @@
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[pVirtio->uQueueSize[idxQueue]]),
+                      pVirtio->aGCPhysVirtqAvail[idxVirtq] + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[pVirtio->uVirtqSize[idxVirtq]]),
                       &uUsedEventIdx, sizeof(uUsedEventIdx));
     return uUsedEventIdx;
@@ -184 +184 @@
 #endif
 
-DECLINLINE(uint16_t) virtioReadAvailRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     uint16_t uIdx = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF(VIRTQ_AVAIL_T, uIdx),
+                      pVirtio->aGCPhysVirtqAvail[idxVirtq] + RT_UOFFSETOF(VIRTQ_AVAIL_T, uIdx),
                       &uIdx, sizeof(uIdx));
     return uIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadAvailRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     uint16_t fFlags = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF(VIRTQ_AVAIL_T, fFlags),
+                      pVirtio->aGCPhysVirtqAvail[idxVirtq] + RT_UOFFSETOF(VIRTQ_AVAIL_T, fFlags),
                       &fFlags, sizeof(fFlags));
     return fFlags;
@@ -211 +211 @@
 
 #ifdef IN_RING3
-DECLINLINE(void) virtioWriteUsedElem(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+DECLINLINE(void) virtioWriteUsedElem(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                                      uint32_t usedIdx, uint32_t uDescIdx, uint32_t uLen)
 {
     VIRTQ_USED_ELEM_T elem = { uDescIdx,  uLen };
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[idxVirtq], 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[usedIdx % cQueueItems]),
+                          pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[usedIdx % cVirtqItems]),
                           &elem, sizeof(elem));
 }
 
-DECLINLINE(void) virtioWriteUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint16_t fFlags)
+DECLINLINE(void) virtioWriteUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, uint16_t fFlags)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     RT_UNTRUSTED_VALIDATED_FENCE(); /* VirtIO 1.0, Section 3.2.1.4.1 */
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
+                          pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
                           &fFlags, sizeof(fFlags));
 }
 #endif
 
-DECLINLINE(void) virtioWriteUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint16_t uIdx)
+DECLINLINE(void) virtioWriteUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, uint16_t uIdx)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
+                          pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                           &uIdx, sizeof(uIdx));
 }
@@ -243 +243 @@
 #ifdef IN_RING3
 
-DECLINLINE(uint16_t) virtioReadUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     uint16_t uIdx = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
+                      pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                       &uIdx, sizeof(uIdx));
     return uIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
 {
     uint16_t fFlags = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
+                      pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
                       &fFlags, sizeof(fFlags));
     return fFlags;
 }
 
-DECLINLINE(void) virtioWriteUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint32_t uAvailEventIdx)
+DECLINLINE(void) virtioWriteUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, uint32_t uAvailEventIdx)
 {
     /** VirtIO 1.0 uAvailEventIdx (avail_event) immediately follows ring */
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[pVirtio->uQueueSize[idxQueue]]),
+                          pVirtio->aGCPhysVirtqUsed[idxVirtq] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[pVirtio->uVirtqSize[idxVirtq]]),
                           &uAvailEventIdx, sizeof(uAvailEventIdx));
 }
@@ -275 +275 @@
 #endif
 
-DECLINLINE(uint16_t) virtioCoreQueueAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQSTATE pVirtq)
-{
-    uint16_t uIdx    = virtioReadAvailRingIdx(pDevIns, pVirtio, pVirtq->idxQueue);
-    uint16_t uShadow = pVirtq->uAvailIdxShadow;
+DECLINLINE(uint16_t) virtioCoreVirtqAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQSTATE pVirtqState)
+{
+    uint16_t uIdx    = virtioReadAvailRingIdx(pDevIns, pVirtio, pVirtqState->idxVirtq);
+    uint16_t uShadow = pVirtqState->uAvailIdxShadow;
 
     uint16_t uDelta;
@@ -287 +287 @@
 
     LogFunc(("%s has %u %s (idx=%u shadow=%u)\n",
-        VIRTQNAME(pVirtio, pVirtq->idxQueue), uDelta, uDelta == 1 ? "entry" : "entries",
+        VIRTQNAME(pVirtio, pVirtqState->idxVirtq), uDelta, uDelta == 1 ? "entry" : "entries",
         uIdx, uShadow));
 
@@ -297 +297 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  *
  * @returns how many entries have been added to ring as a delta of the consumer's
  *          avail index and the queue's guest-side current avail index.
  */
-uint16_t virtioCoreQueueAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    if (!IS_DRIVER_OK(pVirtio) || !pVirtio->uQueueEnable[idxQueue])
+uint16_t virtioCoreVirtqAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    if (!IS_DRIVER_OK(pVirtio) || !pVirtio->uVirtqEnable[idxVirtq])
     {
         LogRelFunc(("Driver not ready or queue not enabled\n"));
         return 0;
     }
-    return virtioCoreQueueAvailCount(pDevIns, pVirtio, &pVirtio->virtqState[idxQueue]);
+    return virtioCoreVirtqAvailCount(pDevIns, pVirtio, &pVirtio->aVirtqState[idxVirtq]);
 }
 
@@ -681 +681 @@
     bool fState    = pszArgs && (*pszArgs == 's' || *pszArgs == 'S'); /* "state"    */
     bool fPointers = pszArgs && (*pszArgs == 'p' || *pszArgs == 'P'); /* "pointers" */
-    bool fQueues   = pszArgs && (*pszArgs == 'q' || *pszArgs == 'Q'); /* "queues    */
-    RT_NOREF6(fNone, fAll, fBasic, fState, fPointers, fQueues);
+    bool fVirtqs   = pszArgs && (*pszArgs == 'q' || *pszArgs == 'Q'); /* "queues    */
+    RT_NOREF6(fNone, fAll, fBasic, fState, fPointers, fVirtqs);
     pHlp->pfnPrintf(pHlp, "");
 
 }
 
-void virtioCoreR3QueueInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int idxQueue)
+void virtioCoreR3VirtqInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int idxVirtq)
 {
     RT_NOREF(pszArgs);
     PVIRTIOCORE pVirtio = PDMDEVINS_2_DATA(pDevIns, PVIRTIOCORE);
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
 
 //    bool fDump      = pszArgs && (*pszArgs == 'd' || *pszArgs == 'D'); /* "dump" (avail phys descriptor)"       */
 
-    uint16_t uAvailIdx       = virtioReadAvailRingIdx(pDevIns, pVirtio, idxQueue);
-    uint16_t uAvailIdxShadow = pVirtq->uAvailIdxShadow;
-
-    uint16_t uUsedIdx        = virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue);
-    uint16_t uUsedIdxShadow  = pVirtq->uUsedIdxShadow;
+    uint16_t uAvailIdx       = virtioReadAvailRingIdx(pDevIns, pVirtio, idxVirtq);
+    uint16_t uAvailIdxShadow = pVirtqState->uAvailIdxShadow;
+
+    uint16_t uUsedIdx        = virtioReadUsedRingIdx(pDevIns, pVirtio, idxVirtq);
+    uint16_t uUsedIdxShadow  = pVirtqState->uUsedIdxShadow;
 
     PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
 
-    bool fEmpty = IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq);
-
-    LogFunc(("%s, empty = %s\n", VIRTQNAME(pVirtio, idxQueue), fEmpty ? "true" : "false"));
+    bool fEmpty = IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState);
+
+    LogFunc(("%s, empty = %s\n", VIRTQNAME(pVirtio, idxVirtq), fEmpty ? "true" : "false"));
 
     int cSendSegs = 0, cReturnSegs = 0;
     if (!fEmpty)
     {
-        virtioCoreR3QueuePeek(pDevIns,  pVirtio, idxQueue, &pDescChain);
+        virtioCoreR3VirtqPeek(pDevIns,  pVirtio, idxVirtq, &pDescChain);
         cSendSegs   = pDescChain->pSgPhysSend ? pDescChain->pSgPhysSend->cSegs : 0;
         cReturnSegs = pDescChain->pSgPhysReturn ? pDescChain->pSgPhysReturn->cSegs : 0;
     }
 
-    bool fAvailNoInterrupt   = virtioReadAvailRingFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT;
-    bool fUsedNoNotify       = virtioReadUsedRingFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_USED_F_NO_NOTIFY;
-
-
-    pHlp->pfnPrintf(pHlp, "       queue enabled: ........... %s\n", pVirtio->uQueueEnable[idxQueue] ? "true" : "false");
-    pHlp->pfnPrintf(pHlp, "       size: .................... %d\n", pVirtio->uQueueSize[idxQueue]);
-    pHlp->pfnPrintf(pHlp, "       notify offset: ........... %d\n", pVirtio->uQueueNotifyOff[idxQueue]);
+    bool fAvailNoInterrupt   = virtioReadAvailRingFlags(pDevIns, pVirtio, idxVirtq) & VIRTQ_AVAIL_F_NO_INTERRUPT;
+    bool fUsedNoNotify       = virtioReadUsedRingFlags(pDevIns, pVirtio, idxVirtq) & VIRTQ_USED_F_NO_NOTIFY;
+
+
+    pHlp->pfnPrintf(pHlp, "       queue enabled: ........... %s\n", pVirtio->uVirtqEnable[idxVirtq] ? "true" : "false");
+    pHlp->pfnPrintf(pHlp, "       size: .................... %d\n", pVirtio->uVirtqSize[idxVirtq]);
+    pHlp->pfnPrintf(pHlp, "       notify offset: ........... %d\n", pVirtio->uVirtqNotifyOff[idxVirtq]);
     if (pVirtio->fMsiSupport)
-        pHlp->pfnPrintf(pHlp, "       MSIX vector: ....... %4.4x\n", pVirtio->uQueueMsixVector[idxQueue]);
+        pHlp->pfnPrintf(pHlp, "       MSIX vector: ....... %4.4x\n", pVirtio->uVirtqMsixVector[idxVirtq]);
     pHlp->pfnPrintf(pHlp, "\n");
     pHlp->pfnPrintf(pHlp, "       avail ring (%d entries):\n", uAvailIdx - uAvailIdxShadow);
@@ -747 +747 @@
         {
             pHlp->pfnPrintf(pHlp, "             index: ............. %d\n", pDescChain->pSgPhysSend->idxSeg);
-            pHlp->pfnPrintf(pHlp, "             unsent ............. %d\n",  pDescChain->pSgPhysSend->cbSegLeft);
+            pHlp->pfnPrintf(pHlp, "             unsent ............. %d\n", pDescChain->pSgPhysSend->cbSegLeft);
         }
         pHlp->pfnPrintf(pHlp, "\n");
@@ -755 +755 @@
         {
             pHlp->pfnPrintf(pHlp, "             index: ............. %d\n", pDescChain->pSgPhysReturn->idxSeg);
-            pHlp->pfnPrintf(pHlp, "             unsent ............. %d\n",  pDescChain->pSgPhysReturn->cbSegLeft);
+            pHlp->pfnPrintf(pHlp, "             unsent ............. %d\n", pDescChain->pSgPhysReturn->cbSegLeft);
         }
     } else
@@ -767 +767 @@
  *
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  * @param   pcszName    Name to give queue
  *
  * @returns VBox status code.
  */
-int virtioCoreR3QueueAttach(PVIRTIOCORE pVirtio, uint16_t idxQueue, const char *pcszName)
+int virtioCoreR3VirtqAttach(PVIRTIOCORE pVirtio, uint16_t idxVirtq, const char *pcszName)
 {
     LogFunc(("%s\n", pcszName));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-    pVirtq->idxQueue = idxQueue;
-    pVirtq->uAvailIdxShadow = 0;
-    pVirtq->uUsedIdxShadow  = 0;
-    pVirtq->fVirtqRingEventThreshold = false;
-    RTStrCopy(pVirtq->szVirtqName, sizeof(pVirtq->szVirtqName), pcszName);
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+    pVirtqState->idxVirtq = idxVirtq;
+    pVirtqState->uAvailIdxShadow = 0;
+    pVirtqState->uUsedIdxShadow  = 0;
+    pVirtqState->fVirtqRingEventThreshold = false;
+    RTStrCopy(pVirtqState->szVirtqName, sizeof(pVirtqState->szVirtqName), pcszName);
     return VINF_SUCCESS;
 }
@@ -788 +788 @@
 #ifdef IN_RING3
 
-int virtioCoreR3DescChainGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+int virtioCoreR3DescChainGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                              uint16_t uHeadIdx, PPVIRTIO_DESC_CHAIN_T ppDescChain)
 {
@@ -794 +794 @@
     *ppDescChain = NULL;
 
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uQueueEnable[idxQueue],
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[idxVirtq],
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
     uint16_t uDescIdx = uHeadIdx;
 
-    Log6Func(("%s DESC CHAIN: (head) desc_idx=%u\n", pVirtq->szVirtqName, uHeadIdx));
-    RT_NOREF(pVirtq);
+    Log6Func(("%s DESC CHAIN: (head) desc_idx=%u\n", pVirtqState->szVirtqName, uHeadIdx));
+    RT_NOREF(pVirtqState);
 
     /*
@@ -853 +853 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        virtioReadDesc(pDevIns, pVirtio, idxQueue, uDescIdx, &desc);
+        virtioReadDesc(pDevIns, pVirtio, idxVirtq, uDescIdx, &desc);
 
         if (desc.fFlags & VIRTQ_DESC_F_WRITE)
         {
-            Log6Func(("%s IN  desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, idxQueue), uDescIdx, cSegsIn, desc.GCPhysBuf, desc.cb));
+            Log6Func(("%s IN  desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, idxVirtq), uDescIdx, cSegsIn, desc.GCPhysBuf, desc.cb));
             cbIn += desc.cb;
             pSeg = &paSegsIn[cSegsIn++];
@@ -863 +863 @@
         else
         {
-            Log6Func(("%s OUT desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, idxQueue), uDescIdx, cSegsOut, desc.GCPhysBuf, desc.cb));
+            Log6Func(("%s OUT desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, idxVirtq), uDescIdx, cSegsOut, desc.GCPhysBuf, desc.cb));
             cbOut += desc.cb;
             pSeg = &paSegsOut[cSegsOut++];
@@ -899 +899 @@
 
     STAM_REL_COUNTER_INC(&pVirtio->StatDescChainsAllocated);
-    Log6Func(("%s -- segs OUT: %u (%u bytes)   IN: %u (%u bytes) --\n", pVirtq->szVirtqName, cSegsOut, cbOut, cSegsIn, cbIn));
+    Log6Func(("%s -- segs OUT: %u (%u bytes)   IN: %u (%u bytes) --\n", pVirtqState->szVirtqName, cSegsOut, cbOut, cSegsIn, cbIn));
 
     return VINF_SUCCESS;
@@ -964 +964 @@
  *
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  * @param   fEnable    Selects notification mode (enabled or disabled)
  */
-void virtioCoreQueueNotifyEnable(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnable)
+void virtioCoreVirtqNotifyEnable(PVIRTIOCORE pVirtio, uint16_t idxVirtq, bool fEnable)
 {
     if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
     {
-        uint16_t fFlags = virtioReadUsedRingFlags(pVirtio->pDevInsR3, pVirtio, idxQueue);
+        uint16_t fFlags = virtioReadUsedRingFlags(pVirtio->pDevInsR3, pVirtio, idxVirtq);
 
         if (fEnable)
@@ -978 +978 @@
             fFlags |= VIRTQ_USED_F_NO_NOTIFY;
 
-        virtioWriteUsedRingFlags(pVirtio->pDevInsR3, pVirtio, idxQueue, fFlags);
+        virtioWriteUsedRingFlags(pVirtio->pDevInsR3, pVirtio, idxVirtq, fFlags);
     }
 }
@@ -999 +999 @@
 }
 
-
-
 /**
  * Fetches descriptor chain using avail ring of indicated queue and converts the descriptor
  * chain into its OUT (to device) and IN to guest components, but does NOT remove it from
- * the 'avail' queue. I.e. doesn't advance the index.  This can be used with virtioQueueSkip(),
+ * the 'avail' queue. I.e. doesn't advance the index.  This can be used with virtioVirtqSkip(),
  * which *does* advance the avail index. Together they facilitate a mechanism that allows
  * work with a queue element (descriptor chain) to be aborted if necessary, by not advancing
@@ -1011 +1009 @@
  * Additionally it converts the OUT desc chain data to a contiguous virtual
  * memory buffer for easy consumption by the caller. The caller must return the
- * descriptor chain pointer via virtioCoreR3QueuePut() and then call virtioCoreQueueSync()
+ * descriptor chain pointer via virtioCoreR3VirtqPut() and then call virtioCoreVirtqSync()
  * at some point to return the data to the guest and complete the transaction.
  *
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  * @param   ppDescChain Address to store pointer to descriptor chain that contains the
  *                      pre-processed transaction information pulled from the virtq.
@@ -1026 +1024 @@
  */
 
-int virtioCoreR3QueuePeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+int virtioCoreR3VirtqPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                          PPVIRTIO_DESC_CHAIN_T ppDescChain)
 {
-    return virtioCoreR3QueueGet(pDevIns, pVirtio,  idxQueue, ppDescChain, false);
-}
-
-/**
- * Skip the next entry in the specified queue (typically used with virtioCoreR3QueuePeek())
+    return virtioCoreR3VirtqGet(pDevIns, pVirtio,  idxVirtq, ppDescChain, false);
+}
+
+/**
+ * Skip the next entry in the specified queue (typically used with virtioCoreR3VirtqPeek())
  *
  * @param   pVirtio     Pointer to the virtio state.
- * @param   idxQueue    Index of queue
- */
-int virtioCoreR3QueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uQueueEnable[idxQueue],
+ * @param   idxVirtq    Index of queue
+ */
+int virtioCoreR3VirtqSkip(PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[idxVirtq],
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
-    if (IS_VIRTQ_EMPTY(pVirtio->pDevInsR3, pVirtio, pVirtq))
+    if (IS_VIRTQ_EMPTY(pVirtio->pDevInsR3, pVirtio, pVirtqState))
         return VERR_NOT_AVAILABLE;
 
-    Log6Func(("%s avail shadow idx: %u\n", pVirtq->szVirtqName, pVirtq->uAvailIdxShadow));
-    pVirtq->uAvailIdxShadow++;
+    Log6Func(("%s avail shadow idx: %u\n", pVirtqState->szVirtqName, pVirtqState->uAvailIdxShadow));
+    pVirtqState->uAvailIdxShadow++;
 
     return VINF_SUCCESS;
@@ -1061 +1059 @@
  * Additionally it converts the OUT desc chain data to a contiguous virtual
  * memory buffer for easy consumption by the caller. The caller must return the
- * descriptor chain pointer via virtioCoreR3QueuePut() and then call virtioCoreQueueSync()
+ * descriptor chain pointer via virtioCoreR3VirtqPut() and then call virtioCoreVirtqSync()
  * at some point to return the data to the guest and complete the transaction.
  *
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  * @param   ppDescChain Address to store pointer to descriptor chain that contains the
  *                      pre-processed transaction information pulled from the virtq.
@@ -1078 +1076 @@
  * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
  */
-int virtioCoreR3QueueGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+int virtioCoreR3VirtqGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                          PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove)
 {
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-
-    if (IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq))
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+
+    if (IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState))
         return VERR_NOT_AVAILABLE;
 
-    uint16_t uHeadIdx = virtioReadAvailDescIdx(pDevIns, pVirtio, idxQueue, pVirtq->uAvailIdxShadow);
+    uint16_t uHeadIdx = virtioReadAvailDescIdx(pDevIns, pVirtio, idxVirtq, pVirtqState->uAvailIdxShadow);
 
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
-        virtioWriteUsedAvailEvent(pDevIns,pVirtio, idxQueue, pVirtq->uAvailIdxShadow + 1);
+        virtioWriteUsedAvailEvent(pDevIns,pVirtio, idxVirtq, pVirtqState->uAvailIdxShadow + 1);
 
     if (fRemove)
-        pVirtq->uAvailIdxShadow++;
-
-    int rc = virtioCoreR3DescChainGet(pDevIns, pVirtio, idxQueue, uHeadIdx, ppDescChain);
+        pVirtqState->uAvailIdxShadow++;
+
+    int rc = virtioCoreR3DescChainGet(pDevIns, pVirtio, idxVirtq, uHeadIdx, ppDescChain);
     return rc;
 }
 
 /**
- * Returns data to the guest to complete a transaction initiated by virtQueueGet().
+ * Returns data to the guest to complete a transaction initiated by virtVirtqGet().
  *
  * The caller passes in a pointer to a scatter-gather buffer of virtual memory segments
@@ -1108 +1106 @@
  *
  * @note This does a write-ahead to the used ring of the guest's queue. The data
- *       written won't be seen by the guest until the next call to virtioCoreQueueSync()
+ *       written won't be seen by the guest until the next call to virtioCoreVirtqSync()
  *
  *
  * @param   pDevIns         The device instance (for reading).
  * @param   pVirtio         Pointer to the shared virtio state.
- * @param   idxQueue        Queue number
+ * @param   idxVirtq        Virtq number
  *
  * @param   pSgVirtReturn   Points to scatter-gather buffer of virtual memory
@@ -1127 +1125 @@
  * @retval  VINF_SUCCESS       Success
  * @retval  VERR_INVALID_STATE VirtIO not in ready state
- * @retval  VERR_NOT_AVAILABLE Queue is empty
+ * @retval  VERR_NOT_AVAILABLE Virtq is empty
  *
  * @note    This function will not release any reference to pDescChain.  The
  *          caller must take care of that.
  */
-int virtioCoreR3QueuePut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
+int virtioCoreR3VirtqPut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, PRTSGBUF pSgVirtReturn,
                          PVIRTIO_DESC_CHAIN_T pDescChain, bool fFence)
 {
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
     PVIRTIOSGBUF pSgPhysReturn = pDescChain->pSgPhysReturn;
 
@@ -1145 +1143 @@
 
     Log6Func(("Copying client data to %s, desc chain (head desc_idx %d)\n",
-              VIRTQNAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue)));
+              VIRTQNAME(pVirtio, idxVirtq), virtioReadUsedRingIdx(pDevIns, pVirtio, idxVirtq)));
 
     /* Copy s/g buf (virtual memory) to guest phys mem (IN direction). */
@@ -1175 +1173 @@
     /* If this write-ahead crosses threshold where the driver wants to get an event flag it */
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
-        if (pVirtq->uUsedIdxShadow == virtioReadAvailUsedEvent(pDevIns, pVirtio, idxQueue))
-            pVirtq->fVirtqRingEventThreshold = true;
+        if (pVirtqState->uUsedIdxShadow == virtioReadAvailUsedEvent(pDevIns, pVirtio, idxVirtq))
+            pVirtqState->fVirtqRingEventThreshold = true;
 
     /*
      * Place used buffer's descriptor in used ring but don't update used ring's slot index.
-     * That will be done with a subsequent client call to virtioCoreQueueSync() */
-    virtioWriteUsedElem(pDevIns, pVirtio, idxQueue, pVirtq->uUsedIdxShadow++, pDescChain->uHeadIdx, (uint32_t)cbTotal);
+     * That will be done with a subsequent client call to virtioCoreVirtqSync() */
+    virtioWriteUsedElem(pDevIns, pVirtio, idxVirtq, pVirtqState->uUsedIdxShadow++, pDescChain->uHeadIdx, (uint32_t)cbTotal);
 
     if (pSgVirtReturn)
@@ -1188 +1186 @@
 
     Log6Func(("Write ahead used_idx=%u, %s used_idx=%u\n",
-              pVirtq->uUsedIdxShadow, VIRTQNAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue)));
+              pVirtqState->uUsedIdxShadow, VIRTQNAME(pVirtio, idxVirtq), virtioReadUsedRingIdx(pDevIns, pVirtio, idxVirtq)));
 
     return VINF_SUCCESS;
@@ -1198 +1196 @@
  * Updates the indicated virtq's "used ring" descriptor index to match the
  * current write-head index, thus exposing the data added to the used ring by all
- * virtioCoreR3QueuePut() calls since the last sync. This should be called after one or
- * more virtioCoreR3QueuePut() calls to inform the guest driver there is data in the queue.
+ * virtioCoreR3VirtqPut() calls since the last sync. This should be called after one or
+ * more virtioCoreR3VirtqPut() calls to inform the guest driver there is data in the queue.
  * Explicit notifications (e.g. interrupt or MSI-X) will be sent to the guest,
  * depending on VirtIO features negotiated and conditions, otherwise the guest
@@ -1206 +1204 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue number
+ * @param   idxVirtq    Virtq number
  *
  * @returns VBox status code.
@@ -1212 +1210 @@
  * @retval  VERR_INVALID_STATE VirtIO not in ready state
  */
-int virtioCoreQueueSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uQueueEnable[idxQueue],
+int virtioCoreVirtqSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[idxVirtq],
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
     Log6Func(("Updating %s used_idx to %u\n",
-              VIRTQNAME(pVirtio, idxQueue), pVirtq->uUsedIdxShadow));
-
-    virtioWriteUsedRingIdx(pDevIns, pVirtio, idxQueue, pVirtq->uUsedIdxShadow);
-    virtioCoreNotifyGuestDriver(pDevIns, pVirtio, idxQueue);
+              VIRTQNAME(pVirtio, idxVirtq), pVirtqState->uUsedIdxShadow));
+
+    virtioWriteUsedRingIdx(pDevIns, pVirtio, idxVirtq, pVirtqState->uUsedIdxShadow);
+    virtioCoreNotifyGuestDriver(pDevIns, pVirtio, idxVirtq);
 
     return VINF_SUCCESS;
@@ -1232 +1230 @@
 /**
  */
-static void virtioCoreQueueNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint16_t uNotifyIdx)
+static void virtioCoreVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, uint16_t uNotifyIdx)
 {
 
     PVIRTIOCORECC pVirtioCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOCORECC);
 
-    /* See VirtIO 1.0, section 4.1.5.2 It implies that idxQueue and uNotifyIdx should match.
+    /* See VirtIO 1.0, section 4.1.5.2 It implies that idxVirtq and uNotifyIdx should match.
      * Disregarding this notification may cause throughput to stop, however there's no way to know
      * which was queue was intended for wake-up if the two parameters disagree. */
 
-    AssertMsg(uNotifyIdx == idxQueue,
+    AssertMsg(uNotifyIdx == idxVirtq,
                     ("Guest kicked virtq %d's notify addr w/non-corresponding virtq idx %d\n",
-                     idxQueue, uNotifyIdx));
+                     idxVirtq, uNotifyIdx));
     RT_NOREF(uNotifyIdx);
 
-    AssertReturnVoid(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
+    AssertReturnVoid(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
     Log6Func(("%s (desc chains: %u)\n",
-        pVirtio->virtqState[idxQueue].szVirtqName,
-        virtioCoreQueueAvailCount(pDevIns, pVirtio, idxQueue)));
+        pVirtio->aVirtqState[idxVirtq].szVirtqName,
+        virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq)));
 
     /* Inform client */
-    pVirtioCC->pfnQueueNotified(pDevIns, pVirtio, idxQueue);
+    pVirtioCC->pfnVirtqNotified(pDevIns, pVirtio, idxVirtq);
 }
 
@@ -1264 +1262 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   idxQueue    Queue to check for guest interrupt handling preference
- */
-static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
+ * @param   idxVirtq    Virtq to check for guest interrupt handling preference
+ */
+static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
 
     if (!IS_DRIVER_OK(pVirtio))
@@ -1280 +1278 @@
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
     {
-        if (pVirtq->fVirtqRingEventThreshold)
+        if (pVirtqState->fVirtqRingEventThreshold)
         {
 #ifdef IN_RING3
             Log6Func(("...kicking guest %s, VIRTIO_F_EVENT_IDX set and threshold (%d) reached\n",
-                   VIRTQNAME(pVirtio, idxQueue), (uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, idxQueue)));
+                   VIRTQNAME(pVirtio, idxVirtq), (uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, idxVirtq)));
 #endif
-            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue]);
-            pVirtq->fVirtqRingEventThreshold = false;
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uVirtqMsixVector[idxVirtq]);
+            pVirtqState->fVirtqRingEventThreshold = false;
             return;
         }
 #ifdef IN_RING3
         Log6Func(("...skip interrupt %s, VIRTIO_F_EVENT_IDX set but threshold (%d) not reached (%d)\n",
-                   VIRTQNAME(pVirtio, idxQueue),(uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, idxQueue), pVirtq->uUsedIdxShadow));
+                   VIRTQNAME(pVirtio, idxVirtq),(uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, idxVirtq), pVirtqState->uUsedIdxShadow));
 #endif
     }
@@ -1298 +1296 @@
     {
         /** If guest driver hasn't suppressed interrupts, interrupt  */
-        if (!(virtioReadAvailRingFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT))
-        {
-            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue]);
+        if (!(virtioReadAvailRingFlags(pDevIns, pVirtio, idxVirtq) & VIRTQ_AVAIL_F_NO_INTERRUPT))
+        {
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uVirtqMsixVector[idxVirtq]);
             return;
         }
         Log6Func(("...skipping interrupt for %s (guest set VIRTQ_AVAIL_F_NO_INTERRUPT)\n",
-                     VIRTQNAME(pVirtio, idxQueue)));
+                     VIRTQNAME(pVirtio, idxVirtq)));
     }
 }
@@ -1349 +1347 @@
 
 #ifdef IN_RING3
-static void virtioResetQueue(PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-    pVirtq->uAvailIdxShadow = 0;
-    pVirtq->uUsedIdxShadow  = 0;
-    pVirtq->fVirtqRingEventThreshold = false;
-    pVirtio->uQueueEnable[idxQueue] = false;
-    pVirtio->uQueueSize[idxQueue] = VIRTQ_MAX_ENTRIES;
-    pVirtio->uQueueNotifyOff[idxQueue] = idxQueue;
-    pVirtio->uQueueMsixVector[idxQueue] = idxQueue + 2;
+static void virtioResetVirtq(PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[idxVirtq];
+    pVirtqState->uAvailIdxShadow = 0;
+    pVirtqState->uUsedIdxShadow  = 0;
+    pVirtqState->fVirtqRingEventThreshold = false;
+    pVirtio->uVirtqEnable[idxVirtq] = false;
+    pVirtio->uVirtqSize[idxVirtq] = VIRTQ_MAX_ENTRIES;
+    pVirtio->uVirtqNotifyOff[idxVirtq] = idxVirtq;
+    pVirtio->uVirtqMsixVector[idxVirtq] = idxVirtq + 2;
     if (!pVirtio->fMsiSupport) /* VirtIO 1.0, 4.1.4.3 and 4.1.5.1.2 */
-        pVirtio->uQueueMsixVector[idxQueue] = VIRTIO_MSI_NO_VECTOR;
-
-    virtioLowerInterrupt(pVirtio->pDevInsR3, pVirtio->uQueueMsixVector[idxQueue]);
+        pVirtio->uVirtqMsixVector[idxVirtq] = VIRTIO_MSI_NO_VECTOR;
+
+    virtioLowerInterrupt(pVirtio->pDevInsR3, pVirtio->uVirtqMsixVector[idxVirtq]);
 }
 
@@ -1382 +1380 @@
         for (int i = 0; i < VIRTQ_MAX_CNT; i++)
         {
-            virtioLowerInterrupt(pDevIns, pVirtio->uQueueMsixVector[i]);
-            pVirtio->uQueueMsixVector[i];
+            virtioLowerInterrupt(pDevIns, pVirtio->uVirtqMsixVector[i]);
+            pVirtio->uVirtqMsixVector[i];
         }
     }
@@ -1390 +1388 @@
         pVirtio->uMsixConfig = VIRTIO_MSI_NO_VECTOR;
 
-    for (uint16_t idxQueue = 0; idxQueue < VIRTQ_MAX_CNT; idxQueue++)
-        virtioResetQueue(pVirtio, idxQueue);
+    for (uint16_t idxVirtq = 0; idxVirtq < VIRTQ_MAX_CNT; idxVirtq++)
+        virtioResetVirtq(pVirtio, idxVirtq);
 }
 
@@ -1579 +1577 @@
         }
     }
-    else if (MATCH_COMMON_CFG(uNumQueues))
+    else if (MATCH_COMMON_CFG(uNumVirtqs))
     {
         if (fWrite)
@@ -1589 +1587 @@
         {
             *(uint16_t *)pv = VIRTQ_MAX_CNT;
-            LOG_COMMON_CFG_ACCESS(uNumQueues, 0);
+            LOG_COMMON_CFG_ACCESS(uNumVirtqs, 0);
         }
     }
@@ -1651 +1649 @@
         COMMON_CFG_ACCESSOR_READONLY(uConfigGeneration);
     else
-    if (MATCH_COMMON_CFG(uQueueSelect))
-        COMMON_CFG_ACCESSOR(uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(uQueueSize))
-        COMMON_CFG_ACCESSOR_INDEXED(uQueueSize, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(uQueueMsixVector))
-        COMMON_CFG_ACCESSOR_INDEXED(uQueueMsixVector, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(uQueueEnable))
-        COMMON_CFG_ACCESSOR_INDEXED(uQueueEnable, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(uQueueNotifyOff))
-        COMMON_CFG_ACCESSOR_INDEXED_READONLY(uQueueNotifyOff, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(aGCPhysQueueDesc))
-        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysQueueDesc, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(aGCPhysQueueAvail))
-        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysQueueAvail, pVirtio->uQueueSelect);
-    else
-    if (MATCH_COMMON_CFG(aGCPhysQueueUsed))
-        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysQueueUsed, pVirtio->uQueueSelect);
+    if (MATCH_COMMON_CFG(uVirtqSelect))
+        COMMON_CFG_ACCESSOR(uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(uVirtqSize))
+        COMMON_CFG_ACCESSOR_INDEXED(uVirtqSize, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(uVirtqMsixVector))
+        COMMON_CFG_ACCESSOR_INDEXED(uVirtqMsixVector, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(uVirtqEnable))
+        COMMON_CFG_ACCESSOR_INDEXED(uVirtqEnable, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(uVirtqNotifyOff))
+        COMMON_CFG_ACCESSOR_INDEXED_READONLY(uVirtqNotifyOff, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(aGCPhysVirtqDesc))
+        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysVirtqDesc, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(aGCPhysVirtqAvail))
+        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysVirtqAvail, pVirtio->uVirtqSelect);
+    else
+    if (MATCH_COMMON_CFG(aGCPhysVirtqUsed))
+        COMMON_CFG_ACCESSOR_INDEXED(aGCPhysVirtqUsed, pVirtio->uVirtqSelect);
     else
     {
@@ -1809 +1807 @@
     if (MATCHES_VIRTIO_CAP_STRUCT(off, cb, uOffset, pVirtio->LocNotifyCap) && cb == sizeof(uint16_t))
     {
-        virtioCoreQueueNotified(pDevIns, pVirtio, uOffset / VIRTIO_NOTIFY_OFFSET_MULTIPLIER, *(uint16_t *)pv);
+        virtioCoreVirtqNotified(pDevIns, pVirtio, uOffset / VIRTIO_NOTIFY_OFFSET_MULTIPLIER, *(uint16_t *)pv);
         return VINF_SUCCESS;
     }
@@ -1918 +1916 @@
     pHlp->pfnSSMPutU8(pSSM,     pVirtio->uPciCfgDataOff);
     pHlp->pfnSSMPutU8(pSSM,     pVirtio->uISR);
-    pHlp->pfnSSMPutU16(pSSM,    pVirtio->uQueueSelect);
+    pHlp->pfnSSMPutU16(pSSM,    pVirtio->uVirtqSelect);
     pHlp->pfnSSMPutU32(pSSM,    pVirtio->uDeviceFeaturesSelect);
     pHlp->pfnSSMPutU32(pSSM,    pVirtio->uDriverFeaturesSelect);
@@ -1925 +1923 @@
     for (uint32_t i = 0; i < VIRTQ_MAX_CNT; i++)
     {
-        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysQueueDesc[i]);
-        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysQueueAvail[i]);
-        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysQueueUsed[i]);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uQueueNotifyOff[i]);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uQueueMsixVector[i]);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uQueueEnable[i]);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uQueueSize[i]);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->virtqState[i].uAvailIdxShadow);
-        pHlp->pfnSSMPutU16(pSSM,      pVirtio->virtqState[i].uUsedIdxShadow);
-        int rc = pHlp->pfnSSMPutMem(pSSM, pVirtio->virtqState[i].szVirtqName, 32);
+        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysVirtqDesc[i]);
+        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysVirtqAvail[i]);
+        pHlp->pfnSSMPutGCPhys64(pSSM, pVirtio->aGCPhysVirtqUsed[i]);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uVirtqNotifyOff[i]);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uVirtqMsixVector[i]);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uVirtqEnable[i]);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->uVirtqSize[i]);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->aVirtqState[i].uAvailIdxShadow);
+        pHlp->pfnSSMPutU16(pSSM,      pVirtio->aVirtqState[i].uUsedIdxShadow);
+        int rc = pHlp->pfnSSMPutMem(pSSM, pVirtio->aVirtqState[i].szVirtqName, 32);
         AssertRCReturn(rc, rc);
     }
@@ -1976 +1974 @@
     pHlp->pfnSSMGetU8(pSSM,   &pVirtio->uPciCfgDataOff);
     pHlp->pfnSSMGetU8(pSSM,   &pVirtio->uISR);
-    pHlp->pfnSSMGetU16(pSSM,  &pVirtio->uQueueSelect);
+    pHlp->pfnSSMGetU16(pSSM,  &pVirtio->uVirtqSelect);
     pHlp->pfnSSMGetU32(pSSM,  &pVirtio->uDeviceFeaturesSelect);
     pHlp->pfnSSMGetU32(pSSM,  &pVirtio->uDriverFeaturesSelect);
@@ -1983 +1981 @@
     for (uint32_t i = 0; i < VIRTQ_MAX_CNT; i++)
     {
-        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysQueueDesc[i]);
-        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysQueueAvail[i]);
-        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysQueueUsed[i]);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uQueueNotifyOff[i]);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uQueueMsixVector[i]);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uQueueEnable[i]);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uQueueSize[i]);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->virtqState[i].uAvailIdxShadow);
-        pHlp->pfnSSMGetU16(pSSM, &pVirtio->virtqState[i].uUsedIdxShadow);
-        rc = pHlp->pfnSSMGetMem(pSSM, pVirtio->virtqState[i].szVirtqName,
-                                sizeof(pVirtio->virtqState[i].szVirtqName));
+        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysVirtqDesc[i]);
+        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysVirtqAvail[i]);
+        pHlp->pfnSSMGetGCPhys64(pSSM, &pVirtio->aGCPhysVirtqUsed[i]);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uVirtqNotifyOff[i]);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uVirtqMsixVector[i]);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uVirtqEnable[i]);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->uVirtqSize[i]);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->aVirtqState[i].uAvailIdxShadow);
+        pHlp->pfnSSMGetU16(pSSM, &pVirtio->aVirtqState[i].uUsedIdxShadow);
+        rc = pHlp->pfnSSMGetMem(pSSM, pVirtio->aVirtqState[i].szVirtqName,
+                                sizeof(pVirtio->aVirtqState[i].szVirtqName));
         AssertRCReturn(rc, rc);
     }
@@ -2028 +2026 @@
             break;
         case kvirtIoVmStateChangedResume:
-            virtioCoreNotifyGuestDriver(pVirtio->pDevInsR3, pVirtio, 0 /* idxQueue */);
+            virtioCoreNotifyGuestDriver(pVirtio->pDevInsR3, pVirtio, 0 /* idxVirtq */);
             break;
         default:
@@ -2090 +2088 @@
      */
     AssertReturn(pVirtioCC->pfnStatusChanged, VERR_INVALID_POINTER);
-    AssertReturn(pVirtioCC->pfnQueueNotified, VERR_INVALID_POINTER);
+    AssertReturn(pVirtioCC->pfnVirtqNotified, VERR_INVALID_POINTER);
 
 #if 0 /* Until pdmR3DvHlp_PCISetIrq() impl is fixed and Assert that limits vec to 0 is removed */
@@ -2173 +2171 @@
     /*
      * Notify capability (VirtIO 1.0 spec, section 4.1.4.4). Note: uLength is based on the choice
-     * of this implementation to make each queue's uQueueNotifyOff equal to (QueueSelect) ordinal
+     * of this implementation to make each queue's uVirtqNotifyOff equal to (VirtqSelect) ordinal
      * value of the queue (different strategies are possible according to spec).
      */

trunk/src/VBox/Devices/VirtIO/Virtio_1_0.h

@@ -52 +52 @@
   * TEMPORARY NOTE: Some of these values are experimental during development and will likely change.
   */
-#define VIRTIO_MAX_QUEUE_NAME_SIZE          32                   /**< Maximum length of a queue name           */
+#define VIRTIO_MAX_VIRTQ_NAME_SIZE          32                   /**< Maximum length of a queue name           */
 #define VIRTQ_MAX_ENTRIES                   1024                 /**< Max size (# desc elements) of a virtq    */
 #define VIRTQ_MAX_CNT                       24                   /**< Max queues we allow guest to create      */
@@ -187 +187 @@
 typedef struct VIRTQSTATE
 {
-    uint16_t  idxQueue;                                          /**< Index of this queue                       */
+    uint16_t  idxVirtq;                                          /**< Index of this queue                       */
     char      szVirtqName[32];                                   /**< Dev-specific name of queue                */
     uint16_t  uAvailIdxShadow;                                   /**< Consumer's position in avail ring         */
@@ -207 +207 @@
     uint32_t  uDriverFeatures;                                   /**< RW (driver-accepted device features)      */
     uint16_t  uMsixConfig;                                       /**< RW (driver sets MSI-X config vector)      */
-    uint16_t  uNumQueues;                                        /**< RO (device specifies max queues)          */
+    uint16_t  uNumVirtqs;                                        /**< RO (device specifies max queues)          */
     uint8_t   uDeviceStatus;                                     /**< RW (driver writes device status, 0=reset) */
     uint8_t   uConfigGeneration;                                 /**< RO (device changes when changing configs) */
 
-    /* Per virtqueue fields (as determined by uQueueSelect) */
-    uint16_t  uQueueSelect;                                      /**< RW (selects queue focus for these fields) */
-    uint16_t  uQueueSize;                                        /**< RW (queue size, 0 - 2^n)                  */
-    uint16_t  uQueueMsixVector;                                  /**< RW (driver selects MSI-X queue vector)    */
-    uint16_t  uQueueEnable;                                      /**< RW (driver controls usability of queue)   */
-    uint16_t  uQueueNotifyOff;                                   /**< RO (offset uto virtqueue; see spec)       */
-    uint64_t  aGCPhysQueueDesc;                                  /**< RW (driver writes desc table phys addr)   */
-    uint64_t  aGCPhysQueueAvail;                                 /**< RW (driver writes avail ring phys addr)   */
-    uint64_t  aGCPhysQueueUsed;                                  /**< RW (driver writes used ring  phys addr)   */
+    /* Per virtqueue fields (as determined by uVirtqSelect) */
+    uint16_t  uVirtqSelect;                                      /**< RW (selects queue focus for these fields) */
+    uint16_t  uVirtqSize;                                        /**< RW (queue size, 0 - 2^n)                  */
+    uint16_t  uVirtqMsixVector;                                  /**< RW (driver selects MSI-X queue vector)    */
+    uint16_t  uVirtqEnable;                                      /**< RW (driver controls usability of queue)   */
+    uint16_t  uVirtqNotifyOff;                                   /**< RO (offset uto virtqueue; see spec)       */
+    uint64_t  aGCPhysVirtqDesc;                                  /**< RW (driver writes desc table phys addr)   */
+    uint64_t  aGCPhysVirtqAvail;                                 /**< RW (driver writes avail ring phys addr)   */
+    uint64_t  aGCPhysVirtqUsed;                                  /**< RW (driver writes used ring  phys addr)   */
 } VIRTIO_PCI_COMMON_CFG_T, *PVIRTIO_PCI_COMMON_CFG_T;
 
@@ -253 +253 @@
     PPDMDEVINS                  pDevInsR0;                          /**< Client device instance                    */
     PPDMDEVINS                  pDevInsR3;                          /**< Client device instance                    */
-    RTGCPHYS                    aGCPhysQueueDesc[VIRTQ_MAX_CNT];    /**< (MMIO) PhysAdr per-Q desc structs   GUEST */
-    RTGCPHYS                    aGCPhysQueueAvail[VIRTQ_MAX_CNT];   /**< (MMIO) PhysAdr per-Q avail structs  GUEST */
-    RTGCPHYS                    aGCPhysQueueUsed[VIRTQ_MAX_CNT];    /**< (MMIO) PhysAdr per-Q used structs   GUEST */
-    uint16_t                    uQueueNotifyOff[VIRTQ_MAX_CNT];     /**< (MMIO) per-Q notify offset           HOST */
-    uint16_t                    uQueueMsixVector[VIRTQ_MAX_CNT];    /**< (MMIO) Per-queue vector for MSI-X   GUEST */
-    uint16_t                    uQueueEnable[VIRTQ_MAX_CNT];        /**< (MMIO) Per-queue enable             GUEST */
-    uint16_t                    uQueueSize[VIRTQ_MAX_CNT];          /**< (MMIO) Per-queue size          HOST/GUEST */
-    uint16_t                    uQueueSelect;                       /**< (MMIO) queue selector               GUEST */
+    RTGCPHYS                    aGCPhysVirtqDesc[VIRTQ_MAX_CNT];    /**< (MMIO) PhysAdr per-Q desc structs   GUEST */
+    RTGCPHYS                    aGCPhysVirtqAvail[VIRTQ_MAX_CNT];   /**< (MMIO) PhysAdr per-Q avail structs  GUEST */
+    RTGCPHYS                    aGCPhysVirtqUsed[VIRTQ_MAX_CNT];    /**< (MMIO) PhysAdr per-Q used structs   GUEST */
+    uint16_t                    uVirtqNotifyOff[VIRTQ_MAX_CNT];     /**< (MMIO) per-Q notify offset           HOST */
+    uint16_t                    uVirtqMsixVector[VIRTQ_MAX_CNT];    /**< (MMIO) Per-queue vector for MSI-X   GUEST */
+    uint16_t                    uVirtqEnable[VIRTQ_MAX_CNT];        /**< (MMIO) Per-queue enable             GUEST */
+    uint16_t                    uVirtqSize[VIRTQ_MAX_CNT];          /**< (MMIO) Per-queue size          HOST/GUEST */
+    uint16_t                    uVirtqSelect;                       /**< (MMIO) queue selector               GUEST */
     uint16_t                    padding;
     uint64_t                    uDeviceFeatures;                    /**< (MMIO) Host features offered         HOST */
@@ -270 +270 @@
     uint8_t                     uPrevDeviceStatus;                  /**< (MMIO) Prev Device Status           GUEST */
     uint8_t                     uConfigGeneration;                  /**< (MMIO) Device config sequencer       HOST */
-    VIRTQSTATE                  virtqState[VIRTQ_MAX_CNT];          /**< Local impl-specific queue context         */
+    VIRTQSTATE                  aVirtqState[VIRTQ_MAX_CNT];         /**< Local impl-specific queue context         */
 
     /** @name The locations of the capability structures in PCI config space and the BAR.
@@ -348 +348 @@
      * @param   pVirtio    Pointer to the shared virtio state.
      * @param   pVirtioCC  Pointer to the ring-3 virtio state.
-     * @param   idxQueue   Index of the notified queue
+     * @param   idxVirtq   Index of the notified queue
      */
-    DECLCALLBACKMEMBER(void, pfnQueueNotified)(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
+    DECLCALLBACKMEMBER(void, pfnVirtqNotified)(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq);
 
     /** @} */
@@ -381 +381 @@
      * @param   pVirtio    Pointer to the shared virtio state.
      * @param   pVirtioCC  Pointer to the ring-3 virtio state.
-     * @param   idxQueue   Index of the notified queue
+     * @param   idxVirtq   Index of the notified queue
      */
-    DECLCALLBACKMEMBER(void, pfnQueueNotified)(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
+    DECLCALLBACKMEMBER(void, pfnVirtqNotified)(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq);
 
 } VIRTIOCORER0;
@@ -405 +405 @@
  * @{ */
 
-int      virtioCoreQueueSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
-uint16_t virtioCoreQueueAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
-void     virtioCoreQueueEnable(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnable);
-void     virtioCoreQueueNotifyEnable(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnable);
+int      virtioCoreVirtqSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq);
+uint16_t virtioCoreVirtqAvailCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq);
+void     virtioCoreVirtqEnable(PVIRTIOCORE pVirtio, uint16_t idxVirtq, bool fEnable);
+void     virtioCoreVirtqNotifyEnable(PVIRTIOCORE pVirtio, uint16_t idxVirtq, bool fEnable);
 void     virtioCoreNotifyConfigChanged(PVIRTIOCORE pVirtio);
 void     virtioCoreResetAll(PVIRTIOCORE pVirtio);
@@ -416 +416 @@
 uint32_t virtioCoreR3DescChainRelease(PVIRTIOCORE pVirtio, PVIRTIO_DESC_CHAIN_T pDescChain);
 void     virtioCoreR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs);
-void     virtioCoreR3QueueInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int idxQueue);
-int      virtioCoreR3QueueAttach(PVIRTIOCORE pVirtio, uint16_t idxQueue, const char *pcszName);
-
-int      virtioCoreR3DescChainGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+void     virtioCoreR3VirtqInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int idxVirtq);
+int      virtioCoreR3VirtqAttach(PVIRTIOCORE pVirtio, uint16_t idxVirtq, const char *pcszName);
+
+int      virtioCoreR3DescChainGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                                   uint16_t uHeadIdx, PPVIRTIO_DESC_CHAIN_T ppDescChain);
 
-int      virtioCoreR3QueuePeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+int      virtioCoreR3VirtqPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                                PPVIRTIO_DESC_CHAIN_T ppDescChain);
 
-int      virtioCoreR3QueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue);
-
-int      virtioCoreR3QueueGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+int      virtioCoreR3VirtqSkip(PVIRTIOCORE pVirtio, uint16_t idxVirtq);
+
+int      virtioCoreR3VirtqGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq,
                               PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove);
 
-int      virtioCoreR3QueuePut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
+int      virtioCoreR3VirtqPut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq, PRTSGBUF pSgVirtReturn,
                               PVIRTIO_DESC_CHAIN_T pDescChain, bool fFence);
 
@@ -438 +438 @@
  *
  * @param   pVirtio     Pointer to the virtio state.
- * @param   idxQueue    Queue number.
+ * @param   idxVirtq    Virtq number.
  * @returns   true or false indicating whether to enable queue or not
  */
-DECLINLINE(bool) virtioCoreIsQueueEnabled(PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    return pVirtio->uQueueEnable[idxQueue] != 0;
+DECLINLINE(bool) virtioCoreIsVirtqEnabled(PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    Assert(idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    return pVirtio->uVirtqEnable[idxVirtq] != 0;
 }
 
 /**
- * Get name of queue, by idxQueue, assigned at virtioCoreR3QueueAttach()
+ * Get name of queue, by idxVirtq, assigned at virtioCoreR3VirtqAttach()
  *
  * @param   pVirtio     Pointer to the virtio state.
- * @param   idxQueue    Queue number.
+ * @param   idxVirtq    Virtq number.
  *
  * @returns Pointer to read-only queue name.
  */
-DECLINLINE(const char *) virtioCoreQueueGetName(PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert((size_t)idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    return pVirtio->virtqState[idxQueue].szVirtqName;
+DECLINLINE(const char *) virtioCoreVirtqGetName(PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+{
+    Assert((size_t)idxVirtq < RT_ELEMENTS(pVirtio->aVirtqState));
+    return pVirtio->aVirtqState[idxVirtq].szVirtqName;
 }
 
@@ -467 +467 @@
  */
 DECLINLINE(uint64_t) virtioCoreGetNegotiatedFeatures(PVIRTIOCORE pVirtio)
-{
-    return pVirtio->uDriverFeatures;
-}
-
-/**
- * Get VirtIO accepted host-side features
- *
- * @returns feature bits selected or 0 if selector out of range.
- *
- * @param   pState          Virtio state
- */
-DECLINLINE(uint64_t) virtioCoreGetAcceptedFeatures(PVIRTIOCORE pVirtio)
 {
     return pVirtio->uDriverFeatures;