Changeset 84819 in vbox for trunk/src/VBox/Devices/Network

Timestamp:

Jun 12, 2020 8:00:27 PM (5 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

138625

Message:

Virtio/VirtioCore.cpp, Network/DevVirtioNet_1_0.cpp, Storage/DevVirtioSCSI.cpp: Renamed Virtio_1_0.cpp/h to VirtioCore.cpp/h to be consistent with bird's extraction of the common Virtio code to VIRTIOCORE. Further improved the API function names and comments, and changed key variables to simplify things and more clearly reflect their relationship to VirtIO architecture. For example PVIRTIO_DESC_CHAIN_T pDescChain becomes PVIRTQBUF pVirtqBuf and added comments above the VIRTQBUF typedef to explain what's going on. Moved all the API function descriptions into the header file.

File:

• trunk/src/VBox/Devices/Network/DevVirtioNet_1_0.cpp (modified) (53 diffs)

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

@@ -55 +55 @@
 # include <iprt/uuid.h>
 #endif
-#include "../VirtIO/Virtio_1_0.h"
+#include "../VirtIO/VirtioCore.h"
 
 #include "VBoxDD.h"
@@ -67 +67 @@
 #define VIRTIONET_PREALLOCATE_RX_SEG_COUNT     32
 
-#define VIRTQNAME(idxVirtq)       (pThis->aVirtqs[idxVirtq]->szName)
-#define CBVIRTQNAME(idxVirtq)     RTStrNLen(VIRTQNAME(idxVirtq), sizeof(VIRTQNAME(idxVirtq)))
+#define VIRTQNAME(uVirtqNbr)       (pThis->aVirtqs[uVirtqNbr]->szName)
+#define CBVIRTQNAME(uVirtqNbr)     RTStrNLen(VIRTQNAME(uVirtqNbr), sizeof(VIRTQNAME(uVirtqNbr)))
 #define FEATURE_ENABLED(feature)  RT_BOOL(pThis->fNegotiatedFeatures & VIRTIONET_F_##feature)
 #define FEATURE_DISABLED(feature) (!FEATURE_ENABLED(feature))
 #define FEATURE_OFFERED(feature)  VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_##feature
 
-#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, idxVirtq) \
-            (virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq) == 0)
+#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, uVirtqNbr) \
+            (virtioCoreVirtqAvailCount(pDevIns, pVirtio, uVirtqNbr) == 0)
 
 #define SET_LINK_UP(pState) \
@@ -227 +227 @@
 };
 #pragma pack()
-typedef virtio_net_pkt_hdr VIRTIONET_PKT_HDR_T, *PVIRTIONET_PKT_HDR_T;
-AssertCompileSize(VIRTIONET_PKT_HDR_T, 12);
+typedef virtio_net_pkt_hdr VIRTIONETPKTHDR, *PVIRTIONETPKTHDR;
+AssertCompileSize(VIRTIONETPKTHDR, 12);
 
 /* Control virtq: Command entry (VirtIO 1.0, 5.1.6.5) */
@@ -615 +615 @@
  * @callback_method_impl{VIRTIOCORER0,pfnVirtqNotified}
  */
-static DECLCALLBACK(void) virtioNetVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxVirtq)
+static DECLCALLBACK(void) virtioNetVirtqNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
 {
     RT_NOREF(pVirtio);
     PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
 
-    PVIRTIONETVIRTQ  pVirtq = &pThis->aVirtqs[idxVirtq];
+    PVIRTIONETVIRTQ  pVirtq  = &pThis->aVirtqs[uVirtqNbr];
     PVIRTIONETWORKER pWorker = pVirtq->pWorker;
 
@@ -627 +627 @@
 #endif
 
-    if (IS_RX_VIRTQ(idxVirtq))
-    {
-        uint16_t cBufsAvailable = virtioCoreVirtqAvailCount(pDevIns, pVirtio, idxVirtq);
+    if (IS_RX_VIRTQ(uVirtqNbr))
+    {
+        uint16_t cBufsAvailable = virtioCoreVirtqAvailCount(pDevIns, pVirtio, uVirtqNbr);
 
         if (cBufsAvailable)
@@ -641 +641 @@
                     pThis->szInst, pVirtq->szName));
     }
-    else if (IS_TX_VIRTQ(idxVirtq) || IS_CTRL_VIRTQ(idxVirtq))
+    else if (IS_TX_VIRTQ(uVirtqNbr) || IS_CTRL_VIRTQ(uVirtqNbr))
     {
         /* Wake queue's worker thread up if sleeping (e.g. a Tx queue, or the control queue */
@@ -663 +663 @@
     }
     else
-        LogRelFunc(("%s unrecognized queue %s (idx=%d) notified\n", pThis->szInst, pVirtq->szName, idxVirtq));
+        LogRelFunc(("%s unrecognized queue %s (idx=%d) notified\n", pThis->szInst, pVirtq->szName, uVirtqNbr));
 }
 
@@ -769 +769 @@
 
 #ifdef LOG_ENABLED
-void virtioNetDumpGcPhysRxBuf(PPDMDEVINS pDevIns, PVIRTIONET_PKT_HDR_T pRxPktHdr,
+void virtioNetDumpGcPhysRxBuf(PPDMDEVINS pDevIns, PVIRTIONETPKTHDR pRxPktHdr,
                      uint16_t cDescs, uint8_t *pvBuf, uint16_t cb, RTGCPHYS GCPhysRxBuf, uint8_t cbRxBuf)
 {
@@ -789 +789 @@
                         pRxPktHdr->uChksumStart, pRxPktHdr->uChksumOffset, pRxPktHdr->uNumBuffers));
 
-        virtioCoreHexDump((uint8_t *)pRxPktHdr, sizeof(VIRTIONET_PKT_HDR_T), 0, "Dump of virtual rPktHdr");
+        virtioCoreHexDump((uint8_t *)pRxPktHdr, sizeof(VIRTIONETPKTHDR), 0, "Dump of virtual rPktHdr");
     }
     virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
@@ -841 +841 @@
         pHlp->pfnPrintf(pHlp, "Virtq information:\n\n");
 
-        for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
+        for (int uVirtqNbr = 0; uVirtqNbr < pThis->cVirtVirtqs; uVirtqNbr++)
         {
-            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[idxVirtq];
+            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[uVirtqNbr];
 
             if (pVirtq->fHasWorker)
@@ -873 +873 @@
             }
             pHlp->pfnPrintf(pHlp, "\n");
-            virtioCoreR3VirtqInfo(pDevIns, pHlp, pszArgs, idxVirtq);
+            virtioCoreR3VirtqInfo(pDevIns, pHlp, pszArgs, uVirtqNbr);
             pHlp->pfnPrintf(pHlp, "    ---------------------------------------------------------------------\n");
             pHlp->pfnPrintf(pHlp, "\n");
@@ -963 +963 @@
 
     }
-    pHlp->pfnPrintf(pHlp, "\n");
-    virtioCoreR3Info(pDevIns, pHlp, pszArgs);
+    /** @todo implement this
+      * pHlp->pfnPrintf(pHlp, "\n");
+      * virtioCoreR3Info(pDevIns, pHlp, pszArgs);
+      */
     pHlp->pfnPrintf(pHlp, "\n");
 }
@@ -1139 +1141 @@
     pHlp->pfnSSMGetU16(     pSSM, &pThis->cWorkers);
 
-    for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
-        pHlp->pfnSSMGetBool(pSSM, &pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore);
+    for (int uVirtqNbr = 0; uVirtqNbr < pThis->cVirtVirtqs; uVirtqNbr++)
+        pHlp->pfnSSMGetBool(pSSM, &pThis->aVirtqs[uVirtqNbr].fAttachedToVirtioCore);
 
     int rc;
@@ -1228 +1230 @@
     pHlp->pfnSSMPutU16(     pSSM, pThis->cWorkers);
 
-    for (int idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
-        pHlp->pfnSSMPutBool(pSSM, pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore);
+    for (int uVirtqNbr = 0; uVirtqNbr < pThis->cVirtVirtqs; uVirtqNbr++)
+        pHlp->pfnSSMPutBool(pSSM, pThis->aVirtqs[uVirtqNbr].fAttachedToVirtioCore);
 
     /* Save config area */
@@ -1489 +1491 @@
         rc = VINF_SUCCESS;
     }
-    virtioCoreVirtqNotifyEnable(&pThis->Virtio, pRxVirtq->idx, rc == VERR_INVALID_STATE /* fEnable */);
+    virtioCoreVirtqEnableNotify(&pThis->Virtio, pRxVirtq->idx, rc == VERR_INVALID_STATE /* fEnable */);
     return rc;
 }
@@ -1495 +1497 @@
 static bool virtioNetR3RxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETVIRTQ *pRxVirtq)
 {
-    for (int idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++)
-    {
-        PVIRTIONETVIRTQ pThisRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
+    for (int uVirtqNbrPair = 0; uVirtqNbrPair < pThis->cVirtqPairs; uVirtqNbrPair++)
+    {
+        PVIRTIONETVIRTQ pThisRxVirtq = &pThis->aVirtqs[RXQIDX(uVirtqNbrPair)];
         if (RT_SUCCESS(virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pThisRxVirtq)))
         {
@@ -1566 +1568 @@
  * @param   pCtx                The context descriptor.
  */
-DECLINLINE(PPDMNETWORKGSO) virtioNetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VIRTIONET_PKT_HDR_T const *pPktHdr)
+DECLINLINE(PPDMNETWORKGSO) virtioNetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VIRTIONETPKTHDR const *pPktHdr)
 {
     pGso->u8Type = PDMNETWORKGSOTYPE_INVALID;
@@ -1729 +1731 @@
 
 static int virtioNetR3CopyRxPktToGuest(PPDMDEVINS pDevIns, PVIRTIONET pThis, const void *pvBuf, size_t cb,
-                                       VIRTIONET_PKT_HDR_T *rxPktHdr, uint16_t cSegsAllocated,
+                                       VIRTIONETPKTHDR *rxPktHdr, uint16_t cSegsAllocated,
                                        PRTSGBUF pVirtSegBufToGuest, PRTSGSEG paVirtSegsToGuest,
                                        PVIRTIONETVIRTQ pRxVirtq)
@@ -1739 +1741 @@
     for (cDescs = uOffset = 0; uOffset < cb; )
     {
-        PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-
-        int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, pRxVirtq->idx, &pDescChain, true);
+        PVIRTQBUF pVirtqBuf = NULL;
+
+        int rc = virtioCoreR3VirtqBufGet(pDevIns, &pThis->Virtio, pRxVirtq->idx, &pVirtqBuf, true);
         AssertMsgReturn(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE, ("%Rrc\n", rc), rc);
 
         /** @todo  Find a better way to deal with this */
-        AssertMsgReturnStmt(rc == VINF_SUCCESS && pDescChain->cbPhysReturn,
+        AssertMsgReturnStmt(rc == VINF_SUCCESS && pVirtqBuf->cbPhysReturn,
                             ("Not enough Rx buffers in queue to accomodate ethernet packet\n"),
-                            virtioCoreR3DescChainRelease(&pThis->Virtio, pDescChain),
+                            virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf),
                             VERR_INTERNAL_ERROR);
 
@@ -1754 +1756 @@
          * virtio_net_header.num_buffers, to defer updating (in GCPhys). Re-visit if needed */
 
-        AssertMsgReturnStmt(pDescChain->pSgPhysReturn->paSegs[0].cbSeg >= sizeof(VIRTIONET_PKT_HDR_T),
+        AssertMsgReturnStmt(pVirtqBuf->pSgPhysReturn->paSegs[0].cbSeg >= sizeof(VIRTIONETPKTHDR),
                             ("Desc chain's first seg has insufficient space for pkt header!\n"),
-                            virtioCoreR3DescChainRelease(&pThis->Virtio, pDescChain),
+                            virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf),
                             VERR_INTERNAL_ERROR);
 
-        size_t cbDescChainLeft = pDescChain->cbPhysReturn;
-        uint8_t  cbHdr = sizeof(VIRTIONET_PKT_HDR_T);
+        size_t cbDescChainLeft = pVirtqBuf->cbPhysReturn;
+        uint8_t  cbHdr = sizeof(VIRTIONETPKTHDR);
 
         /* Fill the Guest Rx buffer with data received from the interface */
@@ -1776 +1778 @@
 
                 /* Calculate & cache addr of field to update after final value is known, in GCPhys mem */
-                GCPhysPktHdrNumBuffers = pDescChain->pSgPhysReturn->paSegs[0].GCPhys
-                                         + RT_UOFFSETOF(VIRTIONET_PKT_HDR_T, uNumBuffers);
+                GCPhysPktHdrNumBuffers = pVirtqBuf->pSgPhysReturn->paSegs[0].GCPhys
+                                         + RT_UOFFSETOF(VIRTIONETPKTHDR, uNumBuffers);
                 fAddPktHdr = false;
                 cSegs++;
@@ -1787 +1789 @@
                 paVirtSegsToGuest = (PRTSGSEG)RTMemRealloc(paVirtSegsToGuest, sizeof(RTSGSEG) * cSegsAllocated);
                 if (!paVirtSegsToGuest)
-                    virtioCoreR3DescChainRelease(&pThis->Virtio, pDescChain);
+                    virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
                 AssertReturn(paVirtSegsToGuest, VERR_NO_MEMORY);
             }
@@ -1802 +1804 @@
             Log7Func(("Send Rx pkt to guest...\n"));
             STAM_PROFILE_START(&pThis->StatReceiveStore, a);
-            virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, pRxVirtq->idx,
-                                 pVirtSegBufToGuest, pDescChain, true /* fFence */);
+            virtioCoreR3VirtqBufPut(pDevIns, &pThis->Virtio, pRxVirtq->idx,
+                                 pVirtSegBufToGuest, pVirtqBuf, true /* fFence */);
             STAM_PROFILE_STOP(&pThis->StatReceiveStore, a);
 
@@ -1810 +1812 @@
         }
 
-        virtioCoreR3DescChainRelease(&pThis->Virtio, pDescChain);
+        virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
     }
 
@@ -1853 +1855 @@
 
     LogFunc(("%s (%RTmac) pGso %s\n", pThis->szInst, pvBuf, pGso ? "present" : "not present"));
-    VIRTIONET_PKT_HDR_T rxPktHdr = { 0 };
+    VIRTIONETPKTHDR rxPktHdr = { 0 };
 
     if (pGso)
@@ -1961 +1963 @@
               selection algorithm feasible or even necessary to prevent starvation? */
 
-    for (int idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++)
-    {
-
-        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
+    for (int uVirtqNbrPair = 0; uVirtqNbrPair < pThis->cVirtqPairs; uVirtqNbrPair++)
+    {
+
+        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(uVirtqNbrPair)];
         if (RT_SUCCESS(!virtioNetR3CheckRxBufsAvail(pDevIns, pThis, pRxVirtq)))
         {
@@ -1998 +2000 @@
 
 /* Read physical bytes from the out segment(s) of descriptor chain */
-static void virtioNetR3PullChain(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIO_DESC_CHAIN_T pDescChain, void *pv, size_t cb)
+static void virtioNetR3PullChain(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTQBUF pVirtqBuf, void *pv, size_t cb)
 {
     uint8_t *pb = (uint8_t *)pv;
-    size_t cbLim = RT_MIN(pDescChain->cbPhysSend, cb);
+    size_t cbLim = RT_MIN(pVirtqBuf->cbPhysSend, cb);
     while (cbLim)
     {
         size_t cbSeg = cbLim;
-        RTGCPHYS GCPhys = virtioCoreSgBufGetNextSegment(pDescChain->pSgPhysSend, &cbSeg);
+        RTGCPHYS GCPhys = virtioCoreSgBufGetNextSegment(pVirtqBuf->pSgPhysSend, &cbSeg);
         PDMDevHlpPCIPhysRead(pDevIns, GCPhys, pb, cbSeg);
         pb += cbSeg;
         cbLim -= cbSeg;
-        pDescChain->cbPhysSend -= cbSeg;
+        pVirtqBuf->cbPhysSend -= cbSeg;
     }
     LogFunc(("%s Pulled %d/%d bytes from desc chain (%d bytes left)\n",
-             pThis->szInst, cb - cbLim, cb, pDescChain->cbPhysSend));
+             pThis->szInst, cb - cbLim, cb, pVirtqBuf->cbPhysSend));
     RT_NOREF(pThis);
 }
 
 static uint8_t virtioNetR3CtrlRx(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+                                 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTQBUF pVirtqBuf)
 {
 
@@ -2044 +2046 @@
 
     uint8_t fOn, fPromiscChanged = false;
-    virtioNetR3PullChain(pDevIns, pThis, pDescChain, &fOn, (size_t)RT_MIN(pDescChain->cbPhysSend, sizeof(fOn)));
+    virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &fOn, (size_t)RT_MIN(pVirtqBuf->cbPhysSend, sizeof(fOn)));
 
     switch(pCtrlPktHdr->uCmd)
@@ -2092 +2094 @@
 
 static uint8_t virtioNetR3CtrlMac(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                  PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+                                  PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTQBUF pVirtqBuf)
 {
     LogFunc(("%s Processing CTRL MAC command\n", pThis->szInst));
@@ -2104 +2106 @@
     AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_TABLE_SET cmd\n"), VIRTIONET_ERROR)
 
-    AssertMsgReturn(pDescChain->cbPhysSend >= sizeof(*pCtrlPktHdr),
+    AssertMsgReturn(pVirtqBuf->cbPhysSend >= sizeof(*pCtrlPktHdr),
                    ("insufficient descriptor space for ctrl pkt hdr"),
                    VIRTIONET_ERROR);
 
-    size_t cbRemaining = pDescChain->cbPhysSend;
+    size_t cbRemaining = pVirtqBuf->cbPhysSend;
     switch(pCtrlPktHdr->uCmd)
     {
@@ -2115 +2117 @@
             /* Set default Rx filter MAC */
             ASSERT_CTRL_ADDR_SET(cbRemaining >= sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
-            virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->rxFilterMacDefault, sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
+            virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &pThis->rxFilterMacDefault, sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
             break;
         }
@@ -2124 +2126 @@
             /* Load unicast MAC filter table */
             ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
-            virtioNetR3PullChain(pDevIns, pThis, pDescChain, &cMacs, sizeof(cMacs));
+            virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &cMacs, sizeof(cMacs));
             cbRemaining -= sizeof(cMacs);
             Log7Func(("%s Guest provided %d unicast MAC Table entries\n", pThis->szInst, cMacs));
@@ -2131 +2133 @@
                 uint32_t cbMacs = cMacs * sizeof(RTMAC);
                 ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
-                virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->aMacUnicastFilter, cbMacs);
+                virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &pThis->aMacUnicastFilter, cbMacs);
                 cbRemaining -= cbMacs;
             }
@@ -2138 +2140 @@
             /* Load multicast MAC filter table */
             ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
-            virtioNetR3PullChain(pDevIns, pThis, pDescChain, &cMacs, sizeof(cMacs));
+            virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &cMacs, sizeof(cMacs));
             cbRemaining -= sizeof(cMacs);
             Log10Func(("%s Guest provided %d multicast MAC Table entries\n", pThis->szInst, cMacs));
@@ -2145 +2147 @@
                 uint32_t cbMacs = cMacs * sizeof(RTMAC);
                 ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
-                virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->aMacMulticastFilter, cbMacs);
+                virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &pThis->aMacMulticastFilter, cbMacs);
                 cbRemaining -= cbMacs;
             }
@@ -2165 +2167 @@
 
 static uint8_t virtioNetR3CtrlVlan(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                   PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+                                   PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTQBUF pVirtqBuf)
 {
     LogFunc(("%s Processing CTRL VLAN command\n", pThis->szInst));
@@ -2172 +2174 @@
 
     uint16_t uVlanId;
-    size_t cbRemaining = pDescChain->cbPhysSend - sizeof(*pCtrlPktHdr);
+    size_t cbRemaining = pVirtqBuf->cbPhysSend - sizeof(*pCtrlPktHdr);
     AssertMsgReturn(cbRemaining > sizeof(uVlanId),
         ("DESC chain too small for VIRTIO_NET_CTRL_VLAN cmd processing"), VIRTIONET_ERROR);
-    virtioNetR3PullChain(pDevIns, pThis, pDescChain, &uVlanId, sizeof(uVlanId));
+    virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, &uVlanId, sizeof(uVlanId));
     AssertMsgReturn(uVlanId > VIRTIONET_MAX_VLAN_ID,
         ("%s VLAN ID out of range (VLAN ID=%u)\n", pThis->szInst, uVlanId), VIRTIONET_ERROR);
@@ -2194 +2196 @@
 
 static void virtioNetR3Ctrl(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                            PVIRTIO_DESC_CHAIN_T pDescChain)
+                            PVIRTQBUF pVirtqBuf)
 {
     LogFunc(("%s Received CTRL packet from guest\n", pThis->szInst));
 
-    if (pDescChain->cbPhysSend < 2)
+    if (pVirtqBuf->cbPhysSend < 2)
     {
         LogFunc(("%s CTRL packet from guest driver incomplete. Skipping ctrl cmd\n", pThis->szInst));
         return;
     }
-    else if (pDescChain->cbPhysReturn < sizeof(VIRTIONET_CTRL_HDR_T_ACK))
+    else if (pVirtqBuf->cbPhysReturn < sizeof(VIRTIONET_CTRL_HDR_T_ACK))
     {
         LogFunc(("%s Guest driver didn't allocate memory to receive ctrl pkt ACK. Skipping ctrl cmd\n", pThis->szInst));
@@ -2216 +2218 @@
     AssertPtrReturnVoid(pCtrlPktHdr);
 
-    AssertMsgReturnVoid(pDescChain->cbPhysSend >= sizeof(VIRTIONET_CTRL_HDR_T),
+    AssertMsgReturnVoid(pVirtqBuf->cbPhysSend >= sizeof(VIRTIONET_CTRL_HDR_T),
                         ("DESC chain too small for CTRL pkt header"));
 
-    virtioNetR3PullChain(pDevIns, pThis, pDescChain, pCtrlPktHdr,
-                         RT_MIN(pDescChain->cbPhysSend, sizeof(VIRTIONET_CTRL_HDR_T)));
+    virtioNetR3PullChain(pDevIns, pThis, pVirtqBuf, pCtrlPktHdr,
+                         RT_MIN(pVirtqBuf->cbPhysSend, sizeof(VIRTIONET_CTRL_HDR_T)));
 
     Log7Func(("%s CTRL COMMAND: class=%d command=%d\n", pThis->szInst, pCtrlPktHdr->uClass, pCtrlPktHdr->uCmd));
@@ -2228 +2230 @@
     {
         case VIRTIONET_CTRL_RX:
-            uAck = virtioNetR3CtrlRx(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
+            uAck = virtioNetR3CtrlRx(pDevIns, pThis, pThisCC, pCtrlPktHdr, pVirtqBuf);
             break;
         case VIRTIONET_CTRL_MAC:
-            uAck = virtioNetR3CtrlMac(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
+            uAck = virtioNetR3CtrlMac(pDevIns, pThis, pThisCC, pCtrlPktHdr, pVirtqBuf);
             break;
         case VIRTIONET_CTRL_VLAN:
-            uAck = virtioNetR3CtrlVlan(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
+            uAck = virtioNetR3CtrlVlan(pDevIns, pThis, pThisCC, pCtrlPktHdr, pVirtqBuf);
             break;
         case VIRTIONET_CTRL_ANNOUNCE:
@@ -2283 +2285 @@
     RTSgBufInit(pReturnSegBuf, paReturnSegs, cSegs);
 
-    virtioCoreR3VirtqPut(pDevIns, &pThis->Virtio, CTRLQIDX, pReturnSegBuf, pDescChain, true /* fFence */);
+    virtioCoreR3VirtqBufPut(pDevIns, &pThis->Virtio, CTRLQIDX, pReturnSegBuf, pVirtqBuf, true /* fFence */);
     virtioCoreVirtqSync(pDevIns, &pThis->Virtio, CTRLQIDX);
 
@@ -2296 +2298 @@
 }
 
-static int virtioNetR3ReadHeader(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, PVIRTIONET_PKT_HDR_T pPktHdr, size_t cbFrame)
+static int virtioNetR3ReadHeader(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, PVIRTIONETPKTHDR pPktHdr, size_t cbFrame)
 {
     int rc = PDMDevHlpPCIPhysRead(pDevIns, GCPhys, pPktHdr, sizeof(*pPktHdr));
@@ -2343 +2345 @@
 
 static int virtioNetR3TransmitFrame(PVIRTIONET pThis, PVIRTIONETCC pThisCC, PPDMSCATTERGATHER pSgBuf,
-                               PPDMNETWORKGSO pGso, PVIRTIONET_PKT_HDR_T pPktHdr)
+                               PPDMNETWORKGSO pGso, PVIRTIONETPKTHDR pPktHdr)
 {
     virtioNetR3PacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
@@ -2449 +2451 @@
 
     int rc;
-    PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-    while ((rc = virtioCoreR3VirtqPeek(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, &pDescChain)) == VINF_SUCCESS)
+    PVIRTQBUF pVirtqBuf = NULL;
+    while ((rc = virtioCoreR3VirtqBufPeek(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, &pVirtqBuf)) == VINF_SUCCESS)
     {
         Log10Func(("%s fetched descriptor chain from %s\n", pThis->szInst, pTxVirtq->szName));
 
-        PVIRTIOSGBUF pSgPhysSend = pDescChain->pSgPhysSend;
+        PVIRTIOSGBUF pSgPhysSend = pVirtqBuf->pSgPhysSend;
         PVIRTIOSGSEG paSegsFromGuest = pSgPhysSend->paSegs;
         uint32_t cSegsFromGuest = pSgPhysSend->cSegs;
 
-        VIRTIONET_PKT_HDR_T PktHdr;
+        VIRTIONETPKTHDR PktHdr;
         size_t uSize = 0;
 
@@ -2514 +2516 @@
 
                 LogFunc((".... Copied %lu bytes to %lu byte guest buffer, residual=%lu\n",
-                     cbTotal, pDescChain->cbPhysSend, pDescChain->cbPhysSend - cbTotal));
+                     cbTotal, pVirtqBuf->cbPhysSend, pVirtqBuf->cbPhysSend - cbTotal));
 
                 rc = virtioNetR3TransmitFrame(pThis, pThisCC, pSgBufToPdmLeafDevice, pGso, &PktHdr);
@@ -2531 +2533 @@
                 Log4Func(("Failed to allocate S/G buffer: size=%u rc=%Rrc\n", uSize, rc));
                 /* Stop trying to fetch TX descriptors until we get more bandwidth. */
-                virtioCoreR3DescChainRelease(pVirtio, pDescChain);
+                virtioCoreR3VirtqBufRelease(pVirtio, pVirtqBuf);
                 break;
             }
 
             /* Remove this descriptor chain from the available ring */
-            virtioCoreR3VirtqSkip(pVirtio, pTxVirtq->idx);
+            virtioCoreR3VirtqBufSkip(pVirtio, pTxVirtq->idx);
 
             /* No data to return to guest, but call is needed put elem (e.g. desc chain) on used ring */
-            virtioCoreR3VirtqPut(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, NULL, pDescChain, true /* fFence */);
+            virtioCoreR3VirtqBufPut(pVirtio->pDevInsR3, pVirtio, pTxVirtq->idx, NULL, pVirtqBuf, true /* fFence */);
 
             /* Update used ring idx and notify guest that we've transmitted the data it sent */
@@ -2545 +2547 @@
         }
 
-        virtioCoreR3DescChainRelease(pVirtio, pDescChain);
-        pDescChain = NULL;
+        virtioCoreR3VirtqBufRelease(pVirtio, pVirtqBuf);
+        pVirtqBuf = NULL;
     }
     virtioNetR3SetWriteLed(pThisCC, false);
@@ -2792 +2794 @@
 
     uint16_t idxWorker = CTRLWIDX + 1;
-    for (uint16_t idxVirtqPair = 0; idxVirtqPair < pThis->cVirtqPairs; idxVirtqPair++, idxWorker++)
-    {
-        PVIRTIONETVIRTQ pTxVirtq = &pThis->aVirtqs[TXQIDX(idxVirtqPair)];
-        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(idxVirtqPair)];
+    for (uint16_t uVirtqNbrPair = 0; uVirtqNbrPair < pThis->cVirtqPairs; uVirtqNbrPair++, idxWorker++)
+    {
+        PVIRTIONETVIRTQ pTxVirtq = &pThis->aVirtqs[TXQIDX(uVirtqNbrPair)];
+        PVIRTIONETVIRTQ pRxVirtq = &pThis->aVirtqs[RXQIDX(uVirtqNbrPair)];
 
         rc = virtioNetR3CreateOneWorkerThread(pDevIns, pThis, idxWorker, &pThis->aWorkers[idxWorker],
@@ -2825 +2827 @@
     /** @todo Race w/guest enabling/disabling guest notifications cyclically.
               See BugRef #8651, Comment #82 */
-    virtioCoreVirtqNotifyEnable(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
+    virtioCoreVirtqEnableNotify(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
 
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
@@ -2857 +2859 @@
              {
                  Log10Func(("%s %s worker woken. Fetching desc chain\n", pThis->szInst, pVirtq->szName));
-                 PVIRTIO_DESC_CHAIN_T pDescChain = NULL;
-                 int rc = virtioCoreR3VirtqGet(pDevIns, &pThis->Virtio, pVirtq->idx, &pDescChain, true);
+                 PVIRTQBUF pVirtqBuf = NULL;
+                 int rc = virtioCoreR3VirtqBufGet(pDevIns, &pThis->Virtio, pVirtq->idx, &pVirtqBuf, true);
                  if (rc == VERR_NOT_AVAILABLE)
                  {
@@ -2864 +2866 @@
                     continue;
                  }
-                 virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pDescChain);
-                 virtioCoreR3DescChainRelease(&pThis->Virtio, pDescChain);
+                 virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pVirtqBuf);
+                 virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
              }
              else /* Must be Tx queue */
@@ -2911 +2913 @@
         pThisCC->fQuiescing = false;
 
-        for (unsigned idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
+        for (unsigned uVirtqNbr = 0; uVirtqNbr < pThis->cVirtVirtqs; uVirtqNbr++)
         {
-            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[idxVirtq];
-            pVirtq->idx = idxVirtq;
+            PVIRTIONETVIRTQ pVirtq = &pThis->aVirtqs[uVirtqNbr];
+            pVirtq->idx = uVirtqNbr;
             (void) virtioCoreR3VirtqAttach(&pThis->Virtio, pVirtq->idx, pVirtq->szName);
             pVirtq->fAttachedToVirtioCore = true;
             if (IS_VIRTQ_EMPTY(pThisCC->pDevIns, &pThis->Virtio, pVirtq->idx))
-                virtioCoreVirtqNotifyEnable(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
+                virtioCoreVirtqEnableNotify(&pThis->Virtio, pVirtq->idx, true /* fEnable */);
         }
     }
@@ -2944 +2946 @@
         pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, true);
 
-        for (uint16_t idxVirtq = 0; idxVirtq < pThis->cVirtVirtqs; idxVirtq++)
-            pThis->aVirtqs[idxVirtq].fAttachedToVirtioCore = false;
+        for (uint16_t uVirtqNbr = 0; uVirtqNbr < pThis->cVirtVirtqs; uVirtqNbr++)
+            pThis->aVirtqs[uVirtqNbr].fAttachedToVirtioCore = false;
     }
 }