Changeset 82863 in vbox for trunk/src/VBox

Timestamp:

Jan 27, 2020 5:11:30 AM (5 years ago)

Author:

vboxsync

Message:

Network/DevVirtioNet_1_0.cpp: Builds cleanly. Finished initial tying together of events/notifications. See BugRef(8651) #52

Location:

trunk/src/VBox/Devices

Files:

• Network/DevVirtioNet_1_0.cpp (modified) (93 diffs)
• Storage/DevVirtioSCSI.cpp (modified) (3 diffs)
• VirtIO/Virtio_1_0.cpp (modified) (17 diffs)
• VirtIO/Virtio_1_0.h (modified) (3 diffs)

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

@@ -31 +31 @@
 #define LOG_GROUP LOG_GROUP_DEV_VIRTIO
 #define VIRTIONET_WITH_GSO
-#define VIRTIONET_WITH_MERGEABLE_RX_BUFS
 
 #include <VBox/vmm/pdmdev.h>
@@ -60 +59 @@
 #include "VBoxDD.h"
 
-
 #define VIRTIONET_SAVED_STATE_VERSION          UINT32_C(1)
 #define VIRTIONET_MAX_QPAIRS                   512
@@ -69 +67 @@
 #define VIRTIONET_PREALLOCATE_RX_SEG_COUNT     32
 
-#define QUEUE_NAME(a_pVirtio, a_idxQueue)   ((a_pVirtio)->virtqState[(a_idxQueue)].szVirtqName)
-#define VIRTQNAME(qIdx) (pThis->aszVirtqNames[qIdx])
-#define CBVIRTQNAME(qIdx) RTStrNLen(VIRTQNAME(qIdx), sizeof(VIRTQNAME(qIdx)))
-#define FEATURE_ENABLED(feature) (pThis->fNegotiatedFeatures & VIRTIONET_F_##feature)
+#define INSTANCE(pState) pState->szInstanceName
+#define QUEUE_NAME(a_pVirtio, a_idxQueue) ((a_pVirtio)->virtqState[(a_idxQueue)].szVirtqName)
+#define VIRTQNAME(qIdx)           (pThis->aszVirtqNames[qIdx])
+#define CBVIRTQNAME(qIdx)         RTStrNLen(VIRTQNAME(qIdx), sizeof(VIRTQNAME(qIdx)))
+#define FEATURE_ENABLED(feature)  (pThis->fNegotiatedFeatures & VIRTIONET_F_##feature)
 #define FEATURE_DISABLED(feature) (!FEATURE_ENABLED(feature))
-#define FEATURE_OFFERED(feature) (VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_##feature)
-#define INSTANCE(pState) pState->szInstanceName;
+#define FEATURE_OFFERED(feature)  (VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_##feature)
 
 #define SET_LINK_UP(pState) \
@@ -85 +83 @@
             virtioCoreNotifyConfigChanged(&pThis->Virtio)
 
-#define IS_LINK_UP(pState)  (pState->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP)
+#define IS_LINK_UP(pState)   (pState->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP)
 #define IS_LINK_DOWN(pState) !IS_LINK_UP(pState)
 
 /* Macros to calculate queue specific index number VirtIO 1.0, 5.1.2 */
-#define RXQIDX(qPairIdx)  (qPairIdx * 2)
-#define TXQIDX(qPairIdx)  (qPairIdx * 2 + 1)
-#define CTRLQIDX          ((pThis->fNegotiatedFeatures & VIRTIONET_F_MQ) ? VIRTIONET_MAX_QPAIRS * 2 + 2 : 4)
-
-#define RXVIRTQNAME(qPairIdx)  (pThis->aszVirtqNames[RXQIDX(qPairIdx)])
-#define TXVIRTQNAME(qPairIdx)  (pThis->aszVirtqNames[TXQIDX(qPairIdx)])
+#define IS_TX_QUEUE(n)    ((n) != CTRLQIDX && ((n) & 1))
+#define IS_RX_QUEUE(n)    ((n) != CTRLQIDX && !IS_TX_QUEUE(n))
+#define IS_CTRL_QUEUE(n)  ((n) == CTRLQIDX)
+#define RXQIDX_QPAIR(qPairIdx)  (qPairIdx * 2)
+#define TXQIDX_QPAIR(qPairIdx)  (qPairIdx * 2 + 1)
+#define CTRLQIDX          ((pThis->fNegotiatedFeatures & VIRTIONET_F_MQ) ? ((VIRTIONET_MAX_QPAIRS - 1) * 2 + 2) : (2))
+
+#define RXVIRTQNAME(qPairIdx)  (pThis->aszVirtqNames[RXQIDX_QPAIR(qPairIdx)])
+#define TXVIRTQNAME(qPairIdx)  (pThis->aszVirtqNames[TXQIDX_QPAIR(qPairIdx)])
 #define CTLVIRTQNAME(qPairIdx) (pThis->aszVirtqNames[CTRLQIDX])
 
@@ -154 +155 @@
     | VIRTIONET_F_CTRL_RX               \
     | VIRTIONET_F_CTRL_VLAN             \
-    | VIRTIONET_HOST_FEATURES_GSO
+    | VIRTIONET_HOST_FEATURES_GSO       \
+    | VIRTIONET_F_MRG_RXBUF
 
 #define PCI_DEVICE_ID_VIRTIONET_HOST               0x1041      /**< Informs guest driver of type of VirtIO device   */
@@ -185 +187 @@
 #pragma pack()
 
-#define VIRTIONET_F_LINK_UP                RT_BIT_16(1)         /**< config status: Link is up                      */
-#define VIRTIONET_F_ANNOUNCE               RT_BIT_16(2)         /**< config status: Announce                        */
+#define VIRTIONET_F_LINK_UP                  RT_BIT(1)          /**< config status: Link is up                      */
+#define VIRTIONET_F_ANNOUNCE                 RT_BIT(2)          /**< config status: Announce                        */
 
 /** @name VirtIO 1.0 NET Host Device device specific control types
@@ -347 +349 @@
     uint64_t                fNegotiatedFeatures;
 
-#ifdef VIRTIONET_TX_DELAY
-    /** Transmit Delay Timer. */
-    TMTIMERHANDLE           hTxTimer;
-    uint32_t                ui;
-    uint32_t                uAvgDiff;
-    uint32_t                uMinDiff;
-    uint32_t                uMaxDiff;
-    uint64_t                u64NanoTS;
-#else  /* !VNET_TX_DELAY */
-    /** The event semaphore TX thread waits on. */
     SUPSEMEVENT             hTxEvent;
-#endif /* !VNET_TX_DELAY */
 
     /** Indicates transmission in progress -- only one thread is allowed. */
@@ -381 +372 @@
 
     /** N/A: */
-    bool volatile           fMaybeOutOfSpace;
+    bool volatile           fLeafWantsRxBuffers;
 
     /** Flags whether VirtIO core is in ready state */
@@ -399 +390 @@
 
     /** No multicast mode - Supresses multicast receive */
-    uint8_t                 fNoMulticat;
+    uint8_t                 fNoMulticast;
 
     /** No unicast mode - Suppresses unicast receive */
@@ -420 +411 @@
 
     /** Bit array of VLAN filter, one bit per VLAN ID. */
-    uint8_t                 aVlanFilter[VIRTIONET_MAX_VID / sizeof(uint8_t)];
+    uint8_t                 aVlanFilter[VIRTIONET_MAX_VLAN_ID / sizeof(uint8_t)];
 
     /* Receive-blocking-related fields ***************************************/
 
     /** EMT: Gets signalled when more RX descriptors become available. */
-    SUPSEMEVENT             hEventMoreRxDescAvail;
-
-    /** Handle of the I/O port range.  */
-    IOMIOPORTHANDLE         hIoPorts;
-
-    /** @name Statistic
-     * @{ */
-    STAMCOUNTER             StatReceiveBytes;
-    STAMCOUNTER             StatTransmitBytes;
-    STAMCOUNTER             StatReceiveGSO;
-    STAMCOUNTER             StatTransmitPackets;
-    STAMCOUNTER             StatTransmitGSO;
-    STAMCOUNTER             StatTransmitChksum;
-#ifdef VBOX_WITH_STATISTICS
-    STAMPROFILE             StatReceive;
-    STAMPROFILE             StatReceiveStore;
-    STAMPROFILEADV          StatTransmit;
-    STAMPROFILE             StatTransmitSend;
-    STAMPROFILE             StatRxOverflow;
-    STAMCOUNTER             StatRxOverflowWakeup;
-    STAMCOUNTER             StatTransmitByNetwork;
-    STAMCOUNTER             StatTransmitByThread;
-#endif
+    SUPSEMEVENT             hEventRxDescAvail;
+
 } VIRTIONET;
 /** Pointer to the shared state of the VirtIO Host NET device. */
@@ -493 +463 @@
     R3PTRTYPE(PPDMINETWORKUP)       pDrv;
 
-#ifndef VIRTIONET_TX_DELAY
     R3PTRTYPE(PPDMTHREAD)           pTxThread;
-#endif
 
     /** Link Up(/Restore) Timer. */
@@ -547 +515 @@
 #ifdef IN_RING3 /* spans most of the file, at the moment. */
 
+/**
+ * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
+ */
+static DECLCALLBACK(int) virtioNetR3WakeupWorker(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
+    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[(uintptr_t)pThread->pvUser].hEvtProcess);
+}
+
+/**
+ * Wakeup the RX thread.
+ */
+static void virtioNetR3WakeupRxBufWaiter(PPDMDEVINS pDevIns)
+{
+    PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
+
+    AssertReturnVoid(pThis->hEventRxDescAvail != NIL_SUPSEMEVENT);
+    AssertReturnVoid(ASMAtomicReadBool(&pThis->fLeafWantsRxBuffers));
+
+    Log(("%s Waking downstream driver's Rx buf waiter thread\n", INSTANCE(pThis)));
+    int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hEventRxDescAvail);
+    AssertRC(rc);
+}
 
 DECLINLINE(void) virtioNetR3SetVirtqNames(PVIRTIONET pThis)
@@ -552 +543 @@
     for (uint16_t qPairIdx = 0; qPairIdx < pThis->cVirtqPairs; qPairIdx++)
     {
-        RTStrPrintf(pThis->aszVirtqNames[RXQIDX(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "receiveq<%d>",  qPairIdx);
-        RTStrPrintf(pThis->aszVirtqNames[TXQIDX(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "transmitq<%d>", qPairIdx);
+        RTStrPrintf(pThis->aszVirtqNames[RXQIDX_QPAIR(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "receiveq<%d>",  qPairIdx);
+        RTStrPrintf(pThis->aszVirtqNames[TXQIDX_QPAIR(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "transmitq<%d>", qPairIdx);
     }
     RTStrCopy(pThis->aszVirtqNames[CTRLQIDX], VIRTIO_MAX_QUEUE_NAME_SIZE, "controlq");
 }
 
+/**
+ * Dump a packet to debug log.
+ *
+ * @param   pThis       The virtio-net shared instance data.
+ * @param   pbPacket    The packet.
+ * @param   cb          The size of the packet.
+ * @param   pszText     A string denoting direction of packet transfer.
+ */
+DECLINLINE(void) virtioNetR3PacketDump(PVIRTIONET pThis, const uint8_t *pbPacket, size_t cb, const char *pszText)
+{
+# ifdef DEBUG
+#  if 0
+    Log(("%s %s packet #%d (%d bytes):\n",
+         INSTANCE(pThis), pszText, ++pThis->u32PktNo, cb));
+    Log3(("%.*Rhxd\n", cb, pbPacket));
+#  else
+    vboxEthPacketDump(INSTANCE(pThis), pszText, pbPacket, (uint32_t)cb);
+#  endif
+# else
+    RT_NOREF4(pThis, pbPacket, cb, pszText);
+# endif
+}
 
 DECLINLINE(void) virtioNetPrintFeatures(PVIRTIONET pThis, uint32_t fFeatures, const char *pcszText)
@@ -641 +654 @@
 }
 
-/**
- * @callback_method_impl{VIRTIOCORER3,pfnQueueNotified}
- */
-static DECLCALLBACK(void) virtioNetR3Notified(PVIRTIOCORE pVirtio, PVIRTIOCORECC pVirtioCC, uint16_t qIdx)
-{
-    PVIRTIONET         pThis     = RT_FROM_MEMBER(pVirtio, VIRTIONET, Virtio);
-    PVIRTIONETCC       pThisCC   = RT_FROM_MEMBER(pVirtioCC, VIRTIONETCC, Virtio);
-    PPDMDEVINS         pDevIns   = pThisCC->pDevIns;
-    AssertReturnVoid(qIdx < pThis->cVirtQueues);
-    PVIRTIONETWORKER   pWorker   = &pThis->aWorkers[qIdx];
-    PVIRTIONETWORKERR3 pWorkerR3 = &pThisCC->aWorkers[qIdx];
-
-#ifdef LOG_ENABLED
-    RTLogFlush(NULL);
-#endif
-
-    Log6Func(("%s has available data\n", VIRTQNAME(qIdx)));
-    /* Wake queue's worker thread up if sleeping */
-    if (!ASMAtomicXchgBool(&pWorkerR3->fNotified, true))
-    {
-        if (ASMAtomicReadBool(&pWorkerR3->fSleeping))
-        {
-            Log6Func(("waking %s worker.\n", VIRTQNAME(qIdx)));
-            int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
-            AssertRC(rc);
-        }
-    }
-}
+
 
 
@@ -725 +711 @@
 
 
-#if 0
-
 static int virtioNetR3CfgAccessed(PVIRTIONET pThis, uint32_t offConfig, void *pv, uint32_t cb, bool fWrite)
 {
@@ -733 +717 @@
     if (MATCH_NET_CONFIG(uMacAddress))
         NET_CONFIG_ACCESSOR_READONLY(uMacAddress);
-#if VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_STATUS
+#if FEATURE_OFFERED(STATUS)
     else
     if (MATCH_NET_CONFIG(uStatus))
         NET_CONFIG_ACCESSOR_READONLY(uStatus);
 #endif
-#if VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_MQ
+#if FEATURE_OFFERED(MQ)
     else
     if (MATCH_NET_CONFIG(uMaxVirtqPairs))
@@ -771 +755 @@
     return virtioNetR3CfgAccessed(PDMDEVINS_2_DATA(pDevIns, PVIRTIONET), uOffset, (void *)pv, cb, true /*fWrite*/);
 }
-
-#endif
 
 
@@ -940 +922 @@
      */
 
+    virtioNetR3WakeupRxBufWaiter(pDevIns);
+
     virtioNetR3QuiesceDevice(pDevIns, enmType);
+
 }
 
@@ -991 +976 @@
 }
 
-/**
- * @callback_method_impl{FNIOMIOPORTNEWIN}
- */
-static DECLCALLBACK(VBOXSTRICTRC) vnetIOPortIn(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
-{
-    PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    RT_NOREF(pvUser);
-    return vpciIOPortIn(pDevIns, &pThis->VPCI, offPort, pu32, cb, &g_IOCallbacks);
-}
-
-
-/**
- * @callback_method_impl{FNIOMIOPORTNEWOUT}
- */
-static DECLCALLBACK(VBOXSTRICTRC) vnetIOPortOut(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
-{
-    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-    RT_NOREF(pvUser);
-    return vpciIOPortOut(pDevIns, &pThis->VPCI, &pThisCC->VPCI, offPort, u32, cb, &g_IOCallbacks);
-}
-
 
 #ifdef IN_RING3
-/**
- * @interface_method_impl{PDMIBASE,pfnQueryInterface,
- * For VNETSTATECC::VPCI.IBase}
- */
-static DECLCALLBACK(void *) virtioNetQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
-{
-    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, PVIRTIONETCC, VPCI.IBase);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
-
-    return vpciR3QueryInterface(&pThisCC->VPCI, pszIID);
-}
-
-/**
- * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
- */
-static DECLCALLBACK(int) virtioNetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
-{
-    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, PVIRTIONETCC, INetworkDown);
-    PPDMDEVINS   pDevIns = pThisCC->pDevIns;
-
-    LogFlowFunc(("%s: cMillies=%u\n", INSTANCE(pThis), cMillies));
-
-    int rc = virtioNetR3CanReceive(pDevIns, pThis, pThisCC);
-    if (RT_SUCCESS(rc))
-        return VINF_SUCCESS;
-
-    if (cMillies == 0)
-        return VERR_NET_NO_BUFFER_SPACE;
-
-    rc = VERR_INTERRUPTED;
-    ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, true);
-    STAM_PROFILE_START(&pThis->StatRxOverflow, a);
-
-    VMSTATE enmVMState;
-    while (RT_LIKELY(  (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
-                     || enmVMState == VMSTATE_RUNNING_LS))
-    {
-        int rc2 = virtioNetR3CanReceive(pDevIns, pThis, pThisCC);
-        if (RT_SUCCESS(rc2))
-        {
-            rc = VINF_SUCCESS;
-            break;
-        }
-        LogFunc(("%s: waiting cMillies=%u...\n", INSTANCE(pThis), cMillies));
-        rc2 = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hEventMoreRxDescAvail, cMillies);
-        if (RT_FAILURE(rc2) && rc2 != VERR_TIMEOUT && rc2 != VERR_INTERRUPTED)
-            RTThreadSleep(1);
-    }
-    STAM_PROFILE_STOP(&pThis->StatRxOverflow, a);
-    ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, false);
-
-    LogFlowFunc(("%s: -> %d\n", INSTANCE(pThis), rc));
-    return rc;
-}
+
+
+DECLINLINE(uint16_t) virtioNetR3Checkum16(const void *pvBuf, size_t cb)
+{
+    uint32_t  chksum = 0;
+    uint16_t *pu = (uint16_t *)pvBuf;
+
+    while (cb > 1)
+    {
+        chksum += *pu++;
+        cb -= 2;
+    }
+    if (cb)
+        chksum += *(uint8_t*)pu;
+    while (chksum >> 16)
+        chksum = (chksum >> 16) + (chksum & 0xFFFF);
+    return ~chksum;
+}
+
+DECLINLINE(void) virtioNetR3CompleteChecksum(uint8_t *pBuf, size_t cbSize, uint16_t uStart, uint16_t uOffset)
+{
+    AssertReturnVoid(uStart < cbSize);
+    AssertReturnVoid(uStart + uOffset + sizeof(uint16_t) <= cbSize);
+    *(uint16_t *)(pBuf + uStart + uOffset) = virtioNetR3Checkum16(pBuf + uStart, cbSize - uStart);
+}
+
+/**
+ * Turns on/off the read status LED.
+ *
+ * @returns VBox status code.
+ * @param   pThis          Pointer to the device state structure.
+ * @param   fOn             New LED state.
+ */
+void virtioNetR3SetReadLed(PVIRTIONETR3 pThisR3, bool fOn)
+{
+    Log6Func(("%s\n", fOn ? "on" : "off"));
+    if (fOn)
+        pThisR3->led.Asserted.s.fReading = pThisR3->led.Actual.s.fReading = 1;
+    else
+        pThisR3->led.Actual.s.fReading = fOn;
+}
+
+/**
+ * Turns on/off the write status LED.
+ *
+ * @returns VBox status code.
+ * @param   pThis          Pointer to the device state structure.
+ * @param   fOn            New LED state.
+ */
+void virtioNetR3SetWriteLed(PVIRTIONETR3 pThisR3, bool fOn)
+{
+    Log6Func(("%s\n", fOn ? "on" : "off"));
+    if (fOn)
+        pThisR3->led.Asserted.s.fWriting = pThisR3->led.Actual.s.fWriting = 1;
+    else
+        pThisR3->led.Actual.s.fWriting = fOn;
+}
+
 /**
  * Check if the device can receive data now.
@@ -1083 +1047 @@
  * @thread  RX
  */
-static int virtioNetR3CanReceive(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
-{
-    int rc = virtioNetCsRxEnter(pThis, VERR_SEM_BUSY);
-    AssertRCReturn(rc, rc);
+static int virtioNetR3IsRxQueuePrimed(PPDMDEVINS pDevIns, PVIRTIONET pThis)
+{
+    int rc;
 
     LogFlowFunc(("%s:\n", INSTANCE(pThis)));
@@ -1093 +1056 @@
         rc = VERR_NET_NO_BUFFER_SPACE;
 
-    else if (!virtioCoreIsQueueEnabled(&pThis->Virtio, RXQIDX(0)))
+    else if (!virtioCoreIsQueueEnabled(&pThis->Virtio, RXQIDX_QPAIR(0)))
         rc = VERR_NET_NO_BUFFER_SPACE;
 
-    else if (virtioCoreQueueIsEmpty(pDevIns, pThis->Virtio, RXQIDX(0)))
-    {
-        virtioCoreQueueSetNotify(&pThis->pVirtio, RXQIDX(0), true);
+    else if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(0)))
+    {
+        virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(0), true);
         rc = VERR_NET_NO_BUFFER_SPACE;
     }
     else
     {
-        virtioCoreQueueSetNotify(&pThis->pVirtio, RXQIDX(0), false);
+        virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(0), false);
         rc = VINF_SUCCESS;
     }
 
     LogFlowFunc(("%s: -> %Rrc\n", INSTANCE(pThis), rc));
-    virtioNetCsRxLeave(pThis);
     return rc;
 }
-/**
- * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
- */
-static DECLCALLBACK(void) virtioNetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
-{
-    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-    RT_NOREF(pTimer, pvUser);
-
-    int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
-    AssertRCReturnVoid(rc);
-
-    SET_LINK_UP(pThis);
-
-    virtioNetWakeupReceive(pDevIns);
-
-    virtioNetR3CsLeave(pDevIns, pThis);
-
-    LogFunc(("%s: Link is up\n", INSTANCE(pThis)));
-    if (pThisCC->pDrv)
-        pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, PDMNETWORKLINKSTATE_UP);
-}
-
-
-/**
- * Takes down the link temporarily if it's current status is up.
- *
- * This is used during restore and when replumbing the network link.
- *
- * The temporary link outage is supposed to indicate to the OS that all network
- * connections have been lost and that it for instance is appropriate to
- * renegotiate any DHCP lease.
- *
- * @param   pDevIns     The device instance.
- * @param   pThis       The virtio-net shared instance data.
- * @param   pThisCC     The virtio-net ring-3 instance data.
- */
-static void virtioNetR3TempLinkDown(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
-{
-    if (IS_LINK_UP(pThis))
-    {
-        SET_LINK_DOWN(pThis);
-
-        /* Restore the link back in 5 seconds. */
-        int rc = PDMDevHlpTimerSetMillies(pDevIns, pThisCC->hLinkUpTimer, pThis->cMsLinkUpDelay);
-        AssertRC(rc);
-
-        LogFunc(("%s: Link is down temporarily\n", INSTANCE(pThis)));
-    }
-}
-
-/**
- * @interface_method_impl{PDMINETWORKCONFIG,pfnGetLinkState}
- */
-static DECLCALLBACK(PDMNETWORKLINKSTATE) virtioNetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
-{
-    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
-
-    return IS_LINK_UP(pThis) ? PDMNETWORKLINKSTATE_UP : PDMNETWORKLINKSTATE_DOWN;
-}
-
-/**
- * @interface_method_impl{PDMINETWORKCONFIG,pfnSetLinkState}
- */
-static DECLCALLBACK(int) virtioNetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
-{
-    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, PVIRTIONETCC, INetworkConfig);
+
+/**
+ * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
+ */
+static DECLCALLBACK(int) virtioNetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL timeoutMs)
+{
+    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
     PPDMDEVINS   pDevIns = pThisCC->pDevIns;
     PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
 
-    bool fOldUp = !!(pThis->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP);
-    bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
-
-    Log(("%s virtioNetR3NetworkConfig_SetLinkState: enmState=%d\n", INSTANCE(pThis), enmState));
-    if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
-    {
-        if (fOldUp)
+    LogFlowFunc(("%s: timeoutMs=%u\n", INSTANCE(pThis), timeoutMs));
+
+    if (!timeoutMs)
+        return VERR_NET_NO_BUFFER_SPACE;
+
+    ASMAtomicXchgBool(&pThis->fLeafWantsRxBuffers, true);
+
+    VMSTATE enmVMState;
+    while (RT_LIKELY(  (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
+                     || enmVMState == VMSTATE_RUNNING_LS))
+    {
+
+        if (RT_SUCCESS(virtioNetR3IsRxQueuePrimed(pDevIns, pThis)))
         {
-            /*
-             * We bother to bring the link down only if it was up previously. The UP link state
-             * notification will be sent when the link actually goes up in virtioNetR3LinkUpTimer().
-             */
-            virtioNetR3TempLinkDown(pDevIns, pThis, pThisCC);
-            if (pThisCC->pDrv)
-                pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
+            LogFunc(("Rx bufs now available, releasing waiter..."));
+            return VINF_SUCCESS;
         }
-    }
-    else if (fNewUp != fOldUp)
-    {
-        if (fNewUp)
-        {
-            Log(("%s Link is up\n", INSTANCE(pThis)));
-            pThis->fCableConnected = true;
-            pThis->virtioNetConfig.uStatus |= VIRTIONET_F_LINK_UP;
-            virtioCoreNotifyConfigChanged(&pThis->Virtio);
-        }
-        else
-        {
-            /* The link was brought down explicitly, make sure it won't come up by timer.  */
-            PDMDevHlpTimerStop(pDevIns, pThisCC->hLinkUpTimer);
-            Log(("%s Link is down\n", INSTANCE(pThis)));
-            pThis->fCableConnected = false;
-            pThis->virtioNetConfig.uStatus &= ~VIRTIONET_F_LINK_UP;
-            virtioCoreNotifyConfigChanged(&pThis->Virtio);
-        }
-        if (pThisCC->pDrv)
-            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
-    }
-    return VINF_SUCCESS;
-}
-
-/**
- * @callback_method_impl{FNVPCIQUEUECALLBACK, The RX queue}
- */
-static DECLCALLBACK(void) virtioNetR3QueueReceive(PPDMDEVINS pDevIns, PVQUEUE pQueue)
-{
-    PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    RT_NOREF(pThis, pQueue);
-    LogFunc(("%s Receive buffers has been added, waking up receive thread.\n", INSTANCE(pThis)));
-    virtioNetWakeupReceive(pDevIns);
-}
+        LogFunc(("%s: Starved for guest Rx bufs, waiting %u ms ...\n", INSTANCE(pThis), timeoutMs));
+
+        int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hEventRxDescAvail, timeoutMs);
+        if (RT_FAILURE(rc) && rc != VERR_TIMEOUT && rc != VERR_INTERRUPTED)
+            RTThreadSleep(1);
+    }
+    ASMAtomicXchgBool(&pThis->fLeafWantsRxBuffers, false);
+
+    LogFlowFunc(("%s: Wait for Rx buffers available was interrupted\n", INSTANCE(pThis)));
+    return VERR_INTERRUPTED;
+}
+
 
 /**
@@ -1239 +1119 @@
  * @param   pCtx                The context descriptor.
  */
-DECLINLINE(PPDMNETWORKGSO) virtioNetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VNETHDR const *pHdr)
+DECLINLINE(PPDMNETWORKGSO) virtioNetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VIRTIONET_PKT_HDR_T const *pPktHdr)
 {
     pGso->u8Type = PDMNETWORKGSOTYPE_INVALID;
 
-    if (pHdr->u8GSOType & VNETHDR_GSO_ECN)
+    if (pPktHdr->uGsoType & VIRTIONET_HDR_GSO_ECN)
     {
         AssertMsgFailed(("Unsupported flag in virtio header: ECN\n"));
         return NULL;
     }
-    switch (pHdr->u8GSOType & ~VNETHDR_GSO_ECN)
-    {
-        case VNETHDR_GSO_TCPV4:
+    switch (pPktHdr->uGsoType & ~VIRTIONET_HDR_GSO_ECN)
+    {
+        case VIRTIONET_HDR_GSO_TCPV4:
             pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_TCP;
-            pGso->cbHdrsSeg = pHdr->u16HdrLen;
+            pGso->cbHdrsSeg = pPktHdr->uHdrLen;
             break;
-        case VNETHDR_GSO_TCPV6:
+        case VIRTIONET_HDR_GSO_TCPV6:
             pGso->u8Type = PDMNETWORKGSOTYPE_IPV6_TCP;
-            pGso->cbHdrsSeg = pHdr->u16HdrLen;
+            pGso->cbHdrsSeg = pPktHdr->uHdrLen;
             break;
-        case VNETHDR_GSO_UDP:
+        case VIRTIONET_HDR_GSO_UDP:
             pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_UDP;
-            pGso->cbHdrsSeg = pHdr->u16CSumStart;
+            pGso->cbHdrsSeg = pPktHdr->uChksumStart;
             break;
         default:
             return NULL;
     }
-    if (pHdr->u8Flags & VNETHDR_F_NEEDS_CSUM)
-        pGso->offHdr2  = pHdr->u16CSumStart;
+    if (pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM)
+        pGso->offHdr2  = pPktHdr->uChksumStart;
     else
     {
@@ -1273 +1153 @@
     }
     pGso->offHdr1     = sizeof(RTNETETHERHDR);
-    pGso->cbHdrsTotal = pHdr->u16HdrLen;
-    pGso->cbMaxSeg    = pHdr->u16GSOSize;
+    pGso->cbHdrsTotal = pPktHdr->uHdrLen;
+    pGso->cbMaxSeg    = pPktHdr->uGsoSize;
     return pGso;
 }
@@ -1280 +1160 @@
 
 /**
- * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
- */
-static DECLCALLBACK(int) virtioNetR3NetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
-{
-    return virtioNetR3NetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
-}
-
-/**
  * @interface_method_impl{PDMINETWORKCONFIG,pfnGetMac}
  */
 static DECLCALLBACK(int) virtioNetR3NetworkConfig_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
 {
-    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkConfig);
-    PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVNETSTATE);
+    PVIRTIONETCC    pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
+    PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
     memcpy(pMac, pThis->virtioNetConfig.uMacAddress.au8, sizeof(RTMAC));
     return VINF_SUCCESS;
 }
-#endif
 
 /**
@@ -1339 +1210 @@
 
     /* Compare TPID with VLAN Ether Type */
-    if (   uPtr[6] == RT_H2BE_u(0x8100)
-        && !ASMBitTest(pThis->aVlanFilter, RT_BE2H_u(uPtr[7]) & 0xFFF))
-    {
-        Log4func(("%s: not our VLAN, returning false\n", INSTANCE(pThis))));
+    if (   uPtr[6] == RT_H2BE_U16(0x8100)
+        && !ASMBitTest(pThis->aVlanFilter, RT_BE2H_U16(uPtr[7]) & 0xFFF))
+    {
+        Log4Func(("%s: not our VLAN, returning false\n", INSTANCE(pThis)));
         return false;
     }
@@ -1355 +1226 @@
         return true;
 
-    Log4func(("%s : %RTmac (conf) != %RTmac (dest)\n",
+    Log4Func(("%s : %RTmac (conf) != %RTmac (dest)\n",
         INSTANCE(pThis), pThis->virtioNetConfig.uMacAddress.au8, pvBuf));
 
@@ -1369 +1240 @@
 
     Log2Func(("%s: failed all tests, returning false, packet dump follows:\n",
-        INSTANCE(pThis))));
+        INSTANCE(pThis)));
 
     virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
@@ -1392 +1263 @@
  * @thread  RX
  */
+
+/*  static void virtioNetR3Receive(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
+{
+    RT_NOREF5(pDevIns, pThis, pThisCC, qIdx, pDescChain);
+}
+*/
 static int virtioNetR3HandleRxPacket(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
                                 const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso)
 {
+    RT_NOREF(pThisCC);
+
     VIRTIONET_PKT_HDR_T rxPktHdr;
 
@@ -1400 +1279 @@
     {
         Log2Func(("%s gso type=%x cbPktHdrsTotal=%u cbPktHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
-              INSTANCE(pThis), pGso->uType, pGso->cbHdrsTotal,
+              INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal,
               pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
 
         rxPktHdr.uFlags = VIRTIONET_HDR_F_NEEDS_CSUM;
-        switch (pGso->uType)
+        switch (pGso->u8Type)
         {
             case PDMNETWORKGSOTYPE_IPV4_TCP:
                 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_TCPV4;
-                rxPktHdr.uCSumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
+                rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
                 break;
             case PDMNETWORKGSOTYPE_IPV6_TCP:
                 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_TCPV6;
-                rxPktHdr.uCSumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
+                rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
                 break;
             case PDMNETWORKGSOTYPE_IPV4_UDP:
                 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_UDP;
-                rxPktHdr.uCSumOffset = RT_OFFSETOF(RTNETUDP, uh_sum);
+                rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETUDP, uh_sum);
                 break;
             default:
@@ -1422 +1301 @@
         }
         rxPktHdr.uHdrLen = pGso->cbHdrsTotal;
-        rxPktHdr.uGSOSize = pGso->cbMaxSeg;
-        rxPktHdr.uCSumStart = pGso->offHdr2;
-        STAM_REL_COUNTER_INC(&pThis->StatReceiveGSO);
+        rxPktHdr.uGsoSize = pGso->cbMaxSeg;
+        rxPktHdr.uChksumOffset = pGso->offHdr2;
     }
     else
@@ -1434 +1312 @@
     virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
 
-    PRTSGBUF pSegsBuf;
-    PRTSGSEG paSegs = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG) * 2);
-    AssertReturn(paSegs, VERR_NO_MEMORY);
-    RTSgBufInit(pSegsBuf, paSegs, cSegs);
-
-    RTGCPHYS physPktHdrNumBufs, cDescs = 0;
+    uint16_t cSegsAllocated = VIRTIONET_PREALLOCATE_RX_SEG_COUNT;
+
+    PRTSGBUF pVirtSegBufToGuest = NULL;
+    PRTSGSEG paVirtSegsToGuest = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG) * cSegsAllocated);
+    AssertReturn(paVirtSegsToGuest, VERR_NO_MEMORY);
+
+    RTGCPHYS gcPhysPktHdrNumBuffers;
+    uint32_t cDescs = 0;
 
     uint8_t fAddPktHdr = true;
-    for (uint32_t uOffset = 0; uOffset < cb; )
+    uint32_t uOffset;
+
+    while (uOffset < cb)
     {
         PVIRTIO_DESC_CHAIN_T pDescChain;
-        int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, RXQIDX(0), &pDescChain, true);
-
-        AssertRC(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE, rc);
+        int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(0), &pDescChain, true);
+
+        AssertRC(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE);
 
         /** @todo  Find a better way to deal with this */
@@ -1455 +1337 @@
                         VERR_INTERNAL_ERROR);
 
-        /* It's almost inconceivable that the first segment of the guest Rx s/g buf is smaller
-         * than 12 bytes (i.e. size of virtio_net_hdr). Smaller hasn't been seen in practice.
-         * To simplify the code, that constraint is implemented here. If a guest OS ever violates
-         * this assumption, the algorithm can be adapted handle the more complex corner case. */
-
+        /* Unlikely that len of 1st seg of guest Rx (IN) buf is less than sizeof(virtio_net_hdr) == 12.
+         * Assert it to reduce complexity. Robust solution would entail finding seg idx and offset of
+         * virtio_net_header.num_buffers (to update field *after* hdr & pkts copied to gcPhys) */
         AssertMsgReturn(pDescChain->pSgPhysReturn->paSegs[0].cbSeg >= sizeof(VIRTIONET_PKT_HDR_T),
-                        ("Desc chain's phys segs have insufficient space for pkt header!\n"),
+                        ("Desc chain's first seg has insufficient space for pkt header!\n"),
                         VERR_INTERNAL_ERROR);
 
@@ -1470 +1350 @@
         {
             /* Lead with packet header */
-            paSegs[cSegs].cbSeg = sizeof(VIRTIONET_PKT_HDR_T);
-            paSegs[cSegs].pvSeg = RTMemAlloc(paSegs[0].cb);
-            AssertReturn(paSegs[0].pvSeg, VERR_NO_MEMORY);
-
-            gcPhysPktHdrNumBuffers = pDescChain->pSgPhysReturn->paSegs[0]
-                + RT_UOFFSETOF(VIRTIONET_PKT_HDR_T, uNumBuffers);
-
-            cSegs++;
+            paVirtSegsToGuest[cSegs].cbSeg = sizeof(VIRTIONET_PKT_HDR_T);
+            paVirtSegsToGuest[cSegs].pvSeg = RTMemAlloc(sizeof(VIRTIONET_PKT_HDR_T));
+            AssertReturn(paVirtSegsToGuest[0].pvSeg, VERR_NO_MEMORY);
+
+            /* Calculate & cache the field we will need to update later in gcPhys memory */
+            gcPhysPktHdrNumBuffers = pDescChain->pSgPhysReturn->paSegs[0].gcPhys
+                                     + RT_UOFFSETOF(VIRTIONET_PKT_HDR_T, uNumBuffers);
+
+            if (cSegs++ >= cSegsAllocated)
+            {
+                cSegsAllocated <<= 1;
+                paVirtSegsToGuest = (PRTSGSEG)RTMemRealloc(paVirtSegsToGuest, sizeof(RTSGSEG) * cSegsAllocated);
+                AssertReturn(paVirtSegsToGuest, VERR_NO_MEMORY);
+            }
+
             fAddPktHdr = false;
             cbDescChainLeft -= sizeof(VIRTIONET_PKT_HDR_T);
@@ -1483 +1370 @@
 
         /* Append remaining Rx pkt or as much current desc chain has room for */
-        uint32_t uSize = RT_MIN(cb, cbDescChainLeft);
-        paSegs[cSegs].cbSeg = uSize;
-        paSegs[cSegs++].pvSeg = ((uint8_t)pvBuf) + uOffset;
-        uOffset += uSize;
+        uint32_t uboundedSize = RT_MIN(cb, cbDescChainLeft);
+        paVirtSegsToGuest[cSegs].cbSeg = uboundedSize;
+        paVirtSegsToGuest[cSegs++].pvSeg = ((uint8_t *)pvBuf) + uOffset;
+        uOffset += uboundedSize;
         cDescs++;
 
-        virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, RXQIDX(0), pSegsBuf, pDescChain, true);
+        RTSgBufInit(pVirtSegBufToGuest, paVirtSegsToGuest, cSegs);
+
+        virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(0),
+                             pVirtSegBufToGuest, pDescChain, true);
 
         if (FEATURE_DISABLED(MRG_RXBUF))
@@ -1495 +1385 @@
     }
 
-    /* Fix up pkt hdr (already in guest phys. memory) with number of descriptors to send */
-
-    int rc = PDMDevHlpPCIPhysWrite(pDevIns, gcPhysPktHdrNumBuffers, cDescs, sizeof(cDescs));
-    AssertMsgRCReturn(rc, "Failure updating descriptor count in pkt hdr in guest physical memory\n");
-
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, RXQIDX(0));
+    /* Fix-up pkthdr (in guest phys. memory) with number buffers (descriptors) processed */
+
+    int rc = PDMDevHlpPCIPhysWrite(pDevIns, gcPhysPktHdrNumBuffers, &cDescs, sizeof(cDescs));
+    AssertMsgRCReturn(rc,
+                      ("Failure updating descriptor count in pkt hdr in guest physical memory\n"),
+                      rc);
+
+    virtioCoreQueueSync(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(0));
 
     for (int i = 0; i < 2; i++)
-        RTMemFree(paSegs[i].pvSeg);
-
-    RTMemFree(paSegs);
-    RTMemFree(pSegsBuf);
+        RTMemFree(paVirtSegsToGuest[i].pvSeg);
+
+    RTMemFree(paVirtSegsToGuest);
+    RTMemFree(pVirtSegBufToGuest);
 
     if (uOffset < cb)
     {
-        Log(("%s virtioNetR3HandleRxPacket: Packet did not fit into RX queue (packet size=%u)!\n", INSTANCE(pThis), cb));
+        LogFunc(("%s Packet did not fit into RX queue (packet size=%u)!\n", INSTANCE(pThis), cb));
         return VERR_TOO_MUCH_DATA;
     }
@@ -1520 +1412 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnReceiveGso}
  */
-static DECLCALLBACK(int) virtioNetR3ReceiveGso(PPDMINETWORKDOWN pInterface, const void *pvBuf,
+static DECLCALLBACK(int) virtioNetR3NetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface, const void *pvBuf,
                                                size_t cb, PCPDMNETWORKGSO pGso)
 {
-    PVIRTIONETCC    pThisCC = RT_FROM_MEMBER(pInterface, PVIRTIONETCC, INetworkDown);
+    PVIRTIONETCC    pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
     PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
@@ -1529 +1421 @@
     if (pGso)
     {
-        uint32_t uFeatures = pThis->VPCI.uGuestFeatures;
-
-        switch (pGso->uType)
+        uint32_t uFeatures = pThis->fNegotiatedFeatures;
+
+        switch (pGso->u8Type)
         {
             case PDMNETWORKGSOTYPE_IPV4_TCP:
@@ -1549 +1441 @@
         if (!uFeatures)
         {
-            Log2Func((GSO type (0x%x) not supported\n", INSTANCE(pThis), pGso->uType));
+            Log2Func(("GSO type (0x%x) not supported\n", INSTANCE(pThis), pGso->u8Type));
             return VERR_NOT_SUPPORTED;
         }
@@ -1556 +1448 @@
     Log2Func(("pvBuf=%p cb=%u pGso=%p\n", INSTANCE(pThis), pvBuf, cb, pGso));
 
-    int rc = virtioR3CanReceive(pDevIns, pThis, pThisCC);
+    int rc = virtioNetR3IsRxQueuePrimed(pDevIns, pThis);
     if (RT_FAILURE(rc))
         return rc;
@@ -1564 +1456 @@
     if ((   enmVMState != VMSTATE_RUNNING
          && enmVMState != VMSTATE_RUNNING_LS)
-        || !(pThis->virtioNetConfig.uStatus & VIRTIONET_S_LINK_UP))
+        || !(pThis->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP))
         return VINF_SUCCESS;
 
-    STAM_PROFILE_START(&pThis->StatReceive, a);
-    virtioNetR3SetReadLed(&pThisCC, true);
+    virtioNetR3SetReadLed(pThisCC, true);
     if (virtioNetR3AddressFilter(pThis, pvBuf, cb))
     {
-        rc = virtioNetCsRxEnter(pThis, VERR_SEM_BUSY);
-        if (RT_SUCCESS(rc))
-        {
-            rc = virtioNetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso);
-            STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, cb);
-            virtioNetCsRxLeave(pThis);
-        }
-    }
-    virtioNetR3SetReadLed(&pThisCC, false);
-    STAM_PROFILE_STOP(&pThis->StatReceive, a);
+        rc = virtioNetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso);
+    }
+    virtioNetR3SetReadLed(pThisCC, false);
     return rc;
 }
 
-
-DECLINLINE(uint16_t) virtioNetR3Checkum16(const void *pvBuf, size_t cb)
-{
-    uint32_t  chksum = 0;
-    uint16_t *pu = (uint16_t *)pvBuf;
-
-    while (cb > 1)
-    {
-        chksum += *pu++;
-        cb -= 2;
-    }
-    if (cb)
-        chksum += *(uint8_t*)pu;
-    while (chksum >> 16)
-        chksum = (chksum >> 16) + (chksum & 0xFFFF);
-    return ~chksum;
-}
-
-DECLINLINE(void) virtioNetR3CompleteChecksum(uint8_t *pBuf, size_t cbSize, uint16_t uStart, uint16_t uOffset)
-{
-    AssertReturnVoid(uStart < cbSize);
-    AssertReturnVoid(uStart + uOffset + sizeof(uint16_t) <= cbSize);
-    *(uint16_t *)(pBuf + uStart + uOffset) = virtioNetR3Chksum16(pBuf + uStart, cbSize - uStart);
-}
+/**
+ * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
+ */
+static DECLCALLBACK(int) virtioNetR3NetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
+{
+    return virtioNetR3NetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
+}
+
+
 
 /* Read physical bytes from the out segment(s) of descriptor chain */
-static void virtioNetR3PullChain(PVIRTIO_DESC_CHAIN_T pDecChain, void *pv, uint16_t cb)
+static void virtioNetR3PullChain(PPDMDEVINS pDevIns, PVIRTIO_DESC_CHAIN_T pDescChain, void *pv, uint16_t cb)
 {
     uint8_t *pb = (uint8_t *)pv;
-    for (size_t cb = RT_MIN(pDescChain->cbPhysSend, sizeof(VIRTIONET_PKT_HDR_T)); cb; )
-    {
-        size_t cbSeg = cb;
+    uint16_t cbMin = RT_MIN(pDescChain->cbPhysSend, cb);
+    while (cbMin)
+    {
+        size_t cbSeg = cbMin;
         RTGCPHYS GCPhys = virtioCoreSgBufGetNextSegment(pDescChain->pSgPhysSend, &cbSeg);
         PDMDevHlpPCIPhysRead(pDevIns, GCPhys, pb, cbSeg);
         pb += cbSeg;
-        cb -= cbSeg;
-    }
+        cbMin -= cbSeg;
+    }
+    LogFunc(("Pulled %d bytes out of %d bytes requested from descriptor chain\n", cbMin, cb));
 }
 
 
 static uint8_t virtioNetR3CtrlRx(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                 PVIRTIONET_PKT_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
-{
-#define LOG_VIRTIONET_FLAG(field) LogFunc(("%s = %d\n", #field, pThis->field));
+                                 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+{
+
+#define LOG_VIRTIONET_FLAG(fld) LogFunc(("%s = %d\n", #fld, pThis->fld))
 
     LogFunc((""));
@@ -1643 +1515 @@
         /* fallthrough */
       case VIRTIONET_CTRL_RX_NOBCAST:
-        AssertMsgReturn(fFeatures & VIRTIONET_F_CTRL_RX_EXTRA,
-                        ("CTRL "extra" cmd w/o VIRTIONET_F_CTRL_RX_EXTRA feature negotiated - skipping\n"),
+        AssertMsgReturn(FEATURE_ENABLED(CTRL_RX_EXTRA),
+                        ("CTRL 'extra' cmd w/o VIRTIONET_F_CTRL_RX_EXTRA feature negotiated - skipping\n"),
                         VIRTIONET_ERROR);
         /* fall out */
@@ -1650 +1522 @@
 
     uint8_t fOn, fPromiscChanged = false;
-    virtioNetR3PullChain(pDescChain, &fOn, RT_MIN(pDescChain->cbPhysSend, sizeof(fOn)));
+    virtioNetR3PullChain(pDevIns, pDescChain, &fOn, RT_MIN(pDescChain->cbPhysSend, sizeof(fOn)));
 
     switch(pCtrlPktHdr->uCmd)
@@ -1657 +1529 @@
         pThis->fPromiscuous = !!fOn;
         fPromiscChanged = true;
-        LOG_VIRTIONET_FLAG(fPromiscuous)
+        LOG_VIRTIONET_FLAG(fPromiscuous);
         break;
       case VIRTIONET_CTRL_RX_ALLMULTI:
@@ -1684 +1556 @@
     if (pThisCC->pDrv && fPromiscChanged)
     {
-        uint8_t fPromiscuous = pThis->fPromiscuous | pThis->fAllMulticast
+        uint8_t fPromiscuous = pThis->fPromiscuous | pThis->fAllMulticast;
         LogFunc(("Setting promiscuous state to %d\n", fPromiscuous));
         pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, fPromiscuous);
@@ -1693 +1565 @@
 
 static uint8_t virtioNetR3CtrlMac(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                  PVIRTIONET_PKT_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
-{
+                                  PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+{
+RT_NOREF(pThisCC);
+
 #define ASSERT_CTRL_ADDR_SET(v) \
-    AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_ADDR_SET cmd"), VIRTIONET_ERROR);
+    AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_ADDR_SET cmd"), VIRTIONET_ERROR)
 
 #define ASSERT_CTRL_TABLE_SET(v) \
-    AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_TABLE_SET cmd"), VIRTIONET_ERROR);
-
-    int cbRemaining = pDescChain.cbPhysSend - sizeof(*pCtrlPktHdr);
-
-    switch(pCtrlPktHder->uCmd)
+    AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_TABLE_SET cmd"), VIRTIONET_ERROR)
+
+    AssertMsgReturn(pDescChain->cbPhysSend >= sizeof(*pCtrlPktHdr),
+                   ("insufficient descriptor space for ctrl pkt hdr"),
+                   VIRTIONET_ERROR);
+
+    size_t cbRemaining = pDescChain->cbPhysSend - sizeof(*pCtrlPktHdr);
+
+    switch(pCtrlPktHdr->uCmd)
     {
         case VIRTIONET_CTRL_MAC_ADDR_SET:
@@ -1709 +1587 @@
             /* Set default Rx filter MAC */
             ASSERT_CTRL_ADDR_SET(cbRemaining >= sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
-            virtioNetR3PullChain(pDescChain, &pThis->rxFilterMacDefault, sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
+            virtioNetR3PullChain(pDevIns, pDescChain, &pThis->rxFilterMacDefault, sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
             break;
         }
@@ -1718 +1596 @@
             /* Load unicast MAC filter table */
             ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
-            virtioNetR3PullChain(pDescChain, &cMacs, sizeof(cMacs));
+            virtioNetR3PullChain(pDevIns, pDescChain, &cMacs, sizeof(cMacs));
             cbRemaining -= sizeof(cMacs);
             uint32_t cbMacs = cMacs * sizeof(RTMAC);
             ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
-            virtioNetR3PullChain(pDescChain, &pThis->aMacUnicastFilter, cbMacs);
+            virtioNetR3PullChain(pDevIns, pDescChain, &pThis->aMacUnicastFilter, cbMacs);
             cbRemaining -= cbMacs;
             pThis->cUnicastFilterMacs = cMacs;
@@ -1728 +1606 @@
             /* Load multicast MAC filter table */
             ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
-            virtioNetR3PullChain(pDescChain, &cMacs, sizeof(cMacs));
+            virtioNetR3PullChain(pDevIns, pDescChain, &cMacs, sizeof(cMacs));
             cbRemaining -= sizeof(cMacs);
             cbMacs = cMacs * sizeof(RTMAC);
             ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
-            virtioNetR3PullChain(pDescChain, &pThis->aMacMulticastFilter, cbMacs);
+            virtioNetR3PullChain(pDevIns, pDescChain, &pThis->aMacMulticastFilter, cbMacs);
             cbRemaining -= cbMacs;
             pThis->cMulticastFilterMacs = cMacs;
 
 #ifdef LOG_ENABLED
-            LogFunc(("%s: unicast MACs:\n", INSTANCE(pThis))));
-            for(unsigned i = 0; i < nMacs; i++)
+            LogFunc(("%s: unicast MACs:\n", INSTANCE(pThis)));
+            for(unsigned i = 0; i < cMacs; i++)
                 LogFunc(("         %RTmac\n", &pThis->aMacUnicastFilter[i]));
 
-            LogFunc(("%s: multicast MACs:\n", INSTANCE(pThis))));
-            for(unsigned i = 0; i < nMacs; i++)
+            LogFunc(("%s: multicast MACs:\n", INSTANCE(pThis)));
+            for(unsigned i = 0; i < cMacs; i++)
                 LogFunc(("         %RTmac\n", &pThis->aMacUnicastFilter[i]));
 #endif
@@ -1752 +1630 @@
 
 static uint8_t virtioNetR3CtrlVlan(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
-                                   PVIRTIONET_PKT_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
-{
+                                   PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
+{
+    RT_NOREF(pThisCC);
+
     uint16_t uVlanId;
-    int cbRemaining = pDescChain.cbPhysSend - sizeof(*pCtrlPktHdr);
+    uint16_t cbRemaining = pDescChain->cbPhysSend - sizeof(*pCtrlPktHdr);
     AssertMsgReturn(cbRemaining > sizeof(uVlanId),
         ("DESC chain too small for VIRTIO_NET_CTRL_VLAN cmd processing"), VIRTIONET_ERROR);
-    virtioNetR3PullChain(pDescChain, &uVlanId, sizeof(uVlanId));
+    virtioNetR3PullChain(pDevIns, pDescChain, &uVlanId, sizeof(uVlanId));
     AssertMsgReturn(uVlanId > VIRTIONET_MAX_VLAN_ID,
         ("%s VLAN ID out of range (VLAN ID=%u)\n", INSTANCE(pThis), uVlanId), VIRTIONET_ERROR);
@@ -1779 +1659 @@
                             PVIRTIO_DESC_CHAIN_T pDescChain)
 {
-    PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-
+
+#define SIZEOF_SEND(descChain, ctrlHdr) RT_MIN(descChain->cbPhysSend, sizeof(ctrlHdr))
 
     if (pDescChain->cbPhysSend < 2)
@@ -1797 +1676 @@
      * Allocate buffer and read in the control command
      */
-    PVIRTIONET_PKT_HDR_T pCtrlPktHdr = (PVIRTIONET_PKT_HDR_T)RTMemAllocZ(sizeof(VIRTIONET_PKT_HDR_T));
-    AssertPtrReturn(pCtrlPktHdr, VERR_NO_MEMORY /*ignored*/);
-
-    AssertMsgReturnVoid(pDescChain >= sizeof(*pCtrlPktHdr), ("DESC chain too small for CTRL pkt header"));
-    virtioNetR3PullChain(pDescChain, pCtrlPktHdr, SIZEOF_SEND(pDescChain, VIRTIONET_PKT_HDR_T));
+    PVIRTIONET_CTRL_HDR_T pCtrlPktHdr = (PVIRTIONET_CTRL_HDR_T)RTMemAllocZ(sizeof(VIRTIONET_CTRL_HDR_T));
+
+    AssertPtrReturnVoid(pCtrlPktHdr);
+
+    AssertMsgReturnVoid(pDescChain->cbPhysSend >= sizeof(*pCtrlPktHdr),
+                        ("DESC chain too small for CTRL pkt header"));
+
+    virtioNetR3PullChain(pDevIns, pDescChain, pCtrlPktHdr, SIZEOF_SEND(pDescChain, VIRTIONET_CTRL_HDR_T));
 
     uint8_t uAck;
@@ -1819 +1701 @@
     }
 
+    int cSegs = 2;
+
     /* Return CTRL packet Ack byte (result code) to guest driver */
-    PRTSGSEG paSegs = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG) * 2);
-    AssertReturn(paSegs, VERR_NO_MEMORY);
+    PRTSGSEG paSegs = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG) * cSegs);
+    AssertMsgReturnVoid(paSegs, ("Out of memory"));
 
     RTSGSEG aSegs[] = { { &uAck, sizeof(uAck) } };
@@ -1827 +1711 @@
 
     PRTSGBUF pSegBuf = (PRTSGBUF)RTMemAllocZ(sizeof(RTSGBUF));
-    AssertReturn(pSegBuf, VERR_NO_MEMORY);
+    AssertMsgReturnVoid(pSegBuf, ("Out of memory"));
+
 
     /* Copy segment data to malloc'd memory to avoid stack out-of-scope errors sanitizer doesn't detect */
@@ -1834 +1719 @@
         void *pv = paSegs[i].pvSeg;
         paSegs[i].pvSeg = RTMemAlloc(paSegs[i].cbSeg);
-        AssertReturn(paSegs[i].pvSeg, VERR_NO_MEMORY);
+        AssertMsgReturnVoid(paSegs[i].pvSeg, ("Out of memory"));
         memcpy(paSegs[i].pvSeg, pv, paSegs[i].cbSeg);
     }
@@ -1840 +1725 @@
     RTSgBufInit(pSegBuf, paSegs, cSegs);
 
-    virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, qIdx, pSegBuf, pDescChain, true);
-    virtioCoreQueueSync(pDevIns, &pThis->Virtio, qIdx);
+    virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, CTRLQIDX, pSegBuf, pDescChain, true);
+    virtioCoreQueueSync(pDevIns, &pThis->Virtio, CTRLQIDX);
 
     for (int i = 0; i < cSegs; i++)
@@ -1850 +1735 @@
 
     LogFunc(("Processed ctrl message class/cmd/subcmd = %u/%u/%u. Ack=%u.\n",
-              pCtrlPktHdr.uClass, pCtrlPktHdr.uCmd, pCtrlPktHdr.uCmdSpecific, uAck);
+              pCtrlPktHdr->uClass, pCtrlPktHdr->uCmd, pCtrlPktHdr->uCmdSpecific, uAck));
 
 }
@@ -1861 +1746 @@
 
     Log4(("virtio-net: header flags=%x gso-type=%x len=%x gso-size=%x Chksum-start=%x Chksum-offset=%x cb=%x\n",
-          pPktHdr->uFlags, pPktHdr->uGsoType, pPktHdr->uHdrLen, pPktHdr->uGSOSize, pPktHdr->uChksumStart, pPktHdr->uChksumOffset, cbMax));
+          pPktHdr->uFlags, pPktHdr->uGsoType, pPktHdr->uHdrLen,
+          pPktHdr->uGsoSize, pPktHdr->uChksumStart, pPktHdr->uChksumOffset, cbMax));
 
     if (pPktHdr->uGsoType)
@@ -1869 +1755 @@
         /* Segmentation offloading cannot be done without checksumming, and we do not support ECN */
         if (  RT_UNLIKELY(!(pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM))
-            | RT_UNLIKELY(pPktHdr->uGsoType & VIRTIONET_HDR_GSO_ECN)))
+            | RT_UNLIKELY(pPktHdr->uGsoType & VIRTIONET_HDR_GSO_ECN))
                 return false;
 
@@ -1885 +1771 @@
         }
         /* Header + MSS must not exceed the packet size. */
-        if (RT_UNLIKELY(uMinHdrSize + pPktHdr->uChksumStart + pPktHdr->uGSOSize > cbMax))
+        if (RT_UNLIKELY(uMinHdrSize + pPktHdr->uChksumStart + pPktHdr->uGsoSize > cbMax))
             return false;
     }
@@ -1892 +1778 @@
          && sizeof(uint16_t) + pPktHdr->uChksumStart + pPktHdr->uChksumOffset > cbMax)
                return false;
-    Log4func(("returning true\n"));
+    Log4Func(("returning true\n"));
     return true;
 }
 
 static int virtioNetR3TransmitFrame(PVIRTIONET pThis, PVIRTIONETCC pThisCC, PPDMSCATTERGATHER pSgBuf,
-                               PPDMNETWORKGSO pGso, PVNETHDR pHdr)
+                               PPDMNETWORKGSO pGso, PVIRTIONET_PKT_HDR_T pPktHdr)
 {
     virtioNetR3PacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
@@ -1907 +1793 @@
          * it gets filled out by different versions of kernels.
          */
-        //if (pGso->cbHdrs < pHdr->uCSumStart + pHdr->uCSumOffset + 2)
+        //if (pGso->cbHdrs < pPktHdr->uCSumStart + pPktHdr->uCSumOffset + 2)
         {
             Log4Func(("%s: HdrLen before adjustment %d.\n",
@@ -1915 +1801 @@
                 case PDMNETWORKGSOTYPE_IPV4_TCP:
                 case PDMNETWORKGSOTYPE_IPV6_TCP:
-                    pGso->cbHdrsTotal = pHdr->uChkumStart +
-                        ((PRTNETTCP)(((uint8_t*)pSgBuf->aSegs[0].pvSeg) + pHdr->uChkumStart))->th_off * 4;
+                    pGso->cbHdrsTotal = pPktHdr->uChksumStart +
+                        ((PRTNETTCP)(((uint8_t*)pSgBuf->aSegs[0].pvSeg) + pPktHdr->uChksumStart))->th_off * 4;
                     pGso->cbHdrsSeg   = pGso->cbHdrsTotal;
                     break;
                 case PDMNETWORKGSOTYPE_IPV4_UDP:
-                    pGso->cbHdrsTotal = (uint8_t)(pHdr->uCSumStart + sizeof(RTNETUDP));
-                    pGso->cbHdrsSeg   = pHdr->u16CSumStart;
+                    pGso->cbHdrsTotal = (uint8_t)(pPktHdr->uChksumStart + sizeof(RTNETUDP));
+                    pGso->cbHdrsSeg = pPktHdr->uChksumStart;
                     break;
             }
@@ -1927 +1813 @@
             ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsTotal = pGso->cbHdrsTotal;
             ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsSeg   = pGso->cbHdrsSeg;
-            Log4(("%s vnetR3TransmitPendingPackets: adjusted HdrLen to %d.\n",
+            Log4Func(("%s: adjusted HdrLen to %d.\n",
                   INSTANCE(pThis), pGso->cbHdrsTotal));
         }
@@ -1933 +1819 @@
                   INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg,
                   pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
-        STAM_REL_COUNTER_INC(&pThis->StatTransmitGSO);
-    }
-    else if (pHdr->u8Flags & VNETHDR_F_NEEDS_CSUM)
-    {
-        STAM_REL_COUNTER_INC(&pThis->StatTransmitCSum);
+    }
+    else if (pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM)
+    {
         /*
          * This is not GSO frame but checksum offloading is requested.
          */
         virtioNetR3CompleteChecksum((uint8_t*)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed,
-                             pHdr->uChkumStart, pHdr->uCSumOffset);
+                             pPktHdr->uChksumStart, pPktHdr->uChksumOffset);
     }
 
@@ -1948 +1832 @@
 }
 
-static void virtioNetR3TransmitPendingPackets(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC,
+static void virtioNetR3TransmitPendingPackets(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
                                          uint16_t qIdx, bool fOnWorkerThread)
 {
-    PVIRTIOCORE pVirtio = pThis->pVirtio;
+    PVIRTIOCORE pVirtio = &pThis->Virtio;
 
     /*
@@ -1961 +1845 @@
         return;
 
-    if (!fVirtioReady)
+    if (!pThis->fVirtioReady)
     {
         LogFunc(("%s Ignoring transmit requests. VirtIO not ready (status=0x%x).\n",
@@ -1988 +1872 @@
     unsigned int cbPktHdr = sizeof(VIRTIONET_PKT_HDR_T);
 
-    Log3func(("%s: About to transmit %d pending packets\n",
-              INSTANCE(pThis), virtioCoreR3QueuePendingCount(pVirtio->pDevIndx, pVirtio, TXQIDX(0));
-
-    virtioNetR3SetWriteLed(&pThisCC, true);
+    Log3Func(("%s: About to transmit %d pending packets\n", INSTANCE(pThis),
+              virtioCoreR3QueuePendingCount(pVirtio->pDevIns, pVirtio, TXQIDX_QPAIR(0))));
+
+    virtioNetR3SetWriteLed(pThisCC, true);
+
 
     PVIRTIO_DESC_CHAIN_T pDescChain;
-    while (virtioCoreR3QueuePeek(pVirtio->pDevIns, pVirtio, TXQIDX(0), &pDescChain) {
-    {
-        unsigned uOffset = 0;
-        uint32_t cVirtioSegs = pDescChain->pSgPhysSend->cSegs;
-        PVIRTIOSGSEG paVirtioSegs = pDescChain->pSgPhysSend->paSegs;
-
-        if (cVirtioSegs < 2 || paVirtioSegs[0].cbSeg != cbPktHdr)
+    while (virtioCoreR3QueuePeek(pVirtio->pDevIns, pVirtio, TXQIDX_QPAIR(0), &pDescChain))
+    {
+        uint32_t cSegsFromGuest = pDescChain->pSgPhysSend->cSegs;
+        PVIRTIOSGSEG paSegsFromGuest = pDescChain->pSgPhysSend->paSegs;
+
+        Log6Func(("fetched descriptor chain from %s\n", VIRTQNAME(qIdx)));
+
+        if (cSegsFromGuest < 2 || paSegsFromGuest[0].cbSeg != cbPktHdr)
         {
             /* This check could be made more complex, because in theory (but not likely nor
              * seen in practice) the first segment could contain header and data. */
             LogFunc(("%s: The first segment is not the header! (%u < 2 || %u != %u).\n",
-                 INSTANCE(pThis), cVirtioSegs, paVirtioSegs[0].cbSeg, cbPktHdr));
+                 INSTANCE(pThis), cSegsFromGuest, paSegsFromGuest[0].cbSeg, cbPktHdr));
             break;
         }
@@ -2013 +1899 @@
 
         /* Compute total frame size. */
-        for (unsigned i = 1; i < cVirtioSegs && uSize < VIRTIONET_MAX_FRAME_SIZE; i++)
-            uSize +=  paVirtioSegs[i].cbSeg;
-
-        Log5func(("%s: complete frame is %u bytes.\n", INSTANCE(pThis), uSize));
+        for (unsigned i = 1; i < cSegsFromGuest && uSize < VIRTIONET_MAX_FRAME_SIZE; i++)
+            uSize +=  paSegsFromGuest[i].cbSeg;
+
+        Log5Func(("%s: complete frame is %u bytes.\n", INSTANCE(pThis), uSize));
         Assert(uSize <= VIRTIONET_MAX_FRAME_SIZE);
 
@@ -2023 +1909 @@
             uSize = VIRTIONET_MAX_FRAME_SIZE;
 
-        if (pThisCC->pDrv && virtioNetR3ReadHeader(pDevIns, paVirtioSegs[0].gcPhys, &PktHdr, uSize))
+        if (pThisCC->pDrv && virtioNetR3ReadHeader(pDevIns, paSegsFromGuest[0].gcPhys, &PktHdr, uSize))
         {
             PDMNETWORKGSO Gso, *pGso = virtioNetR3SetupGsoCtx(&Gso, &PktHdr);
 
             /** @todo Optimize away the extra copying! (lazy bird) */
-            PPDMSCATTERGATHER pPdmSgBuf;
-            int rc = pThisCC->pDrv->pfnAllocBuf(pThisCC->pDrv, uSize, pGso, &pPdmSgBuf);
+            PPDMSCATTERGATHER pSgBufToPdmLeafDevice;
+            int rc = pThisCC->pDrv->pfnAllocBuf(pThisCC->pDrv, uSize, pGso, &pSgBufToPdmLeafDevice);
             if (RT_SUCCESS(rc))
             {
-                pPdmSgBuf->cbUsed = uSize;
+                pSgBufToPdmLeafDevice->cbUsed = uSize;
 
                 /* Assemble a complete frame. */
-                for (unsigned i = 1; i < cVirtioSegs && uSize > 0; i++)
+                for (unsigned i = 1; i < cSegsFromGuest && uSize > 0; i++)
                 {
                     unsigned uOffset;
-                    unsigned cbSeg = RT_MIN(uSize, paVirtioSegs[i].cbSeg);
-
-                    PDMDevHlpPCIPhysRead(pDevIns, paVirtioSegs[i].gcPhys;
-                                         ((uint8_t *)pPdmSgBuf->aSegs[0].pvSeg) + uOffset,
+                    unsigned cbSeg = RT_MIN(uSize, paSegsFromGuest[i].cbSeg);
+
+                    PDMDevHlpPCIPhysRead(pDevIns, paSegsFromGuest[i].gcPhys,
+                                         ((uint8_t *)pSgBufToPdmLeafDevice->aSegs[0].pvSeg) + uOffset,
                                          cbSeg);
                     uOffset += cbSeg;
                     uSize -= cbSeg;
                 }
-                rc = virtioNetR3TransmitFrame(pThis, pThisCC, pPdmSgBuf, pGso, &PktHdr);
+                rc = virtioNetR3TransmitFrame(pThis, pThisCC, pSgBufToPdmLeafDevice, pGso, &PktHdr);
             }
             else
             {
-                Log4func(("Failed to allocate SG buffer: size=%u rc=%Rrc\n", uSize, rc));
+                Log4Func(("Failed to allocate SG buffer: size=%u rc=%Rrc\n", uSize, rc));
                 /* Stop trying to fetch TX descriptors until we get more bandwidth. */
                 break;
@@ -2057 +1943 @@
 
         /* Remove this descriptor chain from the available ring */
-        virtioCoreR3QueueSkip(pVirtio, TXQIDX(0));
+        virtioCoreR3QueueSkip(pVirtio, TXQIDX_QPAIR(0));
 
         /* No data to return to guest, but call is needed put elem (e.g. desc chain) on used ring */
-        virtioCoreR3QueuePut(pVirtio->pDevIns, pVirtio, TXQIDX(0), NULL, pDescChain, false);
-
-        virtioCoreQueueSync(pVirtio->pDevIns, pVirtio, TXQIDX(0));
+        virtioCoreR3QueuePut(pVirtio->pDevIns, pVirtio, TXQIDX_QPAIR(0), NULL, pDescChain, false);
+
+        virtioCoreQueueSync(pVirtio->pDevIns, pVirtio, TXQIDX_QPAIR(0));
+
     }
     virtioNetR3SetWriteLed(pThisCC, false);
@@ -2074 +1961 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
  */
-static DECLCALLBACK(void) vnetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
+static DECLCALLBACK(void) virtioNetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
 {
     PVIRTIONETCC    pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
     PPDMDEVINS      pDevIns = pThisCC->pDevIns;
     PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
-    vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX(0), false /*fOnWorkerThread*/);
-}
-
-# ifdef VNET_TX_DELAY
-
-/**
- * @callback_method_impl{FNVPCIQUEUECALLBACK, The TX queue}
- */
-static DECLCALLBACK(void) virtioNetR3QueueTransmit(PPDMDEVINS pDevIns, PVQUEUE pQueue)
-{
-    PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-
-    if (PDMDevHlpTimerIsActive(pDevIns, pThis->hTxTimer))
-    {
-        PDMDevHlpTimerStop(pDevIns, pThis->hTxTimer);
-        Log3Func(("%: Got kicked with notification disabled, re-enable notification and flush TX queue\n", INSTANCE(pThis)));
-        virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX(0), false /*fOnWorkerThread*/);
-        if (RT_FAILURE(virtioNettR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
-            LogRelFunc(("Failed to enter critical section!/n"));
-        else
+    virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX_QPAIR(0), false /*fOnWorkerThread*/);
+}
+
+/**
+ * @callback_method_impl{VIRTIOCORER3,pfnQueueNotified}
+ */
+static DECLCALLBACK(void) virtioNetR3QueueNotified(PVIRTIOCORE pVirtio, PVIRTIOCORECC pVirtioCC, uint16_t qIdx)
+{
+    PVIRTIONET         pThis     = RT_FROM_MEMBER(pVirtio, VIRTIONET, Virtio);
+    PVIRTIONETCC       pThisCC   = RT_FROM_MEMBER(pVirtioCC, VIRTIONETCC, Virtio);
+    PPDMDEVINS         pDevIns   = pThisCC->pDevIns;
+    PVIRTIONETWORKER   pWorker   = &pThis->aWorkers[qIdx];
+    PVIRTIONETWORKERR3 pWorkerR3 = &pThisCC->aWorkers[qIdx];
+    AssertReturnVoid(qIdx < pThis->cVirtQueues);
+
+#ifdef LOG_ENABLED
+    RTLogFlush(NULL);
+#endif
+
+    Log6Func(("%s has available buffers\n", VIRTQNAME(qIdx)));
+
+    if (IS_RX_QUEUE(qIdx))
+    {
+        LogFunc(("%s Receive buffers has been added, waking up receive thread.\n",
+            INSTANCE(pThis)));
+        virtioNetR3WakeupRxBufWaiter(pDevIns);
+    }
+    else
+    {
+        /* Wake queue's worker thread up if sleeping */
+        if (!ASMAtomicXchgBool(&pWorkerR3->fNotified, true))
         {
-            virtioCoreQueueSetNotify(&pThis->Virtio,  TXQIDX(0), true);
-            virtioNetR3CsLeave(pDevIns, pThis);
+            if (ASMAtomicReadBool(&pWorkerR3->fSleeping))
+            {
+                Log6Func(("waking %s worker.\n", VIRTQNAME(qIdx)));
+                int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
+                AssertRC(rc);
+            }
         }
     }
-    else
-    {
-        if (RT_FAILURE(virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
-            LogRelFunc(("Failed to enter critical section!/n"));
-        else
-        {
-            virtioCoreQueueSetNotify(&pThis->Virtio,  TXQIDX(0), false);
-            PDMDevHlpTimerSetMicro(pDevIns, pThis->hTxTimer, VNET_TX_DELAY);
-            pThis->u64NanoTS = RTTimeNanoTS();
-            virtioNetR3CsLeave(pDevIns, pThis);
-        }
-    }
-}
-
-/**
- * @callback_method_impl{FNTMTIMERDEV, Transmit Delay Timer handler.}
- */
-static DECLCALLBACK(void) virtioNetR3TxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
-{
-    PVIRTIONET      pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-    RT_NOREF(pTimer, pvUser);
-
-    uint32_t u32MicroDiff = (uint32_t)((RTTimeNanoTS() - pThis->u64NanoTS) / 1000);
-    if (u32MicroDiff < pThis->u32MinDiff)
-        pThis->u32MinDiff = u32MicroDiff;
-    if (u32MicroDiff > pThis->u32MaxDiff)
-        pThis->u32MaxDiff = u32MicroDiff;
-    pThis->u32AvgDiff = (pThis->u32AvgDiff * pThis->u32i + u32MicroDiff) / (pThis->u32i + 1);
-    pThis->u32i++;
-    Log3Func(("Expired, diff %9d usec, avg %9d usec, min %9d usec, max %9d usec\n",
-          u32MicroDiff, pThis->u32AvgDiff, pThis->u32MinDiff, pThis->u32MaxDiff));
-
-//    Log3Func(("%s Expired\n", INSTANCE(pThis)));
-    virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX(0), false /*fOnWorkerThread*/);
-    if (RT_FAILURE(virtioNettR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
-    {
-        LogRelFunc(("Failed to enter critical section!/n"));
-        return;
-    }
-    virtioCoreQueueSetNotify(&pThis->Virtio,  TXQIDX(0), true);
-    virtioNetR3CsLeave(pDevIns, pThis);
-}
-
-DECLINLINE(int) virtioNetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
-{
-    RT_NOREF(pDevIns, pThis, pThisCC);
-    return VINF_SUCCESS;
-}
-
-DECLINLINE(void) virtioNetR3DestroyTxThreadAndEvent(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
-{
-    RT_NOREF(pDevIns, pThis, pThisCC);
-}
-
-# else /* !VNET_TX_DELAY */
-
-/**
- * @callback_method_impl{FNPDMTHREADDEV}
- */
-static DECLCALLBACK(int) vnetR3TxThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
-{
-    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
-
-    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
-        return VINF_SUCCESS;
-
-    int rc = VINF_SUCCESS;
-    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
-    {
-        rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hTxEvent, RT_INDEFINITE_WAIT);
-        if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
-            break;
-        while (true)
-        {
-            virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX(0), false /*fOnWorkerThread*/); /// @todo shouldn't it be true instead?
-            LogFunc(("Enable kicking and get to sleep\n"));
-            virtioCoreQueueSetNotify(&pThis->Virtio,  TXQIDX(0), true);
-            if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, TXQIDX(0)))
-                break;
-            virtioCoreQueueSetNotify(&pThis->Virtio, TXQIDX(0), false);
-        }
-    }
-
-    return rc;
-}
-
-/**
- * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
- */
-static DECLCALLBACK(int) virtioNetR3TxThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    RT_NOREF(pThread);
-    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
-}
-
-static int vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
-{
-    int rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hTxEvent);
-    if (RT_SUCCESS(rc))
-    {
-        rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->pTxThread, NULL, vnetR3TxThread,
-                                   vnetR3TxThreadWakeUp, 0, RTTHREADTYPE_IO, INSTANCE(pThis));
-        if (RT_FAILURE(rc))
-            PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create worker thread %s"), INSTANCE(pThis));
-    }
-    else
-        PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create SUP event semaphore"));
-    return rc;
-}
-
-static void vnetR3DestroyTxThreadAndEvent(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
-{
-    if (pThisCC->pTxThread)
-    {
-        /* Destroy the thread. */
-        int rcThread;
-        int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->pTxThread, &rcThread);
-        if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
-            AssertMsgFailed(("%s Failed to destroy async IO thread rc=%Rrc rcThread=%Rrc\n", __FUNCTION__, rc, rcThread));
-        pThisCC->pTxThread = NULL;
-    }
-
-    if (pThis->hTxEvent != NIL_SUPSEMEVENT)
-    {
-        PDMDevHlpSUPSemEventClose(pDevIns, pThis->hTxEvent);
-        pThis->hTxEvent = NIL_SUPSEMEVENT;
-    }
-}
-
-/**
- * @callback_method_impl{FNVPCIQUEUECALLBACK, The TX queue}
- */
-static DECLCALLBACK(void) virtioNetR3QueueTransmit(PPDMDEVINS pDevIns, uint16_t qIdx)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-
-    LogFunc(("Disable kicking and wake up TX thread\n"));
-    virtioCoreQueueSetNotify(&pThis->Virtio, qIdx, false);
-    int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
-    AssertRC(rc);
-}
-
-# endif /* !VNET_TX_DELAY */
-static void virtioNetR3Transmit(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
-{
-    RT_NOREF5(pDevIns, pThis, pThisCC, qIdx, pDescChain);
-}
- static void virtioNetR3Receive(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
-{
-    RT_NOREF5(pDevIns, pThis, pThisCC, qIdx, pDescChain);
-}
-
-/**
- * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
- */
-static DECLCALLBACK(int) virtioNetR3WorkerWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
-{
-    PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[(uintptr_t)pThread->pvUser].hEvtProcess);
 }
 
@@ -2285 +2024 @@
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
+
+        virtioCoreQueueSetNotify(&pThis->Virtio,  qIdx, true);
+
         if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, qIdx))
         {
@@ -2299 +2041 @@
                     return VINF_SUCCESS;
                 if (rc == VERR_INTERRUPTED)
+                {
+                    virtioCoreQueueSetNotify(&pThis->Virtio, qIdx, false);
                     continue;
+                }
                 Log6Func(("%s worker woken\n", VIRTQNAME(qIdx)));
                 ASMAtomicWriteBool(&pWorkerR3->fNotified, false);
@@ -2306 +2051 @@
         }
 
+        virtioCoreQueueSetNotify(&pThis->Virtio, qIdx, false);
+
         if (!pThis->afQueueAttached[qIdx])
         {
@@ -2311 +2058 @@
             break;
         }
+
+        /* Dispatch to the handler for the queue this worker is set up to drive */
+
         if (!pThisCC->fQuiescing)
         {
-             Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(qIdx)));
-             PVIRTIO_DESC_CHAIN_T pDescChain;
-             int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, qIdx, &pDescChain, true);
-             if (rc == VERR_NOT_AVAILABLE)
+             if (IS_CTRL_QUEUE(qIdx))
              {
-                Log6Func(("Nothing found in %s\n", VIRTQNAME(qIdx)));
-                continue;
+                 Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(qIdx)));
+                 PVIRTIO_DESC_CHAIN_T pDescChain;
+                 int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, qIdx, &pDescChain, true);
+                 if (rc == VERR_NOT_AVAILABLE)
+                 {
+                    Log6Func(("Nothing found in %s\n", VIRTQNAME(qIdx)));
+                    continue;
+                 }
+                 virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pDescChain);
              }
-
-             AssertRC(rc);
-             if (qIdx == CTRLQIDX)
-                 virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pDescChain);
-             else if (qIdx & 1)
-                 virtioNetR3Transmit(pDevIns, pThis, pThisCC, qIdx, pDescChain);
-             else
-                 virtioNetR3Receive(pDevIns, pThis, pThisCC, qIdx, pDescChain);
+             else if (IS_TX_QUEUE(qIdx))
+             {
+                 Log6Func(("Notified of data to transmit\n"));
+                 virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC,
+                                                   qIdx, true /* fOnWorkerThread */);
+             }
+             /* Rx queues aren't handled by our worker threads. Instead, the PDM network
+              * leaf driver invokes PDMINETWORKDOWN.pfnWaitReceiveAvail() callback,
+              * which waits until notified directly by virtioNetR3QueueNotified()
+              * that guest IN buffers have been added to receive virt queue. */
         }
     }
@@ -2334 +2090 @@
 }
 
-#ifdef IN_RING3
-
-/** Returns true if large packets are written into several RX buffers. */
-DECLINLINE(bool) virtioNetR3MergeableRxBuffers(PVIRTIONET pThis)
-{
-    return !!(pThis->fFeatures & VIRTIONET_F_MRG_RXBUF);
-}
-
 DECLINLINE(int) virtioNetR3CsEnter(PPDMDEVINS pDevIns, PVIRTIONET pThis, int rcBusy)
 {
+    RT_NOREF(pDevIns, pThis, rcBusy);
     /* Original DevVirtioNet uses CS in attach/detach/link-up timer/tx timer/transmit */
-    LogFunc("CS unimplemented. What does the critical section protect in orig driver??"));
+    LogFunc(("CS unimplemented. What does the critical section protect in orig driver??"));
+    return VINF_SUCCESS;
 }
 
 DECLINLINE(void) virtioNetR3CsLeave(PPDMDEVINS pDevIns, PVIRTIONET pThis)
 {
-    LogFunc("CS unimplemented. What does the critical section protect in orig driver??"));
-}
+    RT_NOREF(pDevIns, pThis);
+    LogFunc(("CS unimplemented. What does the critical section protect in orig driver??"));
+}
+
+
+/**
+ * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
+ */
+static DECLCALLBACK(void) virtioNetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+{
+    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
+    PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
+    RT_NOREF(pTimer, pvUser);
+
+    int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
+    AssertRCReturnVoid(rc);
+
+    SET_LINK_UP(pThis);
+
+    virtioNetR3WakeupRxBufWaiter(pDevIns);
+
+    virtioNetR3CsLeave(pDevIns, pThis);
+
+    LogFunc(("%s: Link is up\n", INSTANCE(pThis)));
+    if (pThisCC->pDrv)
+        pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, PDMNETWORKLINKSTATE_UP);
+}
+
+/**
+ * Takes down the link temporarily if it's current status is up.
+ *
+ * This is used during restore and when replumbing the network link.
+ *
+ * The temporary link outage is supposed to indicate to the OS that all network
+ * connections have been lost and that it for instance is appropriate to
+ * renegotiate any DHCP lease.
+ *
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The virtio-net shared instance data.
+ * @param   pThisCC     The virtio-net ring-3 instance data.
+ */
+static void virtioNetR3TempLinkDown(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
+{
+    if (IS_LINK_UP(pThis))
+    {
+        SET_LINK_DOWN(pThis);
+
+        /* Restore the link back in 5 seconds. */
+        int rc = PDMDevHlpTimerSetMillies(pDevIns, pThisCC->hLinkUpTimer, pThis->cMsLinkUpDelay);
+        AssertRC(rc);
+
+        LogFunc(("%s: Link is down temporarily\n", INSTANCE(pThis)));
+    }
+}
+
+/**
+ * @interface_method_impl{PDMINETWORKCONFIG,pfnGetLinkState}
+ */
+static DECLCALLBACK(PDMNETWORKLINKSTATE) virtioNetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
+{
+    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
+    PVIRTIONET pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
+
+    return IS_LINK_UP(pThis) ? PDMNETWORKLINKSTATE_UP : PDMNETWORKLINKSTATE_DOWN;
+}
+
+/**
+ * @interface_method_impl{PDMINETWORKCONFIG,pfnSetLinkState}
+ */
+static DECLCALLBACK(int) virtioNetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
+{
+    PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
+    PPDMDEVINS   pDevIns = pThisCC->pDevIns;
+    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
+
+    bool fOldUp = !!(pThis->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP);
+    bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
+
+    Log(("%s virtioNetR3NetworkConfig_SetLinkState: enmState=%d\n", INSTANCE(pThis), enmState));
+    if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
+    {
+        if (fOldUp)
+        {
+            /*
+             * We bother to bring the link down only if it was up previously. The UP link state
+             * notification will be sent when the link actually goes up in virtioNetR3LinkUpTimer().
+             */
+            virtioNetR3TempLinkDown(pDevIns, pThis, pThisCC);
+            if (pThisCC->pDrv)
+                pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
+        }
+    }
+    else if (fNewUp != fOldUp)
+    {
+        if (fNewUp)
+        {
+            Log(("%s Link is up\n", INSTANCE(pThis)));
+            pThis->fCableConnected = true;
+            pThis->virtioNetConfig.uStatus |= VIRTIONET_F_LINK_UP;
+            virtioCoreNotifyConfigChanged(&pThis->Virtio);
+        }
+        else
+        {
+            /* The link was brought down explicitly, make sure it won't come up by timer.  */
+            PDMDevHlpTimerStop(pDevIns, pThisCC->hLinkUpTimer);
+            Log(("%s Link is down\n", INSTANCE(pThis)));
+            pThis->fCableConnected = false;
+            pThis->virtioNetConfig.uStatus &= ~VIRTIONET_F_LINK_UP;
+            virtioCoreNotifyConfigChanged(&pThis->Virtio);
+        }
+        if (pThisCC->pDrv)
+            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
+    }
+    return VINF_SUCCESS;
+}
+
 
 /**
@@ -2368 +2232 @@
     {
         LogFunc(("VirtIO ready\n-----------------------------------------------------------------------------------------\n"));
-        uint64_t fFeatures   = virtioCoreGetNegotiatedFeatures(&pThis->Virtio);
+//        uint64_t fFeatures   = virtioCoreGetNegotiatedFeatures(pThis->Virtio);
         pThis->fResetting    = false;
         pThisCC->fQuiescing  = false;
@@ -2379 +2243 @@
         LogFunc(("VirtIO is resetting\n"));
 
-        pThis->virtioNetConfig.status = pThis->fCableConnected ? VIRTIONET_S_LINK_UP : 0;
+        pThis->virtioNetConfig.uStatus = pThis->fCableConnected ? VIRTIONET_F_LINK_UP : 0;
         LogFunc(("%s Link is %s\n", INSTANCE(pThis), pThis->fCableConnected ? "up" : "down"));
 
@@ -2385 +2249 @@
         pThis->fAllMulticast = false;
         pThis->fAllUnicast   = false;
-        pThis->fNoMulticat   = false;
+        pThis->fNoMulticast  = false;
         pThis->fNoUnicast    = false;
         pThis->fNoBroadcast  = false;
@@ -2412 +2276 @@
 static DECLCALLBACK(void) virtioNetR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
-    PVIRTIONET       pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
-    PVIRTIONETCC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
+    RT_NOREF(fFlags);
+
+    PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
+    PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
 
     LogFunc((""));
@@ -2419 +2285 @@
 
     int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
-    AssertMsgRCReturn(rc, ("Failed to enter critical section"), rc);
+    AssertMsgRCReturnVoid(rc, ("Failed to enter critical section"));
 
     /*
@@ -2478 +2344 @@
 }
 
-/**
- * Turns on/off the write status LED.
- *
- * @returns VBox status code.
- * @param   pThis          Pointer to the device state structure.
- * @param   fOn            New LED state.
- */
-void virtioNetR3SetWriteLed(PVIRTIONETR3 pThisR3, bool fOn)
-{
-    Log6Func(("%s\n", fOn ? "on" : "off"));
-    if (fOn)
-        pThisR3->led.Asserted.s.fWriting = pThisR3->led.Actual.s.fWriting = 1;
-    else
-        pThisR3->led.Actual.s.fWriting = fOn;
-}
-
-/**
- * Turns on/off the read status LED.
- *
- * @returns VBox status code.
- * @param   pThis          Pointer to the device state structure.
- * @param   fOn             New LED state.
- */
-void virtioNetR3SetReadLed(PVIRTIONETR3 pThisR3, bool fOn)
-{
-    Log6Func(("%s\n", fOn ? "on" : "off"));
-    if (fOn)
-        pThisR3->led.Asserted.s.fReading = pThisR3->led.Actual.s.fReading = 1;
-    else
-        pThisR3->led.Actual.s.fReading = fOn;
-}
+
 /**
  * @interface_method_impl{PDMIBASE,pfnQueryInterface,
@@ -2514 +2350 @@
 static DECLCALLBACK(void *) virtioNetR3QueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
 {
-    PVIRTIONETR3 pThisR3 = RT_FROM_MEMBER(pInterface, VIRTIONETR3, IBase);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN,   &pThisR3->INetworkDown);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisR3->INetworkConfig);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE,          &pThisR3->IBase);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS,      &pThisR3->ILeds);
+    PVIRTIONETR3 pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, IBase);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN,   &pThisCC->INetworkDown);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE,          &pThisCC->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS,      &pThisCC->ILeds);
     return NULL;
 }
@@ -2529 +2365 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
+
     PVIRTIONET   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
     PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
-
 
     for (unsigned qIdx = 0; qIdx < pThis->cVirtQueues; qIdx++)
@@ -2541 +2377 @@
             pWorker->hEvtProcess = NIL_SUPSEMEVENT;
         }
+        if (pThisCC->aWorkers[qIdx].pThread)
+        {
+            /* Destroy the thread. */
+            int rcThread;
+            int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[qIdx].pThread, &rcThread);
+            if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
+                AssertMsgFailed(("%s Failed to destroythread rc=%Rrc rcThread=%Rrc\n", __FUNCTION__, rc, rcThread));
+           pThisCC->aWorkers[qIdx].pThread = NULL;
+        }
     }
 
@@ -2566 +2411 @@
     pThisCC->IBase.pfnQueryInterface = virtioNetR3QueryInterface;
     pThisCC->ILeds.pfnQueryStatusLed = virtioNetR3QueryStatusLed;
-    pThisCC->led.uMagic = PDMLED_MAGIC;
+    pThisCC->led.u32Magic = PDMLED_MAGIC;
+
+    /* Interfaces */
+    pThisCC->INetworkDown.pfnWaitReceiveAvail = virtioNetR3NetworkDown_WaitReceiveAvail;
+    pThisCC->INetworkDown.pfnReceive          = virtioNetR3NetworkDown_Receive;
+    pThisCC->INetworkDown.pfnReceiveGso       = virtioNetR3NetworkDown_ReceiveGso;
+    pThisCC->INetworkDown.pfnXmitPending      = virtioNetR3NetworkDown_XmitPending;
+    pThisCC->INetworkConfig.pfnGetMac         = virtioNetR3NetworkConfig_GetMac;
+    pThisCC->INetworkConfig.pfnGetLinkState   = virtioNetR3NetworkConfig_GetLinkState;
+    pThisCC->INetworkConfig.pfnSetLinkState   = virtioNetR3NetworkConfig_SetLinkState;
 
     /*
@@ -2574 +2428 @@
 
     /* Get config params */
-    int rc = pHlp->pfnCFGMQueryBytes(pCfg, "MAC", pThis->macConfigured.au, sizeof(pThis->macConfigured));
+    int rc = pHlp->pfnCFGMQueryBytes(pCfg, "MAC", pThis->macConfigured.au8, sizeof(pThis->macConfigured));
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get MAC address"));
@@ -2583 +2437 @@
 
     uint32_t uStatNo = iInstance;
-    rc = pHlp->pfnCFGMQueryuDef(pCfg, "StatNo", &uStatNo, iInstance);
+    rc = pHlp->pfnCFGMQueryU32Def(pCfg, "StatNo", &uStatNo, iInstance);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the \"StatNo\" value"));
 
-    rc = pHlp->pfnCFGMQueryuDef(pCfg, "LinkUpDelay", &pThis->cMsLinkUpDelay, 5000); /* ms */
+    rc = pHlp->pfnCFGMQueryU32Def(pCfg, "LinkUpDelay", &pThis->cMsLinkUpDelay, 5000); /* ms */
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the value of 'LinkUpDelay'"));
@@ -2600 +2454 @@
 
     /* Copy the MAC address configured for the VM to the MMIO accessible Virtio dev-specific config area */
-    memcpy(pThis->virtioNetConfig.uMacAddress, pThis->macConfigured.au, sizeof(pThis->virtioNetConfig.uMacAddress)); /* TBD */
+    memcpy(pThis->virtioNetConfig.uMacAddress.au8, pThis->macConfigured.au8, sizeof(pThis->virtioNetConfig.uMacAddress)); /* TBD */
 
     /*
@@ -2616 +2470 @@
     /* Initialize the generic Virtio core: */
     pThisCC->Virtio.pfnStatusChanged        = virtioNetR3StatusChanged;
-    pThisCC->Virtio.pfnQueueNotified        = virtioNetR3Notified;
+    pThisCC->Virtio.pfnQueueNotified        = virtioNetR3QueueNotified;
+    pThisCC->Virtio.pfnDevCapRead           = virtioNetR3DevCapRead;
+    pThisCC->Virtio.pfnDevCapWrite          = virtioNetR3DevCapWrite;
 
     VIRTIOPCIPARAMS VirtioPciParams;
@@ -2639 +2495 @@
     pThis->cVirtqPairs =   pThis->fNegotiatedFeatures & VIRTIONET_F_MQ
                          ? pThis->virtioNetConfig.uMaxVirtqPairs : 1;
-    pThis->cVirtQueues = pThis->cVirtqPairs + 1;
+    pThis->cVirtQueues += pThis->cVirtqPairs * 2;
+
+    /* Create Link Up Timer */
+    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, virtioNetR3LinkUpTimer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
+                              "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
 
     /*
@@ -2647 +2507 @@
 
     /* Attach the queues and create worker threads for them: */
-    for (uint16_t qIdx = 0; qIdx < pThis->cVirtQueues; qIdx++)
-    {
+    for (uint16_t qIdx = 0; qIdx < pThis->cVirtQueues + 1; qIdx++)
+    {
+
         rc = virtioCoreR3QueueAttach(&pThis->Virtio, qIdx, VIRTQNAME(qIdx));
         if (RT_FAILURE(rc))
+        {
+            pThis->afQueueAttached[qIdx] = true;
             continue;
+        }
+
+        /* Skip creating threads for receive queues, only create for transmit queues & control queue */
+        if (IS_RX_QUEUE(qIdx))
+            continue;
+
         rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[qIdx].pThread,
                                    (void *)(uintptr_t)qIdx, virtioNetR3WorkerThread,
-                                   virtioNetR3WorkerWakeUp, 0, RTTHREADTYPE_IO, VIRTQNAME(qIdx));
+                                   virtioNetR3WakeupWorker, 0, RTTHREADTYPE_IO, VIRTQNAME(qIdx));
         if (rc != VINF_SUCCESS)
         {
@@ -2708 +2577 @@
 
 #endif /* !IN_RING3 */
+
 
 

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

@@ -1030 +1030 @@
     {
         PVIRTIOSGSEG paSeg = &pSgPhysReturn->paSegs[pSgPhysReturn->idxSeg];
-        uint64_t dstSgStart = (uint64_t)paSeg->pGcSeg;
+        uint64_t dstSgStart = (uint64_t)paSeg->gcPhys;
         uint64_t dstSgLen   = (uint64_t)paSeg->cbSeg;
-        uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->pGcSegCur;
+        uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->gcPhysCur;
         cbCopied = RT_MIN((uint64_t)pSgBuf->cbSegLeft, dstSgLen - (dstSgCur - dstSgStart));
-        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->pGcSegCur, pSgBuf->pvSegCur, cbCopied);
+        PDMDevHlpPCIPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->gcPhysCur, pSgBuf->pvSegCur, cbCopied);
         RTSgBufAdvance(pSgBuf, cbCopied);
         virtioCoreSgBufAdvance(pSgPhysReturn, cbCopied);
@@ -1071 +1071 @@
     {
         PVIRTIOSGSEG paSeg  = &pSgPhysSend->paSegs[pSgPhysSend->idxSeg];
-        uint64_t srcSgStart = (uint64_t)paSeg->pGcSeg;
+        uint64_t srcSgStart = (uint64_t)paSeg->gcPhys;
         uint64_t srcSgLen   = (uint64_t)paSeg->cbSeg;
-        uint64_t srcSgCur   = (uint64_t)pSgPhysSend->pGcSegCur;
+        uint64_t srcSgCur   = (uint64_t)pSgPhysSend->gcPhysCur;
         cbCopied = RT_MIN((uint64_t)pSgBuf->cbSegLeft, srcSgLen - (srcSgCur - srcSgStart));
         PDMDevHlpPCIPhysRead(pDevIns,
-                          (RTGCPHYS)pSgPhysSend->pGcSegCur, pSgBuf->pvSegCur, cbCopied);
+                          (RTGCPHYS)pSgPhysSend->gcPhysCur, pSgBuf->pvSegCur, cbCopied);
         RTSgBufAdvance(pSgBuf, cbCopied);
         virtioCoreSgBufAdvance(pSgPhysSend, cbCopied);
@@ -2413 +2413 @@
             PDMDevHlpSUPSemEventClose(pDevIns, pWorker->hEvtProcess);
             pWorker->hEvtProcess = NIL_SUPSEMEVENT;
+        }
+
+        if (pThisCC->aWorkers[qIdx].pThread)
+        {
+            /* Destroy the thread. */
+            int rcThread;
+            int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[qIdx].pThread, &rcThread);
+            if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
+                AssertMsgFailed(("%s Failed to destroythread rc=%Rrc rcThread=%Rrc\n",
+                                 __FUNCTION__, rc, rcThread));
+           pThisCC->aWorkers[qIdx].pThread = NULL;
         }
     }

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

@@ -256 +256 @@
 }
 
-#if 0 /* unused - This may eventually be used to set no-notify for the ring as an optimization */
 DECLINLINE(void) virtioWriteUsedFlags(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, uint32_t fFlags)
 {
@@ -265 +264 @@
                           &fFlags, sizeof(fFlags));
 }
-#endif
 
 #if 0 /* unused - *May* be used when VIRTIO_F_EVENT_IDX optional feature is implemented VirtIO 1.0, 2.4.9.2*/
@@ -278 +276 @@
 #endif
 
+
 /** @} */
 
@@ -291 +290 @@
     if (cSegs && paSegs)
     {
-        pGcSgBuf->pGcSegCur = paSegs[0].pGcSeg;
+        pGcSgBuf->gcPhysCur = paSegs[0].gcPhys;
         pGcSgBuf->cbSegLeft = paSegs[0].cbSeg;
     }
     else
     {
-        pGcSgBuf->pGcSegCur = 0;
+        pGcSgBuf->gcPhysCur = 0;
         pGcSgBuf->cbSegLeft = 0;
     }
@@ -316 +315 @@
 
     AssertMsg(    pGcSgBuf->cbSegLeft <= 128 * _1M
-              && (RTGCPHYS)pGcSgBuf->pGcSegCur >= (RTGCPHYS)pGcSgBuf->paSegs[pGcSgBuf->idxSeg].pGcSeg
-              && (RTGCPHYS)pGcSgBuf->pGcSegCur + pGcSgBuf->cbSegLeft <=
-                   (RTGCPHYS)pGcSgBuf->paSegs[pGcSgBuf->idxSeg].pGcSeg + pGcSgBuf->paSegs[pGcSgBuf->idxSeg].cbSeg,
-                 ("pGcSgBuf->idxSeg=%d pGcSgBuf->cSegs=%d pGcSgBuf->pGcSegCur=%p pGcSgBuf->cbSegLeft=%zd "
-                  "pGcSgBuf->paSegs[%d].pGcSeg=%p pGcSgBuf->paSegs[%d].cbSeg=%zd\n",
-                  pGcSgBuf->idxSeg, pGcSgBuf->cSegs, pGcSgBuf->pGcSegCur, pGcSgBuf->cbSegLeft,
-                  pGcSgBuf->idxSeg, pGcSgBuf->paSegs[pGcSgBuf->idxSeg].pGcSeg, pGcSgBuf->idxSeg,
+              && (RTGCPHYS)pGcSgBuf->gcPhysCur >= (RTGCPHYS)pGcSgBuf->paSegs[pGcSgBuf->idxSeg].gcPhys
+              && (RTGCPHYS)pGcSgBuf->gcPhysCur + pGcSgBuf->cbSegLeft <=
+                   (RTGCPHYS)pGcSgBuf->paSegs[pGcSgBuf->idxSeg].gcPhys + pGcSgBuf->paSegs[pGcSgBuf->idxSeg].cbSeg,
+                 ("pGcSgBuf->idxSeg=%d pGcSgBuf->cSegs=%d pGcSgBuf->gcPhysCur=%p pGcSgBuf->cbSegLeft=%zd "
+                  "pGcSgBuf->paSegs[%d].gcPhys=%p pGcSgBuf->paSegs[%d].cbSeg=%zd\n",
+                  pGcSgBuf->idxSeg, pGcSgBuf->cSegs, pGcSgBuf->gcPhysCur, pGcSgBuf->cbSegLeft,
+                  pGcSgBuf->idxSeg, pGcSgBuf->paSegs[pGcSgBuf->idxSeg].gcPhys, pGcSgBuf->idxSeg,
                   pGcSgBuf->paSegs[pGcSgBuf->idxSeg].cbSeg));
 
     cbData = RT_MIN(*pcbData, pGcSgBuf->cbSegLeft);
-    pGcBuf = pGcSgBuf->pGcSegCur;
+    pGcBuf = pGcSgBuf->gcPhysCur;
     pGcSgBuf->cbSegLeft -= cbData;
     if (!pGcSgBuf->cbSegLeft)
@@ -334 +333 @@
         if (pGcSgBuf->idxSeg < pGcSgBuf->cSegs)
         {
-            pGcSgBuf->pGcSegCur = pGcSgBuf->paSegs[pGcSgBuf->idxSeg].pGcSeg;
+            pGcSgBuf->gcPhysCur = pGcSgBuf->paSegs[pGcSgBuf->idxSeg].gcPhys;
             pGcSgBuf->cbSegLeft = pGcSgBuf->paSegs[pGcSgBuf->idxSeg].cbSeg;
         }
@@ -340 +339 @@
     }
     else
-        pGcSgBuf->pGcSegCur = pGcSgBuf->pGcSegCur + cbData;
+        pGcSgBuf->gcPhysCur = pGcSgBuf->gcPhysCur + cbData;
 
     return pGcBuf;
@@ -352 +351 @@
     if (pGcSgBuf->cSegs)
     {
-        pGcSgBuf->pGcSegCur = pGcSgBuf->paSegs[0].pGcSeg;
+        pGcSgBuf->gcPhysCur = pGcSgBuf->paSegs[0].gcPhys;
         pGcSgBuf->cbSegLeft = pGcSgBuf->paSegs[0].cbSeg;
     }
     else
     {
-        pGcSgBuf->pGcSegCur = 0;
+        pGcSgBuf->gcPhysCur = 0;
         pGcSgBuf->cbSegLeft = 0;
     }
@@ -541 +540 @@
 #endif /* IN_RING3 */
 
-/**
- * See API comments in header file for description
- */
-int virtioQueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue)
-{
-    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-
-    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uQueueEnable[idxQueue],
-                    ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
-
-    if (virtioCoreQueueIsEmpty(pVirtio->pDevIns, pVirtio, idxQueue))
-        return VERR_NOT_AVAILABLE;
-
-    Log2Func(("%s avail_idx=%u\n", pVirtq->szVirtqName, pVirtq->uAvailIdx));
-    pVirtq->uAvailIdx++;
-
-    return VINF_SUCCESS;
-}
 
 /**
@@ -648 +628 @@
         }
 
-        pSeg->pGcSeg = desc.GCPhysBuf;
+        pSeg->gcPhys = desc.GCPhysBuf;
         pSeg->cbSeg = desc.cb;
 
@@ -679 +659 @@
 }
 
+/*
+ * Notifies guest (via ISR or MSI-X) of device configuration change
+ *
+ * @param   pVirtio     Pointer to the shared virtio state.
+ */
+void virtioCoreNotifyConfigChanged(PVIRTIOCORE pVirtio)
+{
+    virtioKick(pVirtio->pDevIns, pVirtio, VIRTIO_ISR_DEVICE_CONFIG, pVirtio->uMsixConfig, false);
+
+}
+
+/**
+ * Enable or Disable notification for the specified queue
+ *
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   idxQueue    Queue number
+ * @param   fEnabled    Selects notification mode (enabled or disabled)
+ */
+void virtioCoreQueueSetNotify(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnabled)
+{
+    uint16_t fFlags = virtioReadUsedFlags(pVirtio->pDevIns, pVirtio, idxQueue);
+
+    if (fEnabled)
+        fFlags &= ~ VIRTQ_USED_F_NO_NOTIFY;
+    else
+        fFlags |= VIRTQ_USED_F_NO_NOTIFY;
+
+    virtioWriteUsedFlags(pVirtio->pDevIns, pVirtio, idxQueue, fFlags);
+}
+
+
+/**
+ * Initiate orderly reset procedure. This is an exposed API for clients that might need it.
+ * Invoked by client to reset the device and driver (see VirtIO 1.0 section 2.1.1/2.1.2)
+ *
+ * @param   pVirtio     Pointer to the virtio state.
+ */
+void virtioCoreResetAll(PVIRTIOCORE pVirtio)
+{
+    LogFunc(("\n"));
+    pVirtio->uDeviceStatus |= VIRTIO_STATUS_DEVICE_NEEDS_RESET;
+    if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
+    {
+        pVirtio->fGenUpdatePending = true;
+        virtioKick(pVirtio->pDevIns, pVirtio, VIRTIO_ISR_DEVICE_CONFIG, pVirtio->uMsixConfig, false /* fForce */);
+    }
+}
+/**
+ * Get count of new (e.g. pending) elements in available ring.
+ *
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   idxQueue    Queue 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.
+ */
+int  virtioCoreR3QueuePendingCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue)
+{
+    uint16_t uAvailRingIdx = virtioReadAvailRingIdx(pDevIns, pVirtio, idxQueue);
+    uint16_t uNextAvailIdx = pVirtio->virtqState[idxQueue].uAvailIdx;
+    int16_t  iDelta = uAvailRingIdx - uNextAvailIdx;
+    uint16_t uDelta = uAvailRingIdx - uNextAvailIdx;
+    return iDelta >= 0 ? uDelta : VIRTQ_MAX_CNT + uDelta;
+}
 /**
  * Fetches descriptor chain using avail ring of indicated queue and converts the descriptor
- * chain into its OUT (to device) and IN to guest components.
+ * chain into its OUT (to device) and IN to guest components, but does NOT remove it from
+ * the 'avail' queue. I.e. doesn't advance the index.  This can be used with virtioQueueSkip(),
+ * which *does* advance the avail index. Together they facilitate a mechanism that allows
+ * work with a queue element (descriptor chain) to be aborted if necessary, by not advancing
+ * the pointer, or, upon success calling the skip function (above) to move to the next element.
  *
  * Additionally it converts the OUT desc chain data to a contiguous virtual
@@ -691 +740 @@
  * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue number
- * @param   fRemove     flags whether to remove desc chain from queue (false = peek)
  * @param   ppDescChain Address to store pointer to descriptor chain that contains the
  *                      pre-processed transaction information pulled from the virtq.
+ *
+ * @returns VBox status code:
+ * @retval  VINF_SUCCESS         Success
+ * @retval  VERR_INVALID_STATE   VirtIO not in ready state (asserted).
+ * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
+ */
+
+int virtioCoreR3QueuePeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+                         PPVIRTIO_DESC_CHAIN_T ppDescChain)
+{
+    return virtioCoreR3QueueGet(pDevIns, pVirtio,  idxQueue, ppDescChain, false);
+}
+
+/**
+ * Skip the next entry in the specified queue (typically used with virtioCoreR3QueuePeek())
+ *
+ * @param   pVirtio     Pointer to the virtio state.
+ * @param   idxQueue    Index of queue
+ */
+int virtioCoreR3QueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue)
+{
+    Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
+    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
+
+    AssertMsgReturn(IS_DRIVER_OK(pVirtio) && pVirtio->uQueueEnable[idxQueue],
+                    ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
+
+    if (virtioCoreQueueIsEmpty(pVirtio->pDevIns, pVirtio, idxQueue))
+        return VERR_NOT_AVAILABLE;
+
+    Log2Func(("%s avail_idx=%u\n", pVirtq->szVirtqName, pVirtq->uAvailIdx));
+    pVirtq->uAvailIdx++;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Fetches descriptor chain using avail ring of indicated queue and converts the descriptor
+ * chain into its OUT (to device) and IN to guest components.
+ *
+ * Additionally it converts the OUT desc chain data to a contiguous virtual
+ * memory buffer for easy consumption by the caller. The caller must return the
+ * descriptor chain pointer via virtioCoreR3QueuePut() and then call virtioCoreQueueSync()
+ * at some point to return the data to the guest and complete the transaction.
+ *
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   idxQueue    Queue number
+ * @param   ppDescChain Address to store pointer to descriptor chain that contains the
+ *                      pre-processed transaction information pulled from the virtq.
+ * @param   fRemove     flags whether to remove desc chain from queue (false = peek)
  *
  * @returns VBox status code:
@@ -734 +833 @@
  * @param   idxQueue        Queue number
  *
- * @param   pSgVirtReturn   Points toscatter-gather buffer of virtual memory
+ * @param   pSgVirtReturn   Points to scatter-gather buffer of virtual memory
  *                          segments the caller is returning to the guest.
  *
@@ -768 +867 @@
 
     size_t cbCopy = 0;
-    size_t cbRemain = RTSgBufCalcTotalLength(pSgVirtReturn);
-    virtioCoreSgBufReset(pSgPhysReturn); /* Reset ptr because req data may have already been written */
-    while (cbRemain)
-    {
-        PVIRTIOSGSEG paSeg = &pSgPhysReturn->paSegs[pSgPhysReturn->idxSeg];
-        uint64_t dstSgStart = (uint64_t)paSeg->pGcSeg;
-        uint64_t dstSgLen   = (uint64_t)paSeg->cbSeg;
-        uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->pGcSegCur;
-        cbCopy = RT_MIN((uint64_t)pSgVirtReturn->cbSegLeft, dstSgLen - (dstSgCur - dstSgStart));
-        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->pGcSegCur, pSgVirtReturn->pvSegCur, cbCopy);
-        RTSgBufAdvance(pSgVirtReturn, cbCopy);
-        virtioCoreSgBufAdvance(pSgPhysReturn, cbCopy);
-        cbRemain -= cbCopy;
-    }
-
-    if (fFence)
-        RT_UNTRUSTED_NONVOLATILE_COPY_FENCE(); /* needed? */
+
+    if (pSgVirtReturn)
+    {
+        size_t cbRemain = RTSgBufCalcTotalLength(pSgVirtReturn);
+        virtioCoreSgBufReset(pSgPhysReturn); /* Reset ptr because req data may have already been written */
+        while (cbRemain)
+        {
+            PVIRTIOSGSEG paSeg = &pSgPhysReturn->paSegs[pSgPhysReturn->idxSeg];
+            uint64_t dstSgStart = (uint64_t)paSeg->gcPhys;
+            uint64_t dstSgLen   = (uint64_t)paSeg->cbSeg;
+            uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->gcPhysCur;
+            cbCopy = RT_MIN((uint64_t)pSgVirtReturn->cbSegLeft, dstSgLen - (dstSgCur - dstSgStart));
+            PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->gcPhysCur, pSgVirtReturn->pvSegCur, cbCopy);
+            RTSgBufAdvance(pSgVirtReturn, cbCopy);
+            virtioCoreSgBufAdvance(pSgPhysReturn, cbCopy);
+            cbRemain -= cbCopy;
+        }
+
+        if (fFence)
+            RT_UNTRUSTED_NONVOLATILE_COPY_FENCE(); /* needed? */
+
+        Assert(!(cbCopy >> 32));
+    }
+
 
     /* If this write-ahead crosses threshold where the driver wants to get an event flag it */
@@ -790 +896 @@
         if (pVirtq->uUsedIdx == virtioReadAvailUsedEvent(pDevIns, pVirtio, idxQueue))
             pVirtq->fEventThresholdReached = true;
-
-    Assert(!(cbCopy >> 32));
 
     /*
@@ -959 +1063 @@
     else if (uMsixVector != VIRTIO_MSI_NO_VECTOR)
         PDMDevHlpPCISetIrq(pDevIns, pVirtio->uMsixConfig, PDM_IRQ_LEVEL_LOW);
-}
-
-
-
-/**
- * Initiate orderly reset procedure. This is an exposed API for clients that might need it.
- * Invoked by client to reset the device and driver (see VirtIO 1.0 section 2.1.1/2.1.2)
- */
-void virtioCoreResetAll(PVIRTIOCORE pVirtio)
-{
-    LogFunc(("\n"));
-    pVirtio->uDeviceStatus |= VIRTIO_STATUS_DEVICE_NEEDS_RESET;
-    if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
-    {
-        pVirtio->fGenUpdatePending = true;
-        virtioKick(pVirtio->pDevIns, pVirtio, VIRTIO_ISR_DEVICE_CONFIG, pVirtio->uMsixConfig, false /* fForce */);
-    }
 }
 
@@ -1394 +1481 @@
  *
  * This MMIO handler specifically supports the VIRTIO_PCI_CAP_PCI_CFG capability defined
- * in the VirtIO 1.0 specification, section 4.1.4.7, and as such is limited to cb == 1, cb == 2, or cb==4 type writes.
+ * in the VirtIO 1.0 specification, section 4.1.4.7, and as such is limited
+ * to cb == 1, cb == 2, or cb==4 type writes.
  */
 static DECLCALLBACK(VBOXSTRICTRC) virtioMmioWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)

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

@@ -71 +71 @@
 typedef struct VIRTIOSGSEG                                      /**< An S/G entry                              */
 {
-    RTGCPHYS pGcSeg;                                            /**< Pointer to the segment buffer             */
+    RTGCPHYS gcPhys;                                            /**< Pointer to the segment buffer             */
     size_t  cbSeg;                                              /**< Size of the segment buffer                */
 } VIRTIOSGSEG;
@@ -84 +84 @@
     unsigned  cSegs;                                            /**< Number of segments                        */
     unsigned  idxSeg;                                           /**< Current segment we are in                 */
-    RTGCPHYS  pGcSegCur;                                        /**< Ptr to byte within the current seg        */
+    RTGCPHYS  gcPhysCur;                                        /**< Ptr to byte within the current seg        */
     size_t    cbSegLeft;                                        /**< # of bytes left in the current segment    */
 } VIRTIOSGBUF;
@@ -377 +377 @@
                              uint16_t uHeadIdx, PPVIRTIO_DESC_CHAIN_T ppDescChain);
 
+int  virtioCoreR3QueuePeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
+                           PPVIRTIO_DESC_CHAIN_T ppDescChain);
+
+int  virtioCoreR3QueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue);
+
 int  virtioCoreR3QueueGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue,
                           PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove);
+
 int  virtioCoreR3QueuePut(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
                           PVIRTIO_DESC_CHAIN_T pDescChain, bool fFence);
+
+int  virtioCoreR3QueuePendingCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
 int  virtioCoreQueueSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
 bool virtioCoreQueueIsEmpty(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t idxQueue);
 void virtioCoreQueueEnable(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnabled);
-
-/**
- * Skip the next entry in the specified queue
- *
- * @param   pVirtio     Pointer to the virtio state.
- * @param   idxQueue    Index of queue
- *
- */
-int virtioQueueSkip(PVIRTIOCORE pVirtio, uint16_t idxQueue);
-
-/**
- * Reset the device and driver (see VirtIO 1.0 section 2.1.1/2.1.2)
- *
- * @param   pVirtio     Pointer to the virtio state.
- */
+void virtioCoreQueueSetNotify(PVIRTIOCORE pVirtio, uint16_t idxQueue, bool fEnabled);
+void virtioCoreNotifyConfigChanged(PVIRTIOCORE pVirtio);
 void virtioCoreResetAll(PVIRTIOCORE pVirtio);