Changeset 84803 in vbox for trunk/src/VBox/Devices/Storage

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

File:

• trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp (modified) (65 diffs)

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);
 }