Changeset 85109 in vbox for trunk/src/VBox/Devices/VirtIO

Timestamp:

Jul 8, 2020 2:03:45 PM (5 years ago)

Author:

vboxsync

Message:

Resolved other part of xtracker #9766. Rearranged structs, arrays and pointers to improve cache locality (impacts: Network/DevVirtioNet.cpp, DevVirtioNet_1_0.cpp, and VirtIO/VirtioCore.*)

Location:

trunk/src/VBox/Devices/VirtIO

Files:

• VirtioCore.cpp (modified) (51 diffs)
• VirtioCore.h (modified) (15 diffs)

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

@@ -43 +43 @@
 *********************************************************************************************************************************/
 #define INSTANCE(a_pVirtio)                 ((a_pVirtio)->szInstance)
-#define VIRTQNAME(a_pVirtio, a_uVirtqNbr)   ((a_pVirtio)->aVirtqState[(a_uVirtqNbr)].szVirtqName)
+#define VIRTQNAME(a_pVirtio, a_uVirtq)      ((a_pVirtio)->aVirtqueues[(a_uVirtq)].szName)
+
 #define IS_DRIVER_OK(a_pVirtio)             ((a_pVirtio)->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
-#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState) \
-            (virtioCoreVirtqAvailBufCount(pDevIns, pVirtio, pVirtqState) == 0)
+#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq) \
+            (virtioCoreVirtqAvailBufCount_inline(pDevIns, pVirtio, pVirtq) == 0)
 
 /**
@@ -53 +54 @@
  * @a a_LocCapData.
  *
- *
- *
  * @param[in]  a_offAccess      Input:  The offset into the MMIO bar of the access.
  * @param[in]  a_cbAccess       Input:  The access size.
@@ -78 +77 @@
 /** @name virtq related flags
  * @{ */
-#define VIRTQ_DESC_F_NEXT                               1        /**< Indicates this descriptor chains to next  */
-#define VIRTQ_DESC_F_WRITE                              2        /**< Marks buffer as write-only (default ro)   */
-#define VIRTQ_DESC_F_INDIRECT                           4        /**< Buffer is list of buffer descriptors      */
-
-#define VIRTQ_USED_F_NO_NOTIFY                          1        /**< Dev to Drv: Don't notify when buf added   */
-#define VIRTQ_AVAIL_F_NO_INTERRUPT                      1        /**< Drv to Dev: Don't notify when buf eaten   */
+#define VIRTQUEUE_DESC_F_NEXT                               1        /**< Indicates this descriptor chains to next  */
+#define VIRTQUEUE_DESC_F_WRITE                              2        /**< Marks buffer as write-only (default ro)   */
+#define VIRTQUEUE_DESC_F_INDIRECT                           4        /**< Buffer is list of buffer descriptors      */
+
+#define VIRTQUEUE_USED_F_NO_NOTIFY                          1        /**< Dev to Drv: Don't notify when buf added   */
+#define VIRTQUEUE_AVAIL_F_NO_INTERRUPT                      1        /**< Drv to Dev: Don't notify when buf eaten   */
 /** @} */
 
@@ -96 +95 @@
     uint16_t  fFlags;                                            /**< flags      Buffer specific flags          */
     uint16_t  uDescIdxNext;                                      /**< next       Idx set if VIRTIO_DESC_F_NEXT  */
-} VIRTQ_DESC_T, *PVIRTQ_DESC_T;
+} VIRTQUEUE_DESC_T, *PVIRTQUEUE_DESC_T;
 
 typedef struct virtq_avail
@@ -104 +103 @@
     RT_FLEXIBLE_ARRAY_EXTENSION
     uint16_t  auRing[RT_FLEXIBLE_ARRAY];                         /**< ring       Ring: avail drv to dev bufs    */
-    //uint16_t  uUsedEventIdx;                                   /**< used_event (if VIRTQ_USED_F_EVENT_IDX)    */
-} VIRTQ_AVAIL_T, *PVIRTQ_AVAIL_T;
+    //uint16_t  uUsedEventIdx;                                   /**< used_event (if VIRTQUEUE_USED_F_EVENT_IDX)    */
+} VIRTQUEUE_AVAIL_T, *PVIRTQUEUE_AVAIL_T;
 
 typedef struct virtq_used_elem
@@ -111 +110 @@
     uint32_t  uDescIdx;                                          /**< idx         Start of used desc chain      */
     uint32_t  cbElem;                                            /**< len         Total len of used desc chain  */
-} VIRTQ_USED_ELEM_T;
+} VIRTQUEUE_USED_ELEM_T;
 
 typedef struct virt_used
@@ -118 +117 @@
     uint16_t  uIdx;                                              /**< idx         Index of next ring slot       */
     RT_FLEXIBLE_ARRAY_EXTENSION
-    VIRTQ_USED_ELEM_T aRing[RT_FLEXIBLE_ARRAY];                  /**< ring        Ring: used dev to drv bufs    */
-    //uint16_t  uAvailEventIdx;                                  /**< avail_event if (VIRTQ_USED_F_EVENT_IDX)   */
-} VIRTQ_USED_T, *PVIRTQ_USED_T;
+    VIRTQUEUE_USED_ELEM_T aRing[RT_FLEXIBLE_ARRAY];                  /**< ring        Ring: used dev to drv bufs    */
+    //uint16_t  uAvailEventIdx;                                  /**< avail_event if (VIRTQUEUE_USED_F_EVENT_IDX)   */
+} VIRTQUEUE_USED_T, *PVIRTQUEUE_USED_T;
 
 
@@ -137 +136 @@
 /* Internal Functions */
 
-static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr);
+static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq);
 static int  virtioKick(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint8_t uCause, uint16_t uVec);
 
@@ -147 +146 @@
  */
 #ifdef IN_RING3
-DECLINLINE(void) virtioReadDesc(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
-                                uint32_t idxDesc, PVIRTQ_DESC_T pDesc)
+DECLINLINE(void) virtioReadDesc(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq,
+                                uint32_t idxDesc, PVIRTQUEUE_DESC_T pDesc)
 {
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[uVirtqNbr], 1); /* Make sure to avoid div-by-zero. */
+    RT_NOREF(pVirtio);
+    uint16_t const cVirtqItems = RT_MAX(pVirtq->uSize, 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqDesc[uVirtqNbr] + sizeof(VIRTQ_DESC_T) * (idxDesc % cVirtqItems),
-                      pDesc, sizeof(VIRTQ_DESC_T));
+                      pVirtq->GCPhysVirtqDesc + sizeof(VIRTQUEUE_DESC_T) * (idxDesc % cVirtqItems),
+                      pDesc, sizeof(VIRTQUEUE_DESC_T));
 }
 #endif
@@ -162 +162 @@
  */
 #ifdef IN_RING3
-DECLINLINE(uint16_t) virtioReadAvailDescIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, uint32_t availIdx)
+DECLINLINE(uint16_t) virtioReadAvailDescIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq, uint32_t availIdx)
 {
     uint16_t uDescIdx;
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[uVirtqNbr], 1); /* Make sure to avoid div-by-zero. */
+    RT_NOREF(pVirtio);
+    uint16_t const cVirtqItems = RT_MAX(pVirtq->uSize, 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysRead(pDevIns,
-                        pVirtio->aGCPhysVirtqAvail[uVirtqNbr]
-                      + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[availIdx % cVirtqItems]),
-                      &uDescIdx, sizeof(uDescIdx));
+                         pVirtq->GCPhysVirtqAvail + RT_UOFFSETOF_DYN(VIRTQUEUE_AVAIL_T, auRing[availIdx % cVirtqItems]),
+                         &uDescIdx, sizeof(uDescIdx));
     return uDescIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
+DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
 {
     uint16_t uUsedEventIdx;
     /* VirtIO 1.0 uUsedEventIdx (used_event) immediately follows ring */
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqAvail[uVirtqNbr] + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[pVirtio->uVirtqSize[uVirtqNbr]]),
-                      &uUsedEventIdx, sizeof(uUsedEventIdx));
+                         pVirtq->GCPhysVirtqAvail + RT_UOFFSETOF_DYN(VIRTQUEUE_AVAIL_T, auRing[pVirtq->uSize]),
+                         &uUsedEventIdx, sizeof(uUsedEventIdx));
     return uUsedEventIdx;
 }
 #endif
 
-DECLINLINE(uint16_t) virtioReadAvailRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
+DECLINLINE(uint16_t) virtioReadAvailRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
 {
     uint16_t uIdx = 0;
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqAvail[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_AVAIL_T, uIdx),
-                      &uIdx, sizeof(uIdx));
+                         pVirtq->GCPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUE_AVAIL_T, uIdx),
+                         &uIdx, sizeof(uIdx));
     return uIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadAvailRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
+DECLINLINE(uint16_t) virtioReadAvailRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
 {
     uint16_t fFlags = 0;
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqAvail[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_AVAIL_T, fFlags),
-                      &fFlags, sizeof(fFlags));
+                         pVirtq->GCPhysVirtqAvail + RT_UOFFSETOF(VIRTQUEUE_AVAIL_T, fFlags),
+                         &fFlags, sizeof(fFlags));
     return fFlags;
 }
@@ -213 +216 @@
 
 #ifdef IN_RING3
-DECLINLINE(void) virtioWriteUsedElem(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
+DECLINLINE(void) virtioWriteUsedElem(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq,
                                      uint32_t usedIdx, uint32_t uDescIdx, uint32_t uLen)
 {
-    VIRTQ_USED_ELEM_T elem = { uDescIdx,  uLen };
+    VIRTQUEUE_USED_ELEM_T elem = { uDescIdx,  uLen };
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    uint16_t const cVirtqItems = RT_MAX(pVirtio->uVirtqSize[uVirtqNbr], 1); /* Make sure to avoid div-by-zero. */
+    RT_NOREF(pVirtio);
+    uint16_t const cVirtqItems = RT_MAX(pVirtq->uSize, 1); /* Make sure to avoid div-by-zero. */
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[usedIdx % cVirtqItems]),
+                          pVirtq->GCPhysVirtqUsed
+                        + RT_UOFFSETOF_DYN(VIRTQUEUE_USED_T, aRing[usedIdx % cVirtqItems]),
                           &elem, sizeof(elem));
 }
 
-DECLINLINE(void) virtioWriteUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, uint16_t fFlags)
+DECLINLINE(void) virtioWriteUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq, uint16_t fFlags)
 {
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     RT_UNTRUSTED_VALIDATED_FENCE(); /* VirtIO 1.0, Section 3.2.1.4.1 */
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
+                          pVirtq->GCPhysVirtqUsed + RT_UOFFSETOF(VIRTQUEUE_USED_T, fFlags),
                           &fFlags, sizeof(fFlags));
 }
 #endif
 
-DECLINLINE(void) virtioWriteUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, uint16_t uIdx)
+DECLINLINE(void) virtioWriteUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq, uint16_t uIdx)
 {
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
+                          pVirtq->GCPhysVirtqUsed + RT_UOFFSETOF(VIRTQUEUE_USED_T, uIdx),
                           &uIdx, sizeof(uIdx));
 }
@@ -244 +251 @@
 
 #ifdef IN_RING3
-DECLINLINE(uint16_t) virtioReadUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
+DECLINLINE(uint16_t) virtioReadUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
 {
     uint16_t uIdx = 0;
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
-                      &uIdx, sizeof(uIdx));
+                         pVirtq->GCPhysVirtqUsed + RT_UOFFSETOF(VIRTQUEUE_USED_T, uIdx),
+                         &uIdx, sizeof(uIdx));
     return uIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
+DECLINLINE(uint16_t) virtioReadUsedRingFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
 {
     uint16_t fFlags = 0;
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysRead(pDevIns,
-                      pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
-                      &fFlags, sizeof(fFlags));
+                         pVirtq->GCPhysVirtqUsed + RT_UOFFSETOF(VIRTQUEUE_USED_T, fFlags),
+                         &fFlags, sizeof(fFlags));
     return fFlags;
 }
 
-DECLINLINE(void) virtioWriteUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, uint32_t uAvailEventIdx)
+DECLINLINE(void) virtioWriteUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq, uint32_t uAvailEventIdx)
 {
     /** VirtIO 1.0 uAvailEventIdx (avail_event) immediately follows ring */
     AssertMsg(pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
+    RT_NOREF(pVirtio);
     PDMDevHlpPCIPhysWrite(pDevIns,
-                          pVirtio->aGCPhysVirtqUsed[uVirtqNbr] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[pVirtio->uVirtqSize[uVirtqNbr]]),
+                          pVirtq->GCPhysVirtqUsed
+                        + RT_UOFFSETOF_DYN(VIRTQUEUE_USED_T, aRing[pVirtq->uSize]),
                           &uAvailEventIdx, sizeof(uAvailEventIdx));
 }
 #endif
 
-DECLINLINE(uint16_t) virtioCoreVirtqAvailBufCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQSTATE pVirtqState)
-{
-    uint16_t uIdx    = virtioReadAvailRingIdx(pDevIns, pVirtio, pVirtqState->uVirtqNbr);
-    uint16_t uShadow = pVirtqState->uAvailIdxShadow;
+DECLINLINE(uint16_t) virtioCoreVirtqAvailBufCount_inline(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, PVIRTQUEUE pVirtq)
+{
+    uint16_t uIdx    = virtioReadAvailRingIdx(pDevIns, pVirtio, pVirtq);
+    uint16_t uShadow = pVirtq->uAvailIdxShadow;
 
     uint16_t uDelta;
@@ -286 +297 @@
 
     LogFunc(("%s has %u %s (idx=%u shadow=%u)\n",
-        VIRTQNAME(pVirtio, pVirtqState->uVirtqNbr), uDelta, uDelta == 1 ? "entry" : "entries",
+        pVirtq->szName, uDelta, uDelta == 1 ? "entry" : "entries",
         uIdx, uShadow));
 
@@ -296 +307 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   uVirtqNbr   Virtq number
+ * @param   uVirtq      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 virtioCoreVirtqAvailBufCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
-{
-    if (!IS_DRIVER_OK(pVirtio) || !pVirtio->uVirtqEnable[uVirtqNbr])
+uint16_t virtioCoreVirtqAvailBufCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq)
+{
+    AssertMsgReturn(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues), ("uVirtq out of range"), 0);
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+    if (!IS_DRIVER_OK(pVirtio) || !pVirtq->uEnable)
     {
         LogRelFunc(("Driver not ready or queue not enabled\n"));
         return 0;
     }
-    return virtioCoreVirtqAvailBufCount(pDevIns, pVirtio, &pVirtio->aVirtqState[uVirtqNbr]);
+
+    return virtioCoreVirtqAvailBufCount_inline(pDevIns, pVirtio, pVirtq);
 }
 
@@ -444 +458 @@
     } const s_aFeatures[] =
     {
-        { VIRTIO_F_RING_INDIRECT_DESC,      "   RING_INDIRECT_DESC   Driver can use descriptors with VIRTQ_DESC_F_INDIRECT flag set\n" },
+        { VIRTIO_F_RING_INDIRECT_DESC,      "   RING_INDIRECT_DESC   Driver can use descriptors with VIRTQUEUE_DESC_F_INDIRECT flag set\n" },
         { VIRTIO_F_RING_EVENT_IDX,          "   RING_EVENT_IDX       Enables use_event and avail_event fields described in 2.4.7, 2.4.8\n" },
         { VIRTIO_F_VERSION_1,               "   VERSION              Used to detect legacy drivers.\n" },
@@ -659 +673 @@
 #ifdef IN_RING3
 
-int virtioCoreR3VirtqAttach(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, const char *pcszName)
+int virtioCoreR3VirtqAttach(PVIRTIOCORE pVirtio, uint16_t uVirtq, const char *pcszName)
 {
     LogFunc(("%s\n", pcszName));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-    pVirtqState->uVirtqNbr = uVirtqNbr;
-    pVirtqState->uAvailIdxShadow = 0;
-    pVirtqState->uUsedIdxShadow  = 0;
-    pVirtqState->fVirtqRingEventThreshold = false;
-    RTStrCopy(pVirtqState->szVirtqName, sizeof(pVirtqState->szVirtqName), pcszName);
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+    pVirtq->uVirtq = uVirtq;
+    pVirtq->uAvailIdxShadow = 0;
+    pVirtq->uUsedIdxShadow  = 0;
+    pVirtq->fUsedRingEvent = false;
+    RTStrCopy(pVirtq->szName, sizeof(pVirtq->szName), pcszName);
     return VINF_SUCCESS;
 }
 
 /** API Fuunction: See header file */
-void virtioCoreR3VirtqInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int uVirtqNbr)
+void virtioCoreR3VirtqInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs, int uVirtq)
 {
     RT_NOREF(pszArgs);
     PVIRTIOCORE pVirtio = PDMDEVINS_2_DATA(pDevIns, PVIRTIOCORE);
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
 
     /** @todo add ability to dump physical contents described by any descriptor (using existing VirtIO core API function) */
 //    bool fDump      = pszArgs && (*pszArgs == 'd' || *pszArgs == 'D'); /* "dump" (avail phys descriptor)"
 
-    uint16_t uAvailIdx       = virtioReadAvailRingIdx(pDevIns, pVirtio, uVirtqNbr);
-    uint16_t uAvailIdxShadow = pVirtqState->uAvailIdxShadow;
-
-    uint16_t uUsedIdx        = virtioReadUsedRingIdx(pDevIns, pVirtio, uVirtqNbr);
-    uint16_t uUsedIdxShadow  = pVirtqState->uUsedIdxShadow;
+    uint16_t uAvailIdx       = virtioReadAvailRingIdx(pDevIns, pVirtio, pVirtq);
+    uint16_t uAvailIdxShadow = pVirtq->uAvailIdxShadow;
+
+    uint16_t uUsedIdx        = virtioReadUsedRingIdx(pDevIns, pVirtio, pVirtq);
+    uint16_t uUsedIdxShadow  = pVirtq->uUsedIdxShadow;
 
     PVIRTQBUF pVirtqBuf = NULL;
 
-    bool fEmpty = IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState);
-
-    LogFunc(("%s, empty = %s\n", VIRTQNAME(pVirtio, uVirtqNbr), fEmpty ? "true" : "false"));
+    bool fEmpty = IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq);
+
+    LogFunc(("%s, empty = %s\n", pVirtq->szName, fEmpty ? "true" : "false"));
 
     int cSendSegs = 0, cReturnSegs = 0;
     if (!fEmpty)
     {
-        virtioCoreR3VirtqAvailBufPeek(pDevIns,  pVirtio, uVirtqNbr, &pVirtqBuf);
+        virtioCoreR3VirtqAvailBufPeek(pDevIns,  pVirtio, uVirtq, &pVirtqBuf);
         cSendSegs   = pVirtqBuf->pSgPhysSend ? pVirtqBuf->pSgPhysSend->cSegs : 0;
         cReturnSegs = pVirtqBuf->pSgPhysReturn ? pVirtqBuf->pSgPhysReturn->cSegs : 0;
     }
 
-    bool fAvailNoInterrupt   = virtioReadAvailRingFlags(pDevIns, pVirtio, uVirtqNbr) & VIRTQ_AVAIL_F_NO_INTERRUPT;
-    bool fUsedNoNotify       = virtioReadUsedRingFlags(pDevIns, pVirtio, uVirtqNbr) & VIRTQ_USED_F_NO_NOTIFY;
-
-
-    pHlp->pfnPrintf(pHlp, "       queue enabled: ........... %s\n", pVirtio->uVirtqEnable[uVirtqNbr] ? "true" : "false");
-    pHlp->pfnPrintf(pHlp, "       size: .................... %d\n", pVirtio->uVirtqSize[uVirtqNbr]);
-    pHlp->pfnPrintf(pHlp, "       notify offset: ........... %d\n", pVirtio->uVirtqNotifyOff[uVirtqNbr]);
+    bool fAvailNoInterrupt   = virtioReadAvailRingFlags(pDevIns, pVirtio, pVirtq) & VIRTQUEUE_AVAIL_F_NO_INTERRUPT;
+    bool fUsedNoNotify       = virtioReadUsedRingFlags(pDevIns, pVirtio, pVirtq) & VIRTQUEUE_USED_F_NO_NOTIFY;
+
+
+    pHlp->pfnPrintf(pHlp, "       queue enabled: ........... %s\n", pVirtq->uEnable ? "true" : "false");
+    pHlp->pfnPrintf(pHlp, "       size: .................... %d\n", pVirtq->uSize);
+    pHlp->pfnPrintf(pHlp, "       notify offset: ........... %d\n", pVirtq->uNotifyOffset);
     if (pVirtio->fMsiSupport)
-        pHlp->pfnPrintf(pHlp, "       MSIX vector: ....... %4.4x\n", pVirtio->uVirtqMsixVector[uVirtqNbr]);
+        pHlp->pfnPrintf(pHlp, "       MSIX vector: ....... %4.4x\n", pVirtq->uMsix);
     pHlp->pfnPrintf(pHlp, "\n");
     pHlp->pfnPrintf(pHlp, "       avail ring (%d entries):\n", uAvailIdx - uAvailIdxShadow);
@@ -750 +764 @@
 
 /** API Function: See header file */
-int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
+int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
                              uint16_t uHeadIdx, PPVIRTQBUF ppVirtqBuf)
 {
@@ -756 +770 @@
     *ppVirtqBuf = NULL;
 
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[uVirtqNbr],
+    AssertMsgReturn(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues),
+                        ("uVirtq out of range"), VERR_INVALID_PARAMETER);
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    if (!IS_DRIVER_OK(pVirtio) || !pVirtq->uEnable)
+    {
+        LogRelFunc(("Driver not ready or queue not enabled\n"));
+        return 0;
+    }
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtq->uEnable,
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
     uint16_t uDescIdx = uHeadIdx;
 
-    Log6Func(("%s DESC CHAIN: (head) desc_idx=%u\n", pVirtqState->szVirtqName, uHeadIdx));
-    RT_NOREF(pVirtqState);
+    Log6Func(("%s DESC CHAIN: (head) desc_idx=%u\n", pVirtq->szName, uHeadIdx));
 
     /*
@@ -773 +792 @@
     PVIRTQBUF pVirtqBuf = (PVIRTQBUF)RTMemAllocZ(sizeof(VIRTQBUF_T));
     AssertReturn(pVirtqBuf, VERR_NO_MEMORY);
-    pVirtqBuf->u32Magic = VIRTQBUF_MAGIC;
-    pVirtqBuf->cRefs    = 1;
-    pVirtqBuf->uHeadIdx = uHeadIdx;
-    pVirtqBuf->uVirtqNbr = uVirtqNbr;
+    pVirtqBuf->u32Magic  = VIRTQBUF_MAGIC;
+    pVirtqBuf->cRefs     = 1;
+    pVirtqBuf->uHeadIdx  = uHeadIdx;
+    pVirtqBuf->uVirtq = uVirtq;
     *ppVirtqBuf = pVirtqBuf;
 
@@ -782 +801 @@
      * Gather segments.
      */
-    VIRTQ_DESC_T desc;
+    VIRTQUEUE_DESC_T desc;
 
     uint32_t cbIn = 0;
@@ -816 +835 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        virtioReadDesc(pDevIns, pVirtio, uVirtqNbr, uDescIdx, &desc);
-
-        if (desc.fFlags & VIRTQ_DESC_F_WRITE)
-        {
-            Log6Func(("%s IN  desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, uVirtqNbr), uDescIdx, cSegsIn, desc.GCPhysBuf, desc.cb));
+        virtioReadDesc(pDevIns, pVirtio, pVirtq, uDescIdx, &desc);
+
+        if (desc.fFlags & VIRTQUEUE_DESC_F_WRITE)
+        {
+            Log6Func(("%s IN  desc_idx=%u seg=%u addr=%RGp cb=%u\n", pVirtq->szName, uDescIdx, cSegsIn, desc.GCPhysBuf, desc.cb));
             cbIn += desc.cb;
             pSeg = &paSegsIn[cSegsIn++];
@@ -826 +845 @@
         else
         {
-            Log6Func(("%s OUT desc_idx=%u seg=%u addr=%RGp cb=%u\n", VIRTQNAME(pVirtio, uVirtqNbr), uDescIdx, cSegsOut, desc.GCPhysBuf, desc.cb));
+            Log6Func(("%s OUT desc_idx=%u seg=%u addr=%RGp cb=%u\n", pVirtq->szName, uDescIdx, cSegsOut, desc.GCPhysBuf, desc.cb));
             cbOut += desc.cb;
             pSeg = &paSegsOut[cSegsOut++];
@@ -840 +859 @@
 
         uDescIdx = desc.uDescIdxNext;
-    } while (desc.fFlags & VIRTQ_DESC_F_NEXT);
+    } while (desc.fFlags & VIRTQUEUE_DESC_F_NEXT);
 
     /*
@@ -862 +881 @@
 
     STAM_REL_COUNTER_INC(&pVirtio->StatDescChainsAllocated);
-    Log6Func(("%s -- segs OUT: %u (%u bytes)   IN: %u (%u bytes) --\n", pVirtqState->szVirtqName, cSegsOut, cbOut, cSegsIn, cbIn));
+    Log6Func(("%s -- segs OUT: %u (%u bytes)   IN: %u (%u bytes) --\n",
+        pVirtq->szName, cSegsOut, cbOut, cSegsIn, cbIn));
 
     return VINF_SUCCESS;
@@ -903 +923 @@
 }
 
-void virtioCoreVirtqEnableNotify(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, bool fEnable)
-{
+/** API Function: See header file */
+void virtioCoreVirtqEnableNotify(PVIRTIOCORE pVirtio, uint16_t uVirtq, bool fEnable)
+{
+
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
     if (pVirtio->fDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
     {
-        uint16_t fFlags = virtioReadUsedRingFlags(pVirtio->pDevInsR3, pVirtio, uVirtqNbr);
+        uint16_t fFlags = virtioReadUsedRingFlags(pVirtio->pDevInsR3, pVirtio, pVirtq);
 
         if (fEnable)
-            fFlags &= ~ VIRTQ_USED_F_NO_NOTIFY;
+            fFlags &= ~ VIRTQUEUE_USED_F_NO_NOTIFY;
         else
-            fFlags |= VIRTQ_USED_F_NO_NOTIFY;
-
-        virtioWriteUsedRingFlags(pVirtio->pDevInsR3, pVirtio, uVirtqNbr, fFlags);
+            fFlags |= VIRTQUEUE_USED_F_NO_NOTIFY;
+
+        virtioWriteUsedRingFlags(pVirtio->pDevInsR3, pVirtio, pVirtq, fFlags);
     }
 }
@@ -931 +956 @@
 
 /** API function: See Header file  */
-int virtioCoreR3VirtqAvailBufPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
+int virtioCoreR3VirtqAvailBufPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
                          PPVIRTQBUF ppVirtqBuf)
 {
-    return virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtqNbr, ppVirtqBuf, false);
+    return virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, ppVirtqBuf, false);
 }
 
 /** API function: See Header file  */
-int virtioCoreR3VirtqAvailBufNext(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
-{
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[uVirtqNbr],
+int virtioCoreR3VirtqAvailBufNext(PVIRTIOCORE pVirtio, uint16_t uVirtq)
+{
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtq->uEnable,
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
-    if (IS_VIRTQ_EMPTY(pVirtio->pDevInsR3, pVirtio, pVirtqState))
+    if (IS_VIRTQ_EMPTY(pVirtio->pDevInsR3, pVirtio, pVirtq))
         return VERR_NOT_AVAILABLE;
 
-    Log6Func(("%s avail shadow idx: %u\n", pVirtqState->szVirtqName, pVirtqState->uAvailIdxShadow));
-    pVirtqState->uAvailIdxShadow++;
+    Log6Func(("%s avail shadow idx: %u\n", pVirtq->szName, pVirtq->uAvailIdxShadow));
+    pVirtq->uAvailIdxShadow++;
 
     return VINF_SUCCESS;
@@ -956 +981 @@
 
 /** API function: See Header file  */
-int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
+int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
                          PPVIRTQBUF ppVirtqBuf, bool fRemove)
 {
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-
-    if (IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtqState))
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    if (IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq))
         return VERR_NOT_AVAILABLE;
 
-    uint16_t uHeadIdx = virtioReadAvailDescIdx(pDevIns, pVirtio, uVirtqNbr, pVirtqState->uAvailIdxShadow);
+    uint16_t uHeadIdx = virtioReadAvailDescIdx(pDevIns, pVirtio, pVirtq, pVirtq->uAvailIdxShadow);
 
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
-        virtioWriteUsedAvailEvent(pDevIns,pVirtio, uVirtqNbr, pVirtqState->uAvailIdxShadow + 1);
+        virtioWriteUsedAvailEvent(pDevIns,pVirtio, pVirtq, pVirtq->uAvailIdxShadow + 1);
 
     if (fRemove)
-        pVirtqState->uAvailIdxShadow++;
-
-    int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtqNbr, uHeadIdx, ppVirtqBuf);
+        pVirtq->uAvailIdxShadow++;
+
+    int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, uHeadIdx, ppVirtqBuf);
     return rc;
 }
 
 /** API function: See Header file  */
-int virtioCoreR3VirtqUsedBufPut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, PRTSGBUF pSgVirtReturn,
+int virtioCoreR3VirtqUsedBufPut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq, PRTSGBUF pSgVirtReturn,
                             PVIRTQBUF pVirtqBuf, bool fFence)
 {
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
     PVIRTIOSGBUF pSgPhysReturn = pVirtqBuf->pSgPhysReturn;
 
@@ -990 +1017 @@
 
     Log6Func(("Copying client data to %s, desc chain (head desc_idx %d)\n",
-              VIRTQNAME(pVirtio, uVirtqNbr), virtioReadUsedRingIdx(pDevIns, pVirtio, uVirtqNbr)));
+              VIRTQNAME(pVirtio, uVirtq), virtioReadUsedRingIdx(pDevIns, pVirtio, pVirtq)));
 
     /* Copy s/g buf (virtual memory) to guest phys mem (IN direction). */
@@ -1020 +1047 @@
     /* If this write-ahead crosses threshold where the driver wants to get an event flag it */
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
-        if (pVirtqState->uUsedIdxShadow == virtioReadAvailUsedEvent(pDevIns, pVirtio, uVirtqNbr))
-            pVirtqState->fVirtqRingEventThreshold = true;
+        if (pVirtq->uUsedIdxShadow == virtioReadAvailUsedEvent(pDevIns, pVirtio, pVirtq))
+            pVirtq->fUsedRingEvent = 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 virtioCoreVirtqSyncUsedRing() */
-    virtioWriteUsedElem(pDevIns, pVirtio, uVirtqNbr, pVirtqState->uUsedIdxShadow++, pVirtqBuf->uHeadIdx, (uint32_t)cbTotal);
+    virtioWriteUsedElem(pDevIns, pVirtio, pVirtq, pVirtq->uUsedIdxShadow++, pVirtqBuf->uHeadIdx, (uint32_t)cbTotal);
 
     if (pSgVirtReturn)
@@ -1033 +1060 @@
 
     Log6Func(("Write ahead used_idx=%u, %s used_idx=%u\n",
-              pVirtqState->uUsedIdxShadow, VIRTQNAME(pVirtio, uVirtqNbr), virtioReadUsedRingIdx(pDevIns, pVirtio, uVirtqNbr)));
+              pVirtq->uUsedIdxShadow, VIRTQNAME(pVirtio, uVirtq), virtioReadUsedRingIdx(pDevIns, pVirtio, pVirtq)));
 
     return VINF_SUCCESS;
@@ -1053 +1080 @@
     }
     LogFunc(("Added %d/%d bytes to %s buffer, head idx: %u (%d bytes remain)\n",
-             cb - cbLim, cb, VIRTQNAME(pVirtio, pVirtqBuf->uVirtqNbr),
+             cb - cbLim, cb, VIRTQNAME(pVirtio, pVirtqBuf->uVirtq),
              pVirtqBuf->uHeadIdx, pVirtqBuf->cbPhysReturn));
 }
@@ -1073 +1100 @@
     }
     LogFunc(("Drained %d/%d bytes from %s buffer, head idx: %u (%d bytes left)\n",
-             cb - cbLim, cb, VIRTQNAME(pVirtio, pVirtqBuf->uVirtqNbr),
+             cb - cbLim, cb, VIRTQNAME(pVirtio, pVirtqBuf->uVirtq),
              pVirtqBuf->uHeadIdx, pVirtqBuf->cbPhysSend));
 }
@@ -1080 +1107 @@
 
 /** API function: See Header file  */
-int virtioCoreVirtqSyncUsedRing(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
-{
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uVirtqEnable[uVirtqNbr],
+int virtioCoreVirtqSyncUsedRing(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq)
+{
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtq->uEnable,
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
-    Log6Func(("Updating %s used_idx to %u\n",
-              VIRTQNAME(pVirtio, uVirtqNbr), pVirtqState->uUsedIdxShadow));
-
-    virtioWriteUsedRingIdx(pDevIns, pVirtio, uVirtqNbr, pVirtqState->uUsedIdxShadow);
-    virtioCoreNotifyGuestDriver(pDevIns, pVirtio, uVirtqNbr);
+    Log6Func(("Updating %s used_idx to %u\n", pVirtq->szName, pVirtq->uUsedIdxShadow));
+
+    virtioWriteUsedRingIdx(pDevIns, pVirtio, pVirtq, pVirtq->uUsedIdxShadow);
+    virtioCoreNotifyGuestDriver(pDevIns, pVirtio, uVirtq);
 
     return VINF_SUCCESS;
@@ -1104 +1130 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   uVirtqNbr   Virtq to check for guest interrupt handling preference
+ * @param   uVirtq      Virtq to check for guest interrupt handling preference
  * @param   uNotifyIdx  Notification index
  */
-static void virtioCoreVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, uint16_t uNotifyIdx)
+static void virtioCoreVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq, uint16_t uNotifyIdx)
 {
     PVIRTIOCORECC pVirtioCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOCORECC);
 
-    /* See VirtIO 1.0, section 4.1.5.2 It implies that uVirtqNbr and uNotifyIdx should match.
+    /* See VirtIO 1.0, section 4.1.5.2 It implies that uVirtq 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 == uVirtqNbr,
-                    ("Guest kicked virtq %d's notify addr w/non-corresponding virtq idx %d\n",
-                     uVirtqNbr, uNotifyIdx));
+    AssertMsg(uNotifyIdx == uVirtq,
+              ("Guest kicked virtq %d's notify addr w/non-corresponding virtq idx %d\n",
+              uVirtq, uNotifyIdx));
     RT_NOREF(uNotifyIdx);
 
-    AssertReturnVoid(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    Log6Func(("%s (desc chains: %u)\n",
-        pVirtio->aVirtqState[uVirtqNbr].szVirtqName,
-        virtioCoreVirtqAvailBufCount(pDevIns, pVirtio, uVirtqNbr)));
+    AssertReturnVoid(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    Log6Func(("%s (desc chains: %u)\n", pVirtq->szName,
+        virtioCoreVirtqAvailBufCount_inline(pDevIns, pVirtio, pVirtq)));
 
     /* Inform client */
-    pVirtioCC->pfnVirtqNotified(pDevIns, pVirtio, uVirtqNbr);
+    pVirtioCC->pfnVirtqNotified(pDevIns, pVirtio, uVirtq);
+    RT_NOREF2(pVirtio, pVirtq);
 }
 
@@ -1138 +1166 @@
  * @param   pDevIns     The device instance.
  * @param   pVirtio     Pointer to the shared virtio state.
- * @param   uVirtqNbr   Virtq to check for guest interrupt handling preference
- */
-static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
-{
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
+ * @param   uVirtq      Virtq to check for guest interrupt handling preference
+ */
+static void virtioCoreNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq)
+{
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
 
     if (!IS_DRIVER_OK(pVirtio))
@@ -1153 +1181 @@
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
     {
-        if (pVirtqState->fVirtqRingEventThreshold)
+        if (pVirtq->fUsedRingEvent)
         {
 #ifdef IN_RING3
             Log6Func(("...kicking guest %s, VIRTIO_F_EVENT_IDX set and threshold (%d) reached\n",
-                   VIRTQNAME(pVirtio, uVirtqNbr), (uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, uVirtqNbr)));
+                   pVirtq->szName, (uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, pVirtq)));
 #endif
-            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uVirtqMsixVector[uVirtqNbr]);
-            pVirtqState->fVirtqRingEventThreshold = false;
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtq->uMsix);
+            pVirtq->fUsedRingEvent = false;
             return;
         }
 #ifdef IN_RING3
         Log6Func(("...skip interrupt %s, VIRTIO_F_EVENT_IDX set but threshold (%d) not reached (%d)\n",
-                   VIRTQNAME(pVirtio, uVirtqNbr),(uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, uVirtqNbr), pVirtqState->uUsedIdxShadow));
+                   pVirtq->szName,(uint16_t)virtioReadAvailUsedEvent(pDevIns, pVirtio, pVirtq), pVirtq->uUsedIdxShadow));
 #endif
     }
@@ -1171 +1199 @@
     {
         /** If guest driver hasn't suppressed interrupts, interrupt  */
-        if (!(virtioReadAvailRingFlags(pDevIns, pVirtio, uVirtqNbr) & VIRTQ_AVAIL_F_NO_INTERRUPT))
-        {
-            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uVirtqMsixVector[uVirtqNbr]);
+        if (!(virtioReadAvailRingFlags(pDevIns, pVirtio, pVirtq) & VIRTQUEUE_AVAIL_F_NO_INTERRUPT))
+        {
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtq->uMsix);
             return;
         }
-        Log6Func(("...skipping interrupt for %s (guest set VIRTQ_AVAIL_F_NO_INTERRUPT)\n",
-                     VIRTQNAME(pVirtio, uVirtqNbr)));
+        Log6Func(("...skipping interrupt for %s (guest set VIRTQUEUE_AVAIL_F_NO_INTERRUPT)\n", pVirtq->szName));
     }
 }
@@ -1189 +1216 @@
  * @param   uVec        MSI-X vector, if enabled
  */
-static int virtioKick(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint8_t uCause, uint16_t uMsixVector)
+static int virtioKick(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint8_t uCause, uint16_t uMsixtor)
 {
     if (uCause == VIRTIO_ISR_VIRTQ_INTERRUPT)
@@ -1202 +1229 @@
         PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
     }
-    else if (uMsixVector != VIRTIO_MSI_NO_VECTOR)
-        PDMDevHlpPCISetIrq(pDevIns, uMsixVector, 1);
+    else if (uMsixtor != VIRTIO_MSI_NO_VECTOR)
+        PDMDevHlpPCISetIrq(pDevIns, uMsixtor, 1);
     return VINF_SUCCESS;
 }
@@ -1212 +1239 @@
  * @param   pDevIns     The device instance.
  */
-static void virtioLowerInterrupt(PPDMDEVINS pDevIns, uint16_t uMsixVector)
+static void virtioLowerInterrupt(PPDMDEVINS pDevIns, uint16_t uMsixtor)
 {
     PVIRTIOCORE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOCORE);
     if (!pVirtio->fMsiSupport)
         PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
-    else if (uMsixVector != VIRTIO_MSI_NO_VECTOR)
+    else if (uMsixtor != VIRTIO_MSI_NO_VECTOR)
         PDMDevHlpPCISetIrq(pDevIns, pVirtio->uMsixConfig, PDM_IRQ_LEVEL_LOW);
 }
 
 #ifdef IN_RING3
-static void virtioResetVirtq(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
-{
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    PVIRTQSTATE pVirtqState = &pVirtio->aVirtqState[uVirtqNbr];
-    pVirtqState->uAvailIdxShadow = 0;
-    pVirtqState->uUsedIdxShadow  = 0;
-    pVirtqState->fVirtqRingEventThreshold = false;
-    pVirtio->uVirtqEnable[uVirtqNbr] = false;
-    pVirtio->uVirtqSize[uVirtqNbr] = VIRTQ_MAX_ENTRIES;
-    pVirtio->uVirtqNotifyOff[uVirtqNbr] = uVirtqNbr;
-    pVirtio->uVirtqMsixVector[uVirtqNbr] = uVirtqNbr + 2;
+static void virtioResetVirtq(PVIRTIOCORE pVirtio, uint16_t uVirtq)
+{
+    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
+    PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[uVirtq];
+
+    pVirtq->uAvailIdxShadow  = 0;
+    pVirtq->uUsedIdxShadow   = 0;
+    pVirtq->uEnable     = false;
+    pVirtq->uSize       = VIRTQ_MAX_ENTRIES;
+    pVirtq->uNotifyOffset  = uVirtq;
+    pVirtq->uMsix = uVirtq + 2;
+    pVirtq->fUsedRingEvent = false;
+
     if (!pVirtio->fMsiSupport) /* VirtIO 1.0, 4.1.4.3 and 4.1.5.1.2 */
-        pVirtio->uVirtqMsixVector[uVirtqNbr] = VIRTIO_MSI_NO_VECTOR;
-
-    virtioLowerInterrupt(pVirtio->pDevInsR3, pVirtio->uVirtqMsixVector[uVirtqNbr]);
+        pVirtq->uMsix = VIRTIO_MSI_NO_VECTOR;
+
+    virtioLowerInterrupt(pVirtio->pDevInsR3, pVirtq->uMsix);
 }
 
@@ -1253 +1282 @@
     {
         virtioLowerInterrupt(pDevIns, pVirtio->uMsixConfig);
-        for (int i = 0; i < VIRTQ_MAX_CNT; i++)
-        {
-            virtioLowerInterrupt(pDevIns, pVirtio->uVirtqMsixVector[i]);
-            pVirtio->uVirtqMsixVector[i];
-        }
+        for (int i = 0; i < VIRTQ_MAX_COUNT; i++)
+            virtioLowerInterrupt(pDevIns, pVirtio->aVirtqueues[i].uMsix);
     }
 
@@ -1263 +1289 @@
         pVirtio->uMsixConfig = VIRTIO_MSI_NO_VECTOR;
 
-    for (uint16_t uVirtqNbr = 0; uVirtqNbr < VIRTQ_MAX_CNT; uVirtqNbr++)
-        virtioResetVirtq(pVirtio, uVirtqNbr);
+    for (uint16_t uVirtq = 0; uVirtq < VIRTQ_MAX_COUNT; uVirtq++)
+        virtioResetVirtq(pVirtio, uVirtq);
 }
 
@@ -1297 +1323 @@
                                    int fWrite, uint32_t uOffsetOfAccess, unsigned cb, void *pv)
 {
-    uint16_t uVirtqNbr = pVirtio->uVirtqSelect;
+    uint16_t uVirtq = pVirtio->uVirtqSelect;
     int rc = VINF_SUCCESS;
     uint64_t val;
@@ -1381 +1407 @@
             return VINF_SUCCESS;
         }
-        *(uint16_t *)pv = VIRTQ_MAX_CNT;
+        *(uint16_t *)pv = VIRTQ_MAX_COUNT;
         VIRTIO_DEV_CONFIG_LOG_ACCESS(uNumVirtqs, VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess);
     }
@@ -1439 +1465 @@
     }
     else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uMsixConfig,                   VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS(         uMsixConfig,                   VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uDeviceFeaturesSelect,         VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS(         uDeviceFeaturesSelect,         VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uDriverFeaturesSelect,         VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS(         uDriverFeaturesSelect,         VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uConfigGeneration,             VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS(         uConfigGeneration,             VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqSelect,                  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS(         uVirtqSelect,                  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqSize,                    VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uVirtqSize,        uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqMsixVector,              VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uVirtqMsixVector,  uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqEnable,                  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uVirtqEnable,      uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqNotifyOff,               VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uVirtqNotifyOff,   uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   aGCPhysVirtqDesc,              VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( aGCPhysVirtqDesc,  uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   aGCPhysVirtqAvail,             VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( aGCPhysVirtqAvail, uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
-    else
-    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   aGCPhysVirtqUsed,              VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
-        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( aGCPhysVirtqUsed,  uVirtqNbr,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uMsixConfig,                VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS(         uMsixConfig,                VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uDeviceFeaturesSelect,      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS(         uDeviceFeaturesSelect,      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uDriverFeaturesSelect,      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS(         uDriverFeaturesSelect,      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uConfigGeneration,          VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS(         uConfigGeneration,          VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uVirtqSelect,               VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS(         uVirtqSelect,               VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   GCPhysVirtqDesc,            VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( GCPhysVirtqDesc,   uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   GCPhysVirtqAvail,           VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( GCPhysVirtqAvail,  uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   GCPhysVirtqUsed,            VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( GCPhysVirtqUsed,   uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uSize,                      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uSize,             uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uEnable,                    VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uEnable,           uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uNotifyOffset,              VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uNotifyOffset,     uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
+    else
+    if (VIRTIO_DEV_CONFIG_MATCH_MEMBER(   uMsix,                      VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess))
+        VIRTIO_DEV_CONFIG_ACCESS_INDEXED( uMsix,             uVirtq,  VIRTIO_PCI_COMMON_CFG_T, uOffsetOfAccess, pVirtio->aVirtqueues);
     else
     {
@@ -1706 +1732 @@
     pHlp->pfnSSMPutU32(pSSM, VIRTIO_SAVEDSTATE_VERSION);
 
-    pHlp->pfnSSMPutBool(pSSM,   pVirtio->fGenUpdatePending);
-    pHlp->pfnSSMPutU8(pSSM,     pVirtio->fDeviceStatus);
-    pHlp->pfnSSMPutU8(pSSM,     pVirtio->uConfigGeneration);
-    pHlp->pfnSSMPutU8(pSSM,     pVirtio->uPciCfgDataOff);
-    pHlp->pfnSSMPutU8(pSSM,     pVirtio->uISR);
-    pHlp->pfnSSMPutU16(pSSM,    pVirtio->uVirtqSelect);
-    pHlp->pfnSSMPutU32(pSSM,    pVirtio->uDeviceFeaturesSelect);
-    pHlp->pfnSSMPutU32(pSSM,    pVirtio->uDriverFeaturesSelect);
-    pHlp->pfnSSMPutU64(pSSM,    pVirtio->uDriverFeatures);
-
-    for (uint32_t i = 0; i < VIRTQ_MAX_CNT; i++)
-    {
-        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);
+    pHlp->pfnSSMPutBool(pSSM, pVirtio->fGenUpdatePending);
+    pHlp->pfnSSMPutU8(  pSSM, pVirtio->fDeviceStatus);
+    pHlp->pfnSSMPutU8(  pSSM, pVirtio->uConfigGeneration);
+    pHlp->pfnSSMPutU8(  pSSM, pVirtio->uPciCfgDataOff);
+    pHlp->pfnSSMPutU8(  pSSM, pVirtio->uISR);
+    pHlp->pfnSSMPutU16( pSSM, pVirtio->uVirtqSelect);
+    pHlp->pfnSSMPutU32( pSSM, pVirtio->uDeviceFeaturesSelect);
+    pHlp->pfnSSMPutU32( pSSM, pVirtio->uDriverFeaturesSelect);
+    pHlp->pfnSSMPutU64( pSSM, pVirtio->uDriverFeatures);
+
+    for (uint32_t i = 0; i < VIRTQ_MAX_COUNT; i++)
+    {
+        PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[i];
+
+        pHlp->pfnSSMPutGCPhys64( pSSM, pVirtq->GCPhysVirtqDesc);
+        pHlp->pfnSSMPutGCPhys64( pSSM, pVirtq->GCPhysVirtqAvail);
+        pHlp->pfnSSMPutGCPhys64( pSSM, pVirtq->GCPhysVirtqUsed);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uNotifyOffset);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uMsix);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uEnable);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uSize);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uAvailIdxShadow);
+        pHlp->pfnSSMPutU16(      pSSM, pVirtq->uUsedIdxShadow);
+        int rc = pHlp->pfnSSMPutMem(pSSM, pVirtq->szName, 32);
         AssertRCReturn(rc, rc);
     }
@@ -1764 +1792 @@
      * Load the state.
      */
-    pHlp->pfnSSMGetBool(pSSM, &pVirtio->fGenUpdatePending);
-    pHlp->pfnSSMGetU8(pSSM,   &pVirtio->fDeviceStatus);
-    pHlp->pfnSSMGetU8(pSSM,   &pVirtio->uConfigGeneration);
-    pHlp->pfnSSMGetU8(pSSM,   &pVirtio->uPciCfgDataOff);
-    pHlp->pfnSSMGetU8(pSSM,   &pVirtio->uISR);
-    pHlp->pfnSSMGetU16(pSSM,  &pVirtio->uVirtqSelect);
-    pHlp->pfnSSMGetU32(pSSM,  &pVirtio->uDeviceFeaturesSelect);
-    pHlp->pfnSSMGetU32(pSSM,  &pVirtio->uDriverFeaturesSelect);
-    pHlp->pfnSSMGetU64(pSSM,  &pVirtio->uDriverFeatures);
-
-    for (uint32_t i = 0; i < VIRTQ_MAX_CNT; i++)
-    {
-        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));
+    pHlp->pfnSSMGetBool( pSSM, &pVirtio->fGenUpdatePending);
+    pHlp->pfnSSMGetU8(   pSSM, &pVirtio->fDeviceStatus);
+    pHlp->pfnSSMGetU8(   pSSM, &pVirtio->uConfigGeneration);
+    pHlp->pfnSSMGetU8(   pSSM, &pVirtio->uPciCfgDataOff);
+    pHlp->pfnSSMGetU8(   pSSM, &pVirtio->uISR);
+    pHlp->pfnSSMGetU16(  pSSM, &pVirtio->uVirtqSelect);
+    pHlp->pfnSSMGetU32(  pSSM, &pVirtio->uDeviceFeaturesSelect);
+    pHlp->pfnSSMGetU32(  pSSM, &pVirtio->uDriverFeaturesSelect);
+    pHlp->pfnSSMGetU64(  pSSM, &pVirtio->uDriverFeatures);
+
+    for (uint32_t i = 0; i < VIRTQ_MAX_COUNT; i++)
+    {
+        PVIRTQUEUE pVirtq = &pVirtio->aVirtqueues[i];
+
+        pHlp->pfnSSMGetGCPhys64( pSSM, &pVirtq->GCPhysVirtqDesc);
+        pHlp->pfnSSMGetGCPhys64( pSSM, &pVirtq->GCPhysVirtqAvail);
+        pHlp->pfnSSMGetGCPhys64( pSSM, &pVirtq->GCPhysVirtqUsed);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uNotifyOffset);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uMsix);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uEnable);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uSize);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uAvailIdxShadow);
+        pHlp->pfnSSMGetU16(      pSSM, &pVirtq->uUsedIdxShadow);
+        rc = pHlp->pfnSSMGetMem( pSSM, pVirtq->szName,  sizeof(pVirtq->szName));
         AssertRCReturn(rc, rc);
     }
@@ -1821 +1850 @@
             break;
         case kvirtIoVmStateChangedResume:
-            virtioCoreNotifyGuestDriver(pVirtio->pDevInsR3, pVirtio, 0 /* uVirtqNbr */);
+            virtioCoreNotifyGuestDriver(pVirtio->pDevInsR3, pVirtio, 0 /* uVirtq */);
             break;
         default:
@@ -1846 +1875 @@
 }
 
-
-/**rr
+/**
  * Setup PCI device controller and Virtio state
  *
@@ -1960 +1988 @@
     /*
      * 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 uVirtqNotifyOff equal to (VirtqSelect) ordinal
+     * of this implementation to make each queue's uNotifyOffset equal to (VirtqSelect) ordinal
      * value of the queue (different strategies are possible according to spec).
      */
@@ -1971 +1999 @@
     pCfg->uOffset  = pVirtioCC->pCommonCfgCap->uOffset + pVirtioCC->pCommonCfgCap->uLength;
     pCfg->uOffset  = RT_ALIGN_32(pCfg->uOffset, 4);
-    pCfg->uLength  = VIRTQ_MAX_CNT * VIRTIO_NOTIFY_OFFSET_MULTIPLIER + 2;  /* will change in VirtIO 1.1 */
+    pCfg->uLength  = VIRTQ_MAX_COUNT * VIRTIO_NOTIFY_OFFSET_MULTIPLIER + 2;  /* will change in VirtIO 1.1 */
     cbRegion += pCfg->uLength;
     SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocNotifyCap, 1);

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

@@ -49 +49 @@
 #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      */
+#define VIRTQ_MAX_COUNT                     24                   /**< Max queues we allow guest to create      */
 #define VIRTIO_NOTIFY_OFFSET_MULTIPLIER     2                    /**< VirtIO Notify Cap. MMIO config param     */
 #define VIRTIO_REGION_PCI_CAP               2                    /**< BAR for VirtIO Cap. MMIO (impl specific) */
@@ -92 +92 @@
 {
     uint32_t            u32Magic;                                /**< Magic value, VIRTQBUF_MAGIC.             */
-    uint16_t            uVirtqNbr;                               /**< VirtIO index of associated virtq         */
+    uint16_t            uVirtq;                                  /**< VirtIO index of associated virtq         */
     uint16_t            pad;
     uint32_t volatile   cRefs;                                   /**< Reference counter.                       */
@@ -188 +188 @@
 
 /**
- * Local implementation's usage context of a queue (e.g. not part of VirtIO specification)
- */
-typedef struct VIRTQSTATE
-{
-    uint16_t  uVirtqNbr;                                         /**< Index of this queue                       */
-    char      szVirtqName[32];                                   /**< Dev-specific name of queue                */
-    uint16_t  uAvailIdxShadow;                                   /**< Consumer's position in avail ring         */
-    uint16_t  uUsedIdxShadow;                                    /**< Consumer's position in used ring          */
-    bool      fVirtqRingEventThreshold;                          /**< Don't lose track while queueing ahead     */
-} VIRTQSTATE, *PVIRTQSTATE;
-
-/**
  * VirtIO 1.0 Capabilities' related MMIO-mapped structs:
  *
@@ -218 +206 @@
     /* Virtq-specific fields (values reflect (via MMIO) info related to queue indicated 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 into 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)   */
+    uint16_t  uSize;                                             /**< RW (queue size, 0 - 2^n)                  */
+    uint16_t  uMsix;                                             /**< RW (driver selects MSI-X queue vector)    */
+    uint16_t  uEnable;                                           /**< RW (driver controls usability of queue)   */
+    uint16_t  uNotifyOffset;                                     /**< RO (offset into virtqueue; see spec)      */
+    uint64_t  GCPhysVirtqDesc;                                   /**< RW (driver writes desc table phys addr)   */
+    uint64_t  GCPhysVirtqAvail;                                  /**< RW (driver writes avail ring phys addr)   */
+    uint64_t  GCPhysVirtqUsed;                                   /**< RW (driver writes used ring  phys addr)   */
 } VIRTIO_PCI_COMMON_CFG_T, *PVIRTIO_PCI_COMMON_CFG_T;
 
@@ -250 +238 @@
 } VIRTIO_PCI_CAP_LOCATIONS_T;
 
+typedef struct VIRTQUEUE
+{
+    RTGCPHYS                    GCPhysVirtqDesc;                  /**< (MMIO) PhysAdr per-Q desc structs   GUEST */
+    RTGCPHYS                    GCPhysVirtqAvail;                 /**< (MMIO) PhysAdr per-Q avail structs  GUEST */
+    RTGCPHYS                    GCPhysVirtqUsed;                  /**< (MMIO) PhysAdr per-Q used structs   GUEST */
+    uint16_t                    uNotifyOffset;                    /**< (MMIO) per-Q notify offset           HOST */
+    uint16_t                    uMsix;                            /**< (MMIO) Per-queue vector for MSI-X   GUEST */
+    uint16_t                    uEnable;                          /**< (MMIO) Per-queue enable             GUEST */
+    uint16_t                    uSize;                            /**< (MMIO) Per-queue size          HOST/GUEST */
+    uint16_t                    uAvailIdxShadow;                  /**< Consumer's position in avail ring         */
+    uint16_t                    uUsedIdxShadow;                   /**< Consumer's position in used ring          */
+    bool                        fUsedRingEvent;                   /**< Flags if used idx to notify guest reached */
+    uint16_t                    uVirtq;                           /**< Index of this queue                       */
+    char                        szName[32];                       /**< Dev-specific name of queue                */
+    uint8_t                     padding[3];
+} VIRTQUEUE, *PVIRTQUEUE;
+
 /**
  * The core/common state of the VirtIO PCI devices, shared edition.
@@ -255 +260 @@
 typedef struct VIRTIOCORE
 {
-    char                        szInstance[16];                    /**< Instance name, e.g. "VIRTIOSCSI0"         */
-    PPDMDEVINS                  pDevInsR0;                         /**< Client device instance                    */
-    PPDMDEVINS                  pDevInsR3;                         /**< Client device instance                    */
-    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 */
-    uint64_t                    uDriverFeatures;                   /**< (MMIO) Host features accepted       GUEST */
-    uint32_t                    uDeviceFeaturesSelect;             /**< (MMIO) hi/lo select uDeviceFeatures GUEST */
-    uint32_t                    uDriverFeaturesSelect;             /**< (MMIO) hi/lo select uDriverFeatures GUEST */
-    uint32_t                    uMsixConfig;                       /**< (MMIO) MSI-X vector                 GUEST */
-    uint8_t                     fDeviceStatus;                     /**< (MMIO) Device Status                GUEST */
-    uint8_t                     uPrevDeviceStatus;                 /**< (MMIO) Prev Device Status           GUEST */
-    uint8_t                     uConfigGeneration;                 /**< (MMIO) Device config sequencer       HOST */
-    VIRTQSTATE                  aVirtqState[VIRTQ_MAX_CNT];        /**< Local impl-specific queue context         */
+    char                        szInstance[16];                   /**< Instance name, e.g. "VIRTIOSCSI0"         */
+    PPDMDEVINS                  pDevInsR0;                        /**< Client device instance                    */
+    PPDMDEVINS                  pDevInsR3;                        /**< Client device instance                    */
+    VIRTQUEUE                   aVirtqueues[VIRTQ_MAX_COUNT];     /**< (MMIO) VirtIO contexts for queues         */
+    uint64_t                    uDeviceFeatures;                  /**< (MMIO) Host features offered         HOST */
+    uint64_t                    uDriverFeatures;                  /**< (MMIO) Host features accepted       GUEST */
+    uint32_t                    uDeviceFeaturesSelect;            /**< (MMIO) hi/lo select uDeviceFeatures GUEST */
+    uint32_t                    uDriverFeaturesSelect;            /**< (MMIO) hi/lo select uDriverFeatures GUEST */
+    uint32_t                    uMsixConfig;                      /**< (MMIO) MSI-X vector                 GUEST */
+    uint8_t                     fDeviceStatus;                    /**< (MMIO) Device Status                GUEST */
+    uint8_t                     uPrevDeviceStatus;                /**< (MMIO) Prev Device Status           GUEST */
+    uint8_t                     uConfigGeneration;                /**< (MMIO) Device config sequencer       HOST */
 
     /** @name The locations of the capability structures in PCI config space and the BAR.
      * @{ */
-    VIRTIO_PCI_CAP_LOCATIONS_T  LocPciCfgCap;                      /**< VIRTIO_PCI_CFG_CAP_T                      */
-    VIRTIO_PCI_CAP_LOCATIONS_T  LocNotifyCap;                      /**< VIRTIO_PCI_NOTIFY_CAP_T                   */
-    VIRTIO_PCI_CAP_LOCATIONS_T  LocCommonCfgCap;                   /**< VIRTIO_PCI_CAP_T                          */
-    VIRTIO_PCI_CAP_LOCATIONS_T  LocIsrCap;                         /**< VIRTIO_PCI_CAP_T                          */
-    VIRTIO_PCI_CAP_LOCATIONS_T  LocDeviceCap;                      /**< VIRTIO_PCI_CAP_T + custom data.           */
+    VIRTIO_PCI_CAP_LOCATIONS_T  LocPciCfgCap;                     /**< VIRTIO_PCI_CFG_CAP_T                      */
+    VIRTIO_PCI_CAP_LOCATIONS_T  LocNotifyCap;                     /**< VIRTIO_PCI_NOTIFY_CAP_T                   */
+    VIRTIO_PCI_CAP_LOCATIONS_T  LocCommonCfgCap;                  /**< VIRTIO_PCI_CAP_T                          */
+    VIRTIO_PCI_CAP_LOCATIONS_T  LocIsrCap;                        /**< VIRTIO_PCI_CAP_T                          */
+    VIRTIO_PCI_CAP_LOCATIONS_T  LocDeviceCap;                     /**< VIRTIO_PCI_CAP_T + custom data.           */
     /** @} */
 
-    bool                        fGenUpdatePending;                 /**< If set, update cfg gen after driver reads */
-    uint8_t                     uPciCfgDataOff;                    /**< Offset to PCI configuration data area     */
-    uint8_t                     uISR;                              /**< Interrupt Status Register.                */
-    uint8_t                     fMsiSupport;                       /**< Flag set if using MSI instead of ISR      */
+    uint16_t                    uVirtqSelect;                     /**< (MMIO) queue selector               GUEST */
+    bool                        fGenUpdatePending;                /**< If set, update cfg gen after driver reads */
+    uint8_t                     uPciCfgDataOff;                   /**< Offset to PCI configuration data area     */
+    uint8_t                     uISR;                             /**< Interrupt Status Register.                */
+    uint8_t                     fMsiSupport;                      /**< Flag set if using MSI instead of ISR      */
     /** The MMIO handle for the PCI capability region (\#2). */
     IOMMMIOHANDLE               hMmioPciCap;
@@ -416 +413 @@
  * queue management, informing the core of the name of the queue associated spec-defined
  * device specific queue number (which also happens to be the index into VirtIO's array
- * of queue structs].
+ * of queue structs].  uVirtqNbr is used as the 'handle' for virt queues in this API.
+ * They are unambiguous (the VirtIO specification defines how virtq numbers are assigned
+ * for each device type), and it helps prevent muddying of the core state by devices
+ * and vice versa by eliminating direct access to otherwise private structs.
  *
  * @param   pVirtio     Pointer to the shared virtio state.
@@ -477 +477 @@
  * using the command: "VboxManage debugvm <VM name or id> info <device name> [args]"
  *
- * Example:  VBoxManage debugvm myVnetVm info "virtio-net" all
+ * Example:  VBoxManage debugvm myVnetVm info "virtio-net" help
  *
  * This is implemented currently to be invoked by the inheriting device-specific code
@@ -505 +505 @@
  * operation if virtioCoreR3VirtqAvailRingNext() is called to consume the buffer from the avail ring,
  * at which point virtioCoreR3VirtqUsedBufPut() must be called to complete the roundtrip
- * transaction putting the descriptor on the used ring.
+ * transaction by putting the descriptor on the used ring.
  *
  *
@@ -579 +579 @@
  * intervening a roundtrip transaction, wherein I/O transactions are always initiated by
  * the guest and completed by the host. In other words, for the host to send any data to the
- * guest, the guest must provide buffers for the host to fill to the avail ring of the
+ * guest, the guest must provide buffers, for the host to fill, via the avail ring of the
  * virtq.
  *
@@ -697 +697 @@
 DECLINLINE(bool) virtioCoreIsVirtqEnabled(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
 {
-    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    return pVirtio->uVirtqEnable[uVirtqNbr] != 0;
+    Assert(uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqueues));
+    return pVirtio->aVirtqueues[uVirtqNbr].uEnable != 0;
 }
 
@@ -711 +711 @@
 DECLINLINE(const char *) virtioCoreVirtqGetName(PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
 {
-    Assert((size_t)uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqState));
-    return pVirtio->aVirtqState[uVirtqNbr].szVirtqName;
+    Assert((size_t)uVirtqNbr < RT_ELEMENTS(pVirtio->aVirtqueues));
+    return pVirtio->aVirtqueues[uVirtqNbr].szName;
 }
 
@@ -813 +813 @@
 RTGCPHYS virtioCoreGCPhysChainGetNextSeg(PVIRTIOSGBUF pGcSgBuf, size_t *pcbSeg);
 RTGCPHYS virtioCoreGCPhysChainAdvance(PVIRTIOSGBUF pGcSgBuf, size_t cbAdvance);
-void     virtioCoreGCPhysChainInit(PVIRTIOSGBUF pSgBuf, PVIRTIOSGSEG paSegs, size_t cSegs);
 size_t   virtioCoreGCPhysChainCalcBufSize(PCVIRTIOSGBUF pGcSgBuf);
 
@@ -928 +927 @@
         uint32_t uOffsetInMember = uOffsetOfAccess - RT_UOFFSETOF(tCfgStruct, member); \
         if (fWrite) \
-            memcpy(((char *)&(pCfgStruct)->member[uIdx]) + uOffsetInMember, pv, cb); \
+            memcpy(((char *)&(pCfgStruct[uIdx].member)) + uOffsetInMember, pv, cb); \
         else \
-            memcpy(pv, ((const char *)&(pCfgStruct)->member[uIdx]) + uOffsetInMember, cb); \
+            memcpy(pv, ((const char *)&(pCfgStruct[uIdx].member)) + uOffsetInMember, cb); \
         VIRTIO_DEV_CONFIG_LOG_INDEXED_ACCESS(member, tCfgStruct, uOffsetOfAccess, uIdx); \
     } while(0)
@@ -948 +947 @@
         else \
         { \
-            memcpy(pv, ((const char *)&(pCfgStruct)->member[uIdx]) + uOffsetInMember, cb); \
+            memcpy(pv, ((const char *)&(pCfgStruct[uIdx].member)) + uOffsetInMember, cb); \
             VIRTIO_DEV_CONFIG_LOG_INDEXED_ACCESS(member, tCfgStruct, uOffsetOfAccess, uIdx); \
         } \