Changeset 81696 in vbox

Timestamp:

Nov 6, 2019 1:48:57 AM (5 years ago)

Author:

vboxsync

Message:

DevVirtioNet.cpp: Some cleanups prepping for refactoring to new PDM device style. bugref:9218

File:

• trunk/src/VBox/Devices/Network/DevVirtioNet.cpp (modified) (109 diffs)

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

@@ -50 +50 @@
 #ifdef IN_RING3
 
-#define VNET_PCI_CLASS               0x0200
-#define VNET_N_QUEUES                3
-#define VNET_NAME_FMT                "VNet%d"
-
-#if 0
+# define VNET_PCI_CLASS              0x0200
+# define VNET_N_QUEUES               3
+# define VNET_NAME_FMT               "VNet%d"
+
+# if 0
 /* Virtio Block Device */
-#define VNET_PCI_CLASS               0x0180
-#define VNET_N_QUEUES                2
-#define VNET_NAME_FMT                "VBlk%d"
-#endif
+#  define VNET_PCI_CLASS             0x0180
+#  define VNET_N_QUEUES              2
+#  define VNET_NAME_FMT              "VBlk%d"
+# endif
 
 #endif /* IN_RING3 */
@@ -213 +213 @@
     STAMCOUNTER             StatTransmitGSO;
     STAMCOUNTER             StatTransmitCSum;
-#if defined(VBOX_WITH_STATISTICS)
+#ifdef VBOX_WITH_STATISTICS
     STAMPROFILE             StatReceive;
     STAMPROFILE             StatReceiveStore;
@@ -222 +222 @@
     STAMCOUNTER             StatTransmitByNetwork;
     STAMCOUNTER             StatTransmitByThread;
-#endif /* VBOX_WITH_STATISTICS */
+#endif
     /** @}  */
 } VNETSTATE;
@@ -278 +278 @@
 
 
-struct VNetCtlHdr
+typedef struct VNetCtlHdr
 {
     uint8_t  u8Class;
     uint8_t  u8Command;
-};
-typedef struct VNetCtlHdr VNETCTLHDR;
+} VNETCTLHDR;
+AssertCompileSize(VNETCTLHDR, 2);
 typedef VNETCTLHDR *PVNETCTLHDR;
-AssertCompileSize(VNETCTLHDR, 2);
+
+
 
 #ifdef IN_RING3
 
 /** Returns true if large packets are written into several RX buffers. */
-DECLINLINE(bool) vnetMergeableRxBuffers(PVNETSTATE pThis)
+DECLINLINE(bool) vnetR3MergeableRxBuffers(PVNETSTATE pThis)
 {
     return !!(pThis->VPCI.uGuestFeatures & VNET_F_MRG_RXBUF);
 }
 
-DECLINLINE(int) vnetCsEnter(PVNETSTATE pThis, int rcBusy)
+DECLINLINE(int) vnetR3CsEnter(PVNETSTATE pThis, int rcBusy)
 {
     return vpciCsEnter(&pThis->VPCI, rcBusy);
 }
 
-DECLINLINE(void) vnetCsLeave(PVNETSTATE pThis)
+DECLINLINE(void) vnetR3CsLeave(PVNETSTATE pThis)
 {
     vpciCsLeave(&pThis->VPCI);
@@ -333 +334 @@
  * @param   pszText     A string denoting direction of packet transfer.
  */
-DECLINLINE(void) vnetPacketDump(PVNETSTATE pThis, const uint8_t *pbPacket, size_t cb, const char *pszText)
+DECLINLINE(void) vnetR3PacketDump(PVNETSTATE pThis, const uint8_t *pbPacket, size_t cb, const char *pszText)
 {
 # ifdef DEBUG
@@ -358 +359 @@
 DECLINLINE(void) vnetPrintFeatures(PVNETSTATE pThis, uint32_t fFeatures, const char *pcszText)
 {
-#ifdef DEBUG
+#ifdef LOG_ENABLED
     static struct
     {
-        uint32_t uMask;
+        uint32_t fMask;
         const char *pcszDesc;
     } const s_aFeatures[] =
@@ -387 +388 @@
     for (unsigned i = 0; i < RT_ELEMENTS(s_aFeatures); ++i)
     {
-        if (s_aFeatures[i].uMask & fFeatures)
+        if (s_aFeatures[i].fMask & fFeatures)
             Log3(("%s --> %s\n", INSTANCE(pThis), s_aFeatures[i].pcszDesc));
     }
-#else  /* !DEBUG */
+#else  /* !LOG_ENABLED */
     RT_NOREF3(pThis, fFeatures, pcszText);
-#endif /* !DEBUG */
+#endif /* !LOG_ENABLED */
 }
 
@@ -408 +409 @@
      */
     return VNET_F_MAC
-        | VNET_F_STATUS
-        | VNET_F_CTRL_VQ
-        | VNET_F_CTRL_RX
-        | VNET_F_CTRL_VLAN
+         | VNET_F_STATUS
+         | VNET_F_CTRL_VQ
+         | VNET_F_CTRL_RX
+         | VNET_F_CTRL_VLAN
 #ifdef VNET_WITH_GSO
-        | VNET_F_CSUM
-        | VNET_F_HOST_TSO4
-        | VNET_F_HOST_TSO6
-        | VNET_F_HOST_UFO
-        | VNET_F_GUEST_CSUM   /* We expect the guest to accept partial TCP checksums (see @bugref{4796}) */
-        | VNET_F_GUEST_TSO4
-        | VNET_F_GUEST_TSO6
-        | VNET_F_GUEST_UFO
+         | VNET_F_CSUM
+         | VNET_F_HOST_TSO4
+         | VNET_F_HOST_TSO6
+         | VNET_F_HOST_UFO
+         | VNET_F_GUEST_CSUM   /* We expect the guest to accept partial TCP checksums (see @bugref{4796}) */
+         | VNET_F_GUEST_TSO4
+         | VNET_F_GUEST_TSO6
+         | VNET_F_GUEST_UFO
 #endif
 #ifdef VNET_WITH_MERGEABLE_RX_BUFS
-        | VNET_F_MRG_RXBUF
+         | VNET_F_MRG_RXBUF
 #endif
-        ;
+         ;
 }
 
@@ -519 +520 @@
  * Wakeup the RX thread.
  */
-static void vnetWakeupReceive(PPDMDEVINS pDevIns)
+static void vnetR3WakeupReceive(PPDMDEVINS pDevIns)
 {
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
@@ -542 +543 @@
  * Helper function that raises an interrupt if the guest is ready to receive it.
  */
-int vnetRaiseInterrupt(PVNETSTATE pThis, int rcBusy, uint8_t u8IntCause)
+static int vnetR3RaiseInterrupt(PVNETSTATE pThis, int rcBusy, uint8_t u8IntCause)
 {
     if (pThis->VPCI.uStatus & VPCI_STATUS_DRV_OK)
@@ -561 +562 @@
  * @param  pThis        The Virtual I/O network device state.
  */
-static void vnetTempLinkDown(PVNETSTATE pThis)
+static void vnetR3TempLinkDown(PVNETSTATE pThis)
 {
     if (STATUS & VNET_S_LINK_UP)
     {
         STATUS &= ~VNET_S_LINK_UP;
-        vnetRaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+        vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
         /* Restore the link back in 5 seconds. */
         int rc = TMTimerSetMillies(pThis->pLinkUpTimer, pThis->cMsLinkUpDelay);
         AssertRC(rc);
-        Log(("%s vnetTempLinkDown: Link is down temporarily\n", INSTANCE(pThis)));
+        Log(("%s vnetR3TempLinkDown: Link is down temporarily\n", INSTANCE(pThis)));
     }
 }
@@ -578 +579 @@
  * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
  */
-static DECLCALLBACK(void) vnetLinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+static DECLCALLBACK(void) vnetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
     RT_NOREF(pTimer);
     PVNETSTATE pThis = (PVNETSTATE)pvUser;
 
-    int rc = vnetCsEnter(pThis, VERR_SEM_BUSY);
+    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
     if (RT_UNLIKELY(rc != VINF_SUCCESS))
         return;
     STATUS |= VNET_S_LINK_UP;
-    vnetRaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
-    vnetWakeupReceive(pDevIns);
-    vnetCsLeave(pThis);
-    Log(("%s vnetLinkUpTimer: Link is up\n", INSTANCE(pThis)));
+    vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+    vnetR3WakeupReceive(pDevIns);
+    vnetR3CsLeave(pThis);
+    Log(("%s vnetR3LinkUpTimer: Link is up\n", INSTANCE(pThis)));
     if (pThis->pDrv)
         pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, PDMNETWORKLINKSTATE_UP);
@@ -599 +600 @@
  * @callback_method_impl{FNPDMQUEUEDEV, Handler for the wakeup signaller queue.}
  */
-static DECLCALLBACK(bool) vnetCanRxQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
+static DECLCALLBACK(bool) vnetR3CanRxQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
 {
     RT_NOREF(pItem);
-    vnetWakeupReceive(pDevIns);
+    vnetR3WakeupReceive(pDevIns);
     return true;
 }
@@ -625 +626 @@
  */
 #ifdef IN_RING3
-    vnetWakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
+    vnetR3WakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
 #else
     PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pThis->CTX_SUFF(pCanRxQueue));
@@ -681 +682 @@
  * @thread  RX
  */
-static int vnetCanReceive(PVNETSTATE pThis)
+static int vnetR3CanReceive(PVNETSTATE pThis)
 {
     int rc = vnetCsRxEnter(pThis, VERR_SEM_BUSY);
     AssertRCReturn(rc, rc);
 
-    LogFlow(("%s vnetCanReceive\n", INSTANCE(pThis)));
+    LogFlow(("%s vnetR3CanReceive\n", INSTANCE(pThis)));
     if (!(pThis->VPCI.uStatus & VPCI_STATUS_DRV_OK))
         rc = VERR_NET_NO_BUFFER_SPACE;
@@ -702 +703 @@
     }
 
-    LogFlow(("%s vnetCanReceive -> %Rrc\n", INSTANCE(pThis), rc));
+    LogFlow(("%s vnetR3CanReceive -> %Rrc\n", INSTANCE(pThis), rc));
     vnetCsRxLeave(pThis);
     return rc;
@@ -710 +711 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
  */
-static DECLCALLBACK(int) vnetNetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
+static DECLCALLBACK(int) vnetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
 {
     PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
-    LogFlow(("%s vnetNetworkDown_WaitReceiveAvail(cMillies=%u)\n", INSTANCE(pThis), cMillies));
-    int rc = vnetCanReceive(pThis);
+    LogFlow(("%s vnetR3NetworkDown_WaitReceiveAvail(cMillies=%u)\n", INSTANCE(pThis), cMillies));
+    int rc = vnetR3CanReceive(pThis);
 
     if (RT_SUCCESS(rc))
@@ -729 +730 @@
                      ||  enmVMState == VMSTATE_RUNNING_LS))
     {
-        int rc2 = vnetCanReceive(pThis);
+        int rc2 = vnetR3CanReceive(pThis);
         if (RT_SUCCESS(rc2))
         {
@@ -735 +736 @@
             break;
         }
-        Log(("%s vnetNetworkDown_WaitReceiveAvail: waiting cMillies=%u...\n", INSTANCE(pThis), cMillies));
+        Log(("%s vnetR3NetworkDown_WaitReceiveAvail: waiting cMillies=%u...\n", INSTANCE(pThis), cMillies));
         RTSemEventWait(pThis->hEventMoreRxDescAvail, cMillies);
     }
@@ -741 +742 @@
     ASMAtomicXchgBool(&pThis->fMaybeOutOfSpace, false);
 
-    LogFlow(("%s vnetNetworkDown_WaitReceiveAvail -> %d\n", INSTANCE(pThis), rc));
+    LogFlow(("%s vnetR3NetworkDown_WaitReceiveAvail -> %d\n", INSTANCE(pThis), rc));
     return rc;
 }
@@ -765 +766 @@
  * @param   pvBuf           The ethernet packet.
  */
-DECLINLINE(bool) vnetIsBroadcast(const void *pvBuf)
+DECLINLINE(bool) vnetR3IsBroadcast(const void *pvBuf)
 {
     static const uint8_t s_abBcastAddr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
@@ -778 +779 @@
  * @param   pvBuf           The ethernet packet.
  */
-DECLINLINE(bool) vnetIsMulticast(const void *pvBuf)
+DECLINLINE(bool) vnetR3IsMulticast(const void *pvBuf)
 {
     return (*(char*)pvBuf) & 1;
@@ -791 +792 @@
  * @param   cb              Number of bytes available in the packet.
  */
-static bool vnetAddressFilter(PVNETSTATE pThis, const void *pvBuf, size_t cb)
+static bool vnetR3AddressFilter(PVNETSTATE pThis, const void *pvBuf, size_t cb)
 {
     if (pThis->fPromiscuous)
@@ -802 +803 @@
         && !ASMBitTest(pThis->aVlanFilter, RT_BE2H_U16(u16Ptr[7]) & 0xFFF))
     {
-        Log4(("%s vnetAddressFilter: not our VLAN, returning false\n", INSTANCE(pThis)));
+        Log4(("%s vnetR3AddressFilter: not our VLAN, returning false\n", INSTANCE(pThis)));
         return false;
     }
 
-    if (vnetIsBroadcast(pvBuf))
+    if (vnetR3IsBroadcast(pvBuf))
         return true;
 
-    if (pThis->fAllMulti && vnetIsMulticast(pvBuf))
+    if (pThis->fAllMulti && vnetR3IsMulticast(pvBuf))
         return true;
 
     if (!memcmp(pThis->config.mac.au8, pvBuf, sizeof(RTMAC)))
         return true;
-    Log4(("%s vnetAddressFilter: %RTmac (conf) != %RTmac (dest)\n", INSTANCE(pThis), pThis->config.mac.au8, pvBuf));
+    Log4(("%s vnetR3AddressFilter: %RTmac (conf) != %RTmac (dest)\n", INSTANCE(pThis), pThis->config.mac.au8, pvBuf));
 
     for (unsigned i = 0; i < pThis->nMacFilterEntries; i++)
@@ -820 +821 @@
             return true;
 
-    Log2(("%s vnetAddressFilter: failed all tests, returning false, packet dump follows:\n", INSTANCE(pThis)));
-    vnetPacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
+    Log2(("%s vnetR3AddressFilter: failed all tests, returning false, packet dump follows:\n", INSTANCE(pThis)));
+    vnetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
 
     return false;
@@ -838 +839 @@
  * @thread  RX
  */
-static int vnetHandleRxPacket(PVNETSTATE pThis, const void *pvBuf, size_t cb,
-                              PCPDMNETWORKGSO pGso)
-{
-    VNETHDRMRX   Hdr;
-    unsigned    uHdrLen;
-    RTGCPHYS     addrHdrMrx = 0;
+static int vnetR3HandleRxPacket(PVNETSTATE pThis, const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso)
+{
+    VNETHDRMRX  Hdr;
+    unsigned    cbHdr;
+    RTGCPHYS    addrHdrMrx = 0;
 
     if (pGso)
     {
-        Log2(("%s vnetHandleRxPacket: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
+        Log2(("%s vnetR3HandleRxPacket: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
               INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
         Hdr.Hdr.u8Flags = VNETHDR_F_NEEDS_CSUM;
@@ -878 +878 @@
     }
 
-    if (vnetMergeableRxBuffers(pThis))
-        uHdrLen = sizeof(VNETHDRMRX);
+    if (vnetR3MergeableRxBuffers(pThis))
+        cbHdr = sizeof(VNETHDRMRX);
     else
-        uHdrLen = sizeof(VNETHDR);
-
-    vnetPacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
+        cbHdr = sizeof(VNETHDR);
+
+    vnetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
 
     unsigned int uOffset = 0;
@@ -898 +898 @@
              * were added and we received a big packet.
              */
-            Log(("%s vnetHandleRxPacket: Suddenly there is no space in receive queue!\n", INSTANCE(pThis)));
+            Log(("%s vnetR3HandleRxPacket: Suddenly there is no space in receive queue!\n", INSTANCE(pThis)));
             return VERR_INTERNAL_ERROR;
         }
@@ -904 +904 @@
         if (elem.nIn < 1)
         {
-            Log(("%s vnetHandleRxPacket: No writable descriptors in receive queue!\n", INSTANCE(pThis)));
+            Log(("%s vnetR3HandleRxPacket: No writable descriptors in receive queue!\n", INSTANCE(pThis)));
             return VERR_INTERNAL_ERROR;
         }
@@ -910 +910 @@
         if (nElem == 0)
         {
-            if (vnetMergeableRxBuffers(pThis))
+            if (vnetR3MergeableRxBuffers(pThis))
             {
                 addrHdrMrx = elem.aSegsIn[nSeg].addr;
-                cbReserved = uHdrLen;
+                cbReserved = cbHdr;
             }
             else
@@ -920 +920 @@
                 if (elem.aSegsIn[nSeg].cb != sizeof(VNETHDR))
                 {
-                    Log(("%s vnetHandleRxPacket: The first descriptor does match the header size!\n", INSTANCE(pThis)));
+                    Log(("%s vnetR3HandleRxPacket: The first descriptor does match the header size!\n", INSTANCE(pThis)));
                     return VERR_INTERNAL_ERROR;
                 }
                 elem.aSegsIn[nSeg++].pv = &Hdr;
             }
-            uElemSize += uHdrLen;
+            uElemSize += cbHdr;
         }
         while (nSeg < elem.nIn && uOffset < cb)
@@ -938 +938 @@
         vqueuePut(&pThis->VPCI, pThis->pRxQueue, &elem, uElemSize, cbReserved);
         STAM_PROFILE_STOP(&pThis->StatReceiveStore, a);
-        if (!vnetMergeableRxBuffers(pThis))
+        if (!vnetR3MergeableRxBuffers(pThis))
             break;
         cbReserved = 0;
     }
-    if (vnetMergeableRxBuffers(pThis))
+    if (vnetR3MergeableRxBuffers(pThis))
     {
         Hdr.u16NumBufs = nElem;
@@ -949 +949 @@
         if (RT_FAILURE(rc))
         {
-            Log(("%s vnetHandleRxPacket: Failed to write merged RX buf header: %Rrc\n", INSTANCE(pThis), rc));
+            Log(("%s vnetR3HandleRxPacket: Failed to write merged RX buf header: %Rrc\n", INSTANCE(pThis), rc));
             return rc;
         }
@@ -956 +956 @@
     if (uOffset < cb)
     {
-        Log(("%s vnetHandleRxPacket: Packet did not fit into RX queue (packet size=%u)!\n", INSTANCE(pThis), cb));
+        Log(("%s vnetR3HandleRxPacket: Packet did not fit into RX queue (packet size=%u)!\n", INSTANCE(pThis), cb));
         return VERR_TOO_MUCH_DATA;
     }
@@ -966 +966 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnReceiveGso}
  */
-static DECLCALLBACK(int) vnetNetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface,
+static DECLCALLBACK(int) vnetR3NetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface,
                                                     const void *pvBuf, size_t cb,
                                                     PCPDMNETWORKGSO pGso)
@@ -994 +994 @@
         if (!uFeatures)
         {
-            Log2(("%s vnetNetworkDown_ReceiveGso: GSO type (0x%x) not supported\n", INSTANCE(pThis), pGso->u8Type));
+            Log2(("%s vnetR3NetworkDown_ReceiveGso: GSO type (0x%x) not supported\n", INSTANCE(pThis), pGso->u8Type));
             return VERR_NOT_SUPPORTED;
         }
     }
 
-    Log2(("%s vnetNetworkDown_ReceiveGso: pvBuf=%p cb=%u pGso=%p\n", INSTANCE(pThis), pvBuf, cb, pGso));
-    int rc = vnetCanReceive(pThis);
+    Log2(("%s vnetR3NetworkDown_ReceiveGso: pvBuf=%p cb=%u pGso=%p\n", INSTANCE(pThis), pvBuf, cb, pGso));
+    int rc = vnetR3CanReceive(pThis);
     if (RT_FAILURE(rc))
         return rc;
@@ -1013 +1013 @@
     STAM_PROFILE_START(&pThis->StatReceive, a);
     vpciSetReadLed(&pThis->VPCI, true);
-    if (vnetAddressFilter(pThis, pvBuf, cb))
+    if (vnetR3AddressFilter(pThis, pvBuf, cb))
     {
         rc = vnetCsRxEnter(pThis, VERR_SEM_BUSY);
         if (RT_SUCCESS(rc))
         {
-            rc = vnetHandleRxPacket(pThis, pvBuf, cb, pGso);
+            rc = vnetR3HandleRxPacket(pThis, pvBuf, cb, pGso);
             STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, cb);
             vnetCsRxLeave(pThis);
@@ -1031 +1031 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
  */
-static DECLCALLBACK(int) vnetNetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
-{
-    return vnetNetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
+static DECLCALLBACK(int) vnetR3NetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
+{
+    return vnetR3NetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
 }
 
@@ -1044 +1044 @@
  * @thread  EMT
  */
-static DECLCALLBACK(int) vnetGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
+static DECLCALLBACK(int) vnetR3NetworkConfig_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
 {
     PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
@@ -1058 +1058 @@
  * @thread  EMT
  */
-static DECLCALLBACK(PDMNETWORKLINKSTATE) vnetGetLinkState(PPDMINETWORKCONFIG pInterface)
+static DECLCALLBACK(PDMNETWORKLINKSTATE) vnetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
 {
     PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
@@ -1074 +1074 @@
  * @param   enmState        The new link state
  */
-static DECLCALLBACK(int) vnetSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
+static DECLCALLBACK(int) vnetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
 {
     PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
@@ -1080 +1080 @@
     bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
 
-    Log(("%s vnetSetLinkState: enmState=%d\n", INSTANCE(pThis), enmState));
+    Log(("%s vnetR3NetworkConfig_SetLinkState: enmState=%d\n", INSTANCE(pThis), enmState));
     if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
     {
@@ -1087 +1087 @@
             /*
              * 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 vnetLinkUpTimer().
+             * notification will be sent when the link actually goes up in vnetR3LinkUpTimer().
              */
-            vnetTempLinkDown(pThis);
+            vnetR3TempLinkDown(pThis);
             if (pThis->pDrv)
                 pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, enmState);
@@ -1101 +1101 @@
             pThis->fCableConnected = true;
             STATUS |= VNET_S_LINK_UP;
-            vnetRaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+            vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
         }
         else
@@ -1110 +1110 @@
             pThis->fCableConnected = false;
             STATUS &= ~VNET_S_LINK_UP;
-            vnetRaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+            vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
         }
         if (pThis->pDrv)
@@ -1118 +1118 @@
 }
 
-static DECLCALLBACK(void) vnetQueueReceive(void *pvState, PVQUEUE pQueue)
+static DECLCALLBACK(void) vnetR3QueueReceive(void *pvState, PVQUEUE pQueue)
 {
     RT_NOREF(pQueue);
     PVNETSTATE pThis = (PVNETSTATE)pvState;
     Log(("%s Receive buffers has been added, waking up receive thread.\n", INSTANCE(pThis)));
-    vnetWakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
+    vnetR3WakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
 }
 
@@ -1132 +1132 @@
  * @param   pCtx                The context descriptor.
  */
-DECLINLINE(PPDMNETWORKGSO) vnetSetupGsoCtx(PPDMNETWORKGSO pGso, VNETHDR const *pHdr)
+DECLINLINE(PPDMNETWORKGSO) vnetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VNETHDR const *pHdr)
 {
     pGso->u8Type = PDMNETWORKGSOTYPE_INVALID;
@@ -1171 +1171 @@
 }
 
-DECLINLINE(uint16_t) vnetCSum16(const void *pvBuf, size_t cb)
+DECLINLINE(uint16_t) vnetR3CSum16(const void *pvBuf, size_t cb)
 {
     uint32_t  csum = 0;
@@ -1188 +1188 @@
 }
 
-DECLINLINE(void) vnetCompleteChecksum(uint8_t *pBuf, size_t cbSize, uint16_t uStart, uint16_t uOffset)
+DECLINLINE(void) vnetR3CompleteChecksum(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) = vnetCSum16(pBuf + uStart, cbSize - uStart);
-}
-
-static bool vnetReadHeader(PVNETSTATE pThis, RTGCPHYS GCPhys, PVNETHDR pHdr, uint32_t cbMax)
-{
-    int rc = PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns), GCPhys, pHdr, sizeof(*pHdr));
+    *(uint16_t*)(pBuf + uStart + uOffset) = vnetR3CSum16(pBuf + uStart, cbSize - uStart);
+}
+
+static bool vnetR3ReadHeader(PVNETSTATE pThis, RTGCPHYS GCPhys, PVNETHDR pHdr, uint32_t cbMax)
+{
+    int rc = PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns), GCPhys, pHdr, sizeof(*pHdr)); /** @todo r=bird: Why not PDMDevHlpPCIPhysRead? */
     if (RT_FAILURE(rc))
         return false;
@@ -1238 +1238 @@
 }
 
-static int vnetTransmitFrame(PVNETSTATE pThis, PPDMSCATTERGATHER pSgBuf, PPDMNETWORKGSO pGso, PVNETHDR pHdr)
-{
-    vnetPacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
+static int vnetR3TransmitFrame(PVNETSTATE pThis, PPDMSCATTERGATHER pSgBuf, PPDMNETWORKGSO pGso, PVNETHDR pHdr)
+{
+    vnetR3PacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
     if (pGso)
     {
@@ -1250 +1250 @@
         //if (pGso->cbHdrs < pHdr->u16CSumStart + pHdr->u16CSumOffset + 2)
         {
-            Log4(("%s vnetTransmitPendingPackets: HdrLen before adjustment %d.\n",
+            Log4(("%s vnetR3TransmitPendingPackets: HdrLen before adjustment %d.\n",
                   INSTANCE(pThis), pGso->cbHdrsTotal));
             switch (pGso->u8Type)
@@ -1268 +1268 @@
             ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsTotal = pGso->cbHdrsTotal;
             ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsSeg   = pGso->cbHdrsSeg;
-            Log4(("%s vnetTransmitPendingPackets: adjusted HdrLen to %d.\n",
+            Log4(("%s vnetR3TransmitPendingPackets: adjusted HdrLen to %d.\n",
                   INSTANCE(pThis), pGso->cbHdrsTotal));
         }
-        Log2(("%s vnetTransmitPendingPackets: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
+        Log2(("%s vnetR3TransmitPendingPackets: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
               INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
         STAM_REL_COUNTER_INC(&pThis->StatTransmitGSO);
@@ -1281 +1281 @@
          * This is not GSO frame but checksum offloading is requested.
          */
-        vnetCompleteChecksum((uint8_t*)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed,
+        vnetR3CompleteChecksum((uint8_t*)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed,
                              pHdr->u16CSumStart, pHdr->u16CSumOffset);
     }
@@ -1288 +1288 @@
 }
 
-static void vnetTransmitPendingPackets(PVNETSTATE pThis, PVQUEUE pQueue, bool fOnWorkerThread)
+static void vnetR3TransmitPendingPackets(PVNETSTATE pThis, PVQUEUE pQueue, bool fOnWorkerThread)
 {
     /*
@@ -1322 +1322 @@
     }
 
-    unsigned int uHdrLen;
-    if (vnetMergeableRxBuffers(pThis))
-        uHdrLen = sizeof(VNETHDRMRX);
+    unsigned int cbHdr;
+    if (vnetR3MergeableRxBuffers(pThis))
+        cbHdr = sizeof(VNETHDRMRX);
     else
-        uHdrLen = sizeof(VNETHDR);
-
-    Log3(("%s vnetTransmitPendingPackets: About to transmit %d pending packets\n",
+        cbHdr = sizeof(VNETHDR);
+
+    Log3(("%s vnetR3TransmitPendingPackets: About to transmit %d pending packets\n",
           INSTANCE(pThis), vringReadAvailIndex(&pThis->VPCI, &pThis->pTxQueue->VRing) - pThis->pTxQueue->uNextAvailIndex));
 
@@ -1341 +1341 @@
     {
         unsigned int uOffset = 0;
-        if (elem.nOut < 2 || elem.aSegsOut[0].cb != uHdrLen)
-        {
-            Log(("%s vnetQueueTransmit: The first segment is not the header! (%u < 2 || %u != %u).\n",
-                 INSTANCE(pThis), elem.nOut, elem.aSegsOut[0].cb, uHdrLen));
+        if (elem.nOut < 2 || elem.aSegsOut[0].cb != cbHdr)
+        {
+            Log(("%s vnetR3QueueTransmit: The first segment is not the header! (%u < 2 || %u != %u).\n",
+                 INSTANCE(pThis), elem.nOut, elem.aSegsOut[0].cb, cbHdr));
             break; /* For now we simply ignore the header, but it must be there anyway! */
         }
@@ -1356 +1356 @@
         for (unsigned int i = 1; i < elem.nOut && uSize < VNET_MAX_FRAME_SIZE; i++)
             uSize += elem.aSegsOut[i].cb;
-        Log5(("%s vnetTransmitPendingPackets: complete frame is %u bytes.\n", INSTANCE(pThis), uSize));
+        Log5(("%s vnetR3TransmitPendingPackets: complete frame is %u bytes.\n", INSTANCE(pThis), uSize));
         Assert(uSize <= VNET_MAX_FRAME_SIZE);
 
@@ -1362 +1362 @@
         if (uSize > VNET_MAX_FRAME_SIZE)
             uSize = VNET_MAX_FRAME_SIZE;
-        if (pThis->pDrv && vnetReadHeader(pThis, elem.aSegsOut[0].addr, &Hdr, uSize))
+        if (pThis->pDrv && vnetR3ReadHeader(pThis, elem.aSegsOut[0].addr, &Hdr, uSize))
         {
             RT_UNTRUSTED_VALIDATED_FENCE();
@@ -1369 +1369 @@
 
             PDMNETWORKGSO Gso;
-            PDMNETWORKGSO *pGso = vnetSetupGsoCtx(&Gso, &Hdr);
+            PDMNETWORKGSO *pGso = vnetR3SetupGsoCtx(&Gso, &Hdr);
 
             /** @todo Optimize away the extra copying! (lazy bird) */
@@ -1389 +1389 @@
                     uSize -= cbSegment;
                 }
-                rc = vnetTransmitFrame(pThis, pSgBuf, pGso, &Hdr);
+                rc = vnetR3TransmitFrame(pThis, pSgBuf, pGso, &Hdr);
             }
             else
@@ -1420 +1420 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
  */
-static DECLCALLBACK(void) vnetNetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
+static DECLCALLBACK(void) vnetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
 {
     PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
-#if defined(VBOX_WITH_STATISTICS)
-    STAM_REL_COUNTER_INC(&pThis->StatTransmitByNetwork);
-#endif /* VBOX_WITH_STATISTICS */
-    vnetTransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
-}
-
-#ifdef VNET_TX_DELAY
-
-static DECLCALLBACK(void) vnetQueueTransmit(void *pvState, PVQUEUE pQueue)
+    STAM_COUNTER_INC(&pThis->StatTransmitByNetwork);
+    vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
+}
+
+# ifdef VNET_TX_DELAY
+
+static DECLCALLBACK(void) vnetR3QueueTransmit(void *pvState, PVQUEUE pQueue)
 {
     PVNETSTATE pThis = (PVNETSTATE)pvState;
@@ -1438 +1436 @@
     {
         TMTimerStop(pThis->CTX_SUFF(pTxTimer));
-        Log3(("%s vnetQueueTransmit: Got kicked with notification disabled, re-enable notification and flush TX queue\n", INSTANCE(pThis)));
-        vnetTransmitPendingPackets(pThis, pQueue, false /*fOnWorkerThread*/);
-        if (RT_FAILURE(vnetCsEnter(pThis, VERR_SEM_BUSY)))
-            LogRel(("vnetQueueTransmit: Failed to enter critical section!/n"));
+        Log3(("%s vnetR3QueueTransmit: Got kicked with notification disabled, re-enable notification and flush TX queue\n", INSTANCE(pThis)));
+        vnetR3TransmitPendingPackets(pThis, pQueue, false /*fOnWorkerThread*/);
+        if (RT_FAILURE(vnetR3CsEnter(pThis, VERR_SEM_BUSY)))
+            LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
         else
         {
             vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, true);
-            vnetCsLeave(pThis);
+            vnetR3CsLeave(pThis);
         }
     }
     else
     {
-        if (RT_FAILURE(vnetCsEnter(pThis, VERR_SEM_BUSY)))
-            LogRel(("vnetQueueTransmit: Failed to enter critical section!/n"));
+        if (RT_FAILURE(vnetR3CsEnter(pThis, VERR_SEM_BUSY)))
+            LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
         else
         {
@@ -1457 +1455 @@
             TMTimerSetMicro(pThis->CTX_SUFF(pTxTimer), VNET_TX_DELAY);
             pThis->u64NanoTS = RTTimeNanoTS();
-            vnetCsLeave(pThis);
+            vnetR3CsLeave(pThis);
         }
     }
@@ -1465 +1463 @@
  * @callback_method_impl{FNTMTIMERDEV, Transmit Delay Timer handler.}
  */
-static DECLCALLBACK(void) vnetTxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+static DECLCALLBACK(void) vnetR3TxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
     RT_NOREF(pDevIns, pTimer);
@@ -1477 +1475 @@
     pThis->u32AvgDiff = (pThis->u32AvgDiff * pThis->u32i + u32MicroDiff) / (pThis->u32i + 1);
     pThis->u32i++;
-    Log3(("vnetTxTimer: Expired, diff %9d usec, avg %9d usec, min %9d usec, max %9d usec\n",
+    Log3(("vnetR3TxTimer: Expired, diff %9d usec, avg %9d usec, min %9d usec, max %9d usec\n",
           u32MicroDiff, pThis->u32AvgDiff, pThis->u32MinDiff, pThis->u32MaxDiff));
 
-//    Log3(("%s vnetTxTimer: Expired\n", INSTANCE(pThis)));
-    vnetTransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
-    if (RT_FAILURE(vnetCsEnter(pThis, VERR_SEM_BUSY)))
-    {
-        LogRel(("vnetTxTimer: Failed to enter critical section!/n"));
+//    Log3(("%s vnetR3TxTimer: Expired\n", INSTANCE(pThis)));
+    vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
+    if (RT_FAILURE(vnetR3CsEnter(pThis, VERR_SEM_BUSY)))
+    {
+        LogRel(("vnetR3TxTimer: Failed to enter critical section!/n"));
         return;
     }
     vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, true);
-    vnetCsLeave(pThis);
-}
-
-inline int vnetCreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
+    vnetR3CsLeave(pThis);
+}
+
+DECLINLINE(int) vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
 {
     RT_NOREF(pDevIns, pThis);
@@ -1497 +1495 @@
 }
 
-inline void vnetDestroyTxThreadAndEvent(PVNETSTATE pThis)
+DECLINLINE(void) vnetR3DestroyTxThreadAndEvent(PVNETSTATE pThis)
 {
     RT_NOREF(pThis);
 }
-#else /* !VNET_TX_DELAY */
-
-static DECLCALLBACK(int) vnetTxThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+
+# else /* !VNET_TX_DELAY */
+
+static DECLCALLBACK(int) vnetR3TxThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
     RT_NOREF(pDevIns);
@@ -1517 +1516 @@
         if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
             break;
-#if defined(VBOX_WITH_STATISTICS)
-        STAM_REL_COUNTER_INC(&pThis->StatTransmitByThread);
-#endif /* VBOX_WITH_STATISTICS */
+        STAM_COUNTER_INC(&pThis->StatTransmitByThread);
         while (true)
         {
-            vnetTransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/); /// @todo shouldn't it be true instead?
-            Log(("vnetTxThread: enable kicking and get to sleep\n"));
+            vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/); /// @todo shouldn't it be true instead?
+            Log(("vnetR3TxThread: enable kicking and get to sleep\n"));
             vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, true);
             if (vqueueIsEmpty(&pThis->VPCI, pThis->pTxQueue))
@@ -1548 +1545 @@
 }
 
-static int vnetCreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
+static int vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
 {
     int rc = SUPSemEventCreate(pThis->pSupDrvSession, &pThis->hTxEvent);
@@ -1554 +1551 @@
         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                    N_("VNET: Failed to create SUP event semaphore"));
-    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->pTxThread, pThis, vnetTxThread,
+    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->pTxThread, pThis, vnetR3TxThread,
                                vnetTxThreadWakeUp, 0, RTTHREADTYPE_IO, INSTANCE(pThis));
     if (RT_FAILURE(rc))
@@ -1562 +1559 @@
 }
 
-static void vnetDestroyTxThreadAndEvent(PVNETSTATE pThis)
+static void vnetR3DestroyTxThreadAndEvent(PVNETSTATE pThis)
 {
     if (pThis->pTxThread)
@@ -1580 +1577 @@
 }
 
-static DECLCALLBACK(void) vnetQueueTransmit(void *pvState, PVQUEUE pQueue)
+static DECLCALLBACK(void) vnetR3QueueTransmit(void *pvState, PVQUEUE pQueue)
 {
     PVNETSTATE pThis = (PVNETSTATE)pvState;
 
-    Log(("vnetQueueTransmit: disable kicking and wake up TX thread\n"));
+    Log(("vnetR3QueueTransmit: disable kicking and wake up TX thread\n"));
     vringSetNotification(&pThis->VPCI, &pQueue->VRing, false);
     SUPSemEventSignal(pThis->pSupDrvSession, pThis->hTxEvent);
 }
 
-#endif /* !VNET_TX_DELAY */
-
-static uint8_t vnetControlRx(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+# endif /* !VNET_TX_DELAY */
+
+static uint8_t vnetR3ControlRx(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint8_t u8Ack = VNET_OK;
@@ -1598 +1595 @@
                       pElem->aSegsOut[1].addr,
                       &fOn, sizeof(fOn));
-    Log(("%s vnetControlRx: uCommand=%u fOn=%u\n", INSTANCE(pThis), pCtlHdr->u8Command, fOn));
+    Log(("%s vnetR3ControlRx: uCommand=%u fOn=%u\n", INSTANCE(pThis), pCtlHdr->u8Command, fOn));
     switch (pCtlHdr->u8Command)
     {
@@ -1617 +1614 @@
 }
 
-static uint8_t vnetControlMac(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+static uint8_t vnetR3ControlMac(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint32_t nMacs = 0;
@@ -1626 +1623 @@
         || pElem->aSegsOut[2].cb < sizeof(nMacs))
     {
-        Log(("%s vnetControlMac: Segment layout is wrong (u8Command=%u nOut=%u cb1=%u cb2=%u)\n",
+        Log(("%s vnetR3ControlMac: Segment layout is wrong (u8Command=%u nOut=%u cb1=%u cb2=%u)\n",
              INSTANCE(pThis), pCtlHdr->u8Command, pElem->nOut, pElem->aSegsOut[1].cb, pElem->aSegsOut[2].cb));
         return VNET_ERROR;
@@ -1638 +1635 @@
     if (pElem->aSegsOut[1].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
     {
-        Log(("%s vnetControlMac: The unicast mac segment is too small (nMacs=%u cb=%u)\n",
+        Log(("%s vnetR3ControlMac: The unicast mac segment is too small (nMacs=%u cb=%u)\n",
              INSTANCE(pThis), nMacs, pElem->aSegsOut[1].cb));
         return VNET_ERROR;
@@ -1645 +1642 @@
     if (nMacs > VNET_MAC_FILTER_LEN)
     {
-        Log(("%s vnetControlMac: MAC table is too big, have to use promiscuous mode (nMacs=%u)\n", INSTANCE(pThis), nMacs));
+        Log(("%s vnetR3ControlMac: MAC table is too big, have to use promiscuous mode (nMacs=%u)\n", INSTANCE(pThis), nMacs));
         pThis->fPromiscuous = true;
     }
@@ -1656 +1653 @@
         pThis->nMacFilterEntries = nMacs;
 #ifdef DEBUG
-        Log(("%s vnetControlMac: unicast macs:\n", INSTANCE(pThis)));
+        Log(("%s vnetR3ControlMac: unicast macs:\n", INSTANCE(pThis)));
         for(unsigned i = 0; i < nMacs; i++)
             Log(("         %RTmac\n", &pThis->aMacFilter[i]));
@@ -1669 +1666 @@
     if (pElem->aSegsOut[2].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
     {
-        Log(("%s vnetControlMac: The multicast mac segment is too small (nMacs=%u cb=%u)\n",
+        Log(("%s vnetR3ControlMac: The multicast mac segment is too small (nMacs=%u cb=%u)\n",
              INSTANCE(pThis), nMacs, pElem->aSegsOut[2].cb));
         return VNET_ERROR;
@@ -1676 +1673 @@
     if (nMacs > VNET_MAC_FILTER_LEN - pThis->nMacFilterEntries)
     {
-        Log(("%s vnetControlMac: MAC table is too big, have to use allmulti mode (nMacs=%u)\n", INSTANCE(pThis), nMacs));
+        Log(("%s vnetR3ControlMac: MAC table is too big, have to use allmulti mode (nMacs=%u)\n", INSTANCE(pThis), nMacs));
         pThis->fAllMulti = true;
     }
@@ -1687 +1684 @@
                               nMacs * sizeof(RTMAC));
 #ifdef DEBUG
-        Log(("%s vnetControlMac: multicast macs:\n", INSTANCE(pThis)));
+        Log(("%s vnetR3ControlMac: multicast macs:\n", INSTANCE(pThis)));
         for(unsigned i = 0; i < nMacs; i++)
             Log(("         %RTmac\n",
@@ -1698 +1695 @@
 }
 
-static uint8_t vnetControlVlan(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+static uint8_t vnetR3ControlVlan(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint8_t  u8Ack = VNET_OK;
@@ -1705 +1702 @@
     if (pElem->nOut != 2 || pElem->aSegsOut[1].cb != sizeof(u16Vid))
     {
-        Log(("%s vnetControlVlan: Segment layout is wrong (u8Command=%u nOut=%u cb=%u)\n",
+        Log(("%s vnetR3ControlVlan: Segment layout is wrong (u8Command=%u nOut=%u cb=%u)\n",
              INSTANCE(pThis), pCtlHdr->u8Command, pElem->nOut, pElem->aSegsOut[1].cb));
         return VNET_ERROR;
@@ -1716 +1713 @@
     if (u16Vid >= VNET_MAX_VID)
     {
-        Log(("%s vnetControlVlan: VLAN ID is out of range (VID=%u)\n", INSTANCE(pThis), u16Vid));
+        Log(("%s vnetR3ControlVlan: VLAN ID is out of range (VID=%u)\n", INSTANCE(pThis), u16Vid));
         return VNET_ERROR;
     }
 
-    Log(("%s vnetControlVlan: uCommand=%u VID=%u\n", INSTANCE(pThis), pCtlHdr->u8Command, u16Vid));
+    Log(("%s vnetR3ControlVlan: uCommand=%u VID=%u\n", INSTANCE(pThis), pCtlHdr->u8Command, u16Vid));
 
     switch (pCtlHdr->u8Command)
@@ -1738 +1735 @@
 
 
-static DECLCALLBACK(void) vnetQueueControl(void *pvState, PVQUEUE pQueue)
+static DECLCALLBACK(void) vnetR3QueueControl(void *pvState, PVQUEUE pQueue)
 {
     PVNETSTATE pThis = (PVNETSTATE)pvState;
@@ -1747 +1744 @@
         if (elem.nOut < 1 || elem.aSegsOut[0].cb < sizeof(VNETCTLHDR))
         {
-            Log(("%s vnetQueueControl: The first 'out' segment is not the header! (%u < 1 || %u < %u).\n",
+            Log(("%s vnetR3QueueControl: The first 'out' segment is not the header! (%u < 1 || %u < %u).\n",
                  INSTANCE(pThis), elem.nOut, elem.aSegsOut[0].cb,sizeof(VNETCTLHDR)));
             break; /* Skip the element and hope the next one is good. */
         }
-        else if (   elem.nIn < 1
-                 || elem.aSegsIn[elem.nIn - 1].cb < sizeof(VNETCTLACK))
-        {
-            Log(("%s vnetQueueControl: The last 'in' segment is too small to hold the acknowledge! (%u < 1 || %u < %u).\n",
+        if (   elem.nIn < 1
+            || elem.aSegsIn[elem.nIn - 1].cb < sizeof(VNETCTLACK))
+        {
+            Log(("%s vnetR3QueueControl: The last 'in' segment is too small to hold the acknowledge! (%u < 1 || %u < %u).\n",
                  INSTANCE(pThis), elem.nIn, elem.aSegsIn[elem.nIn - 1].cb, sizeof(VNETCTLACK)));
             break; /* Skip the element and hope the next one is good. */
         }
-        else
-        {
-            VNETCTLHDR CtlHdr;
-            PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                              elem.aSegsOut[0].addr,
-                              &CtlHdr, sizeof(CtlHdr));
-            switch (CtlHdr.u8Class)
-            {
-                case VNET_CTRL_CLS_RX_MODE:
-                    u8Ack = vnetControlRx(pThis, &CtlHdr, &elem);
-                    break;
-                case VNET_CTRL_CLS_MAC:
-                    u8Ack = vnetControlMac(pThis, &CtlHdr, &elem);
-                    break;
-                case VNET_CTRL_CLS_VLAN:
-                    u8Ack = vnetControlVlan(pThis, &CtlHdr, &elem);
-                    break;
-                default:
-                    u8Ack = VNET_ERROR;
-            }
-            Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pThis), CtlHdr.u8Class, u8Ack));
-            PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns),
-                                  elem.aSegsIn[elem.nIn - 1].addr,
-                                  &u8Ack, sizeof(u8Ack));
-        }
+
+        VNETCTLHDR CtlHdr;
+        PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
+                          elem.aSegsOut[0].addr,
+                          &CtlHdr, sizeof(CtlHdr));
+        switch (CtlHdr.u8Class)
+        {
+            case VNET_CTRL_CLS_RX_MODE:
+                u8Ack = vnetR3ControlRx(pThis, &CtlHdr, &elem);
+                break;
+            case VNET_CTRL_CLS_MAC:
+                u8Ack = vnetR3ControlMac(pThis, &CtlHdr, &elem);
+                break;
+            case VNET_CTRL_CLS_VLAN:
+                u8Ack = vnetR3ControlVlan(pThis, &CtlHdr, &elem);
+                break;
+            default:
+                u8Ack = VNET_ERROR;
+        }
+        Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pThis), CtlHdr.u8Class, u8Ack));
+        PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns),
+                              elem.aSegsIn[elem.nIn - 1].addr,
+                              &u8Ack, sizeof(u8Ack));
+
         vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(u8Ack));
         vqueueSync(&pThis->VPCI, pQueue);
@@ -1794 +1790 @@
  * Saves the configuration.
  *
- * @param   pThis      The VNET state.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The VNET state.
  * @param   pSSM        The handle to the saved state.
  */
-static void vnetSaveConfig(PVNETSTATE pThis, PSSMHANDLE pSSM)
-{
-    SSMR3PutMem(pSSM, &pThis->macConfigured, sizeof(pThis->macConfigured));
+static void vnetR3SaveConfig(PPDMDEVINS pDevIns, PVNETSTATE pThis, PSSMHANDLE pSSM)
+{
+    pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->macConfigured, sizeof(pThis->macConfigured));
 }
 
@@ -1806 +1803 @@
  * @callback_method_impl{FNSSMDEVLIVEEXEC}
  */
-static DECLCALLBACK(int) vnetLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
-{
+static DECLCALLBACK(int) vnetR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
+{
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     RT_NOREF(uPass);
+    vnetR3SaveConfig(pDevIns, pThis, pSSM);
+    return VINF_SSM_DONT_CALL_AGAIN;
+}
+
+
+/**
+ * @callback_method_impl{FNSSMDEVSAVEPREP}
+ */
+static DECLCALLBACK(int) vnetR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    vnetSaveConfig(pThis, pSSM);
-    return VINF_SSM_DONT_CALL_AGAIN;
-}
-
-
-/**
- * @callback_method_impl{FNSSMDEVSAVEPREP}
- */
-static DECLCALLBACK(int) vnetSavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
     RT_NOREF(pSSM);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
 
     int rc = vnetCsRxEnter(pThis, VERR_SEM_BUSY);
-    if (RT_UNLIKELY(rc != VINF_SUCCESS))
-        return rc;
-    vnetCsRxLeave(pThis);
-    return VINF_SUCCESS;
+    if (RT_SUCCESS(rc))
+        vnetCsRxLeave(pThis);
+    return rc;
 }
 
@@ -1834 +1830 @@
  * @callback_method_impl{FNSSMDEVSAVEEXEC}
  */
-static DECLCALLBACK(int) vnetSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+static DECLCALLBACK(int) vnetR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
 
     /* Save config first */
-    vnetSaveConfig(pThis, pSSM);
+    vnetR3SaveConfig(pDevIns, pThis, pSSM);
 
     /* Save the common part */
     int rc = vpciSaveExec(&pThis->VPCI, pSSM);
     AssertRCReturn(rc, rc);
+
     /* Save device-specific part */
-    rc = SSMR3PutMem( pSSM, pThis->config.mac.au8, sizeof(pThis->config.mac));
+    pHlp->pfnSSMPutMem(     pSSM, pThis->config.mac.au8, sizeof(pThis->config.mac));
+    pHlp->pfnSSMPutBool(    pSSM, pThis->fPromiscuous);
+    pHlp->pfnSSMPutBool(    pSSM, pThis->fAllMulti);
+    pHlp->pfnSSMPutU32(     pSSM, pThis->nMacFilterEntries);
+    pHlp->pfnSSMPutMem(     pSSM, pThis->aMacFilter, pThis->nMacFilterEntries * sizeof(RTMAC));
+    rc = pHlp->pfnSSMPutMem(pSSM, pThis->aVlanFilter, sizeof(pThis->aVlanFilter));
     AssertRCReturn(rc, rc);
-    rc = SSMR3PutBool(pSSM, pThis->fPromiscuous);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutBool(pSSM, pThis->fAllMulti);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutU32( pSSM, pThis->nMacFilterEntries);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutMem( pSSM, pThis->aMacFilter,
-                      pThis->nMacFilterEntries * sizeof(RTMAC));
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutMem( pSSM, pThis->aVlanFilter, sizeof(pThis->aVlanFilter));
-    AssertRCReturn(rc, rc);
+
     Log(("%s State has been saved\n", INSTANCE(pThis)));
     return VINF_SUCCESS;
@@ -1864 +1857 @@
 
 /**
- * @callback_method_impl{FNSSMDEVLOADPREP, Serializes the receive thread, it may
- *                      be working inside the critsect. }
- */
-static DECLCALLBACK(int) vnetLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
+ * @callback_method_impl{FNSSMDEVLOADPREP,
+ * Serializes the receive thread - it may be working inside the critsect. }
+ */
+static DECLCALLBACK(int) vnetR3LoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     RT_NOREF(pSSM);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
 
     int rc = vnetCsRxEnter(pThis, VERR_SEM_BUSY);
-    if (RT_UNLIKELY(rc != VINF_SUCCESS))
-        return rc;
-    vnetCsRxLeave(pThis);
-    return VINF_SUCCESS;
+    if (RT_SUCCESS(rc))
+        vnetCsRxLeave(pThis);
+    return rc;
 }
 
@@ -1883 +1875 @@
  * @callback_method_impl{FNSSMDEVLOADEXEC}
  */
-static DECLCALLBACK(int) vnetLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    int       rc;
+static DECLCALLBACK(int) vnetR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+{
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
 
     /* config checks */
     RTMAC macConfigured;
-    rc = SSMR3GetMem(pSSM, &macConfigured, sizeof(macConfigured));
+    int rc = pHlp->pfnSSMGetMem(pSSM, &macConfigured, sizeof(macConfigured));
     AssertRCReturn(rc, rc);
     if (memcmp(&macConfigured, &pThis->macConfigured, sizeof(macConfigured))
@@ -1901 +1893 @@
     if (uPass == SSM_PASS_FINAL)
     {
-        rc = SSMR3GetMem( pSSM, pThis->config.mac.au8,
-                          sizeof(pThis->config.mac));
+        rc = pHlp->pfnSSMGetMem( pSSM, pThis->config.mac.au8, sizeof(pThis->config.mac));
         AssertRCReturn(rc, rc);
 
         if (uVersion > VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1)
         {
-            rc = SSMR3GetBool(pSSM, &pThis->fPromiscuous);
-            AssertRCReturn(rc, rc);
-            rc = SSMR3GetBool(pSSM, &pThis->fAllMulti);
-            AssertRCReturn(rc, rc);
-            rc = SSMR3GetU32(pSSM, &pThis->nMacFilterEntries);
-            AssertRCReturn(rc, rc);
-            rc = SSMR3GetMem(pSSM, pThis->aMacFilter,
-                             pThis->nMacFilterEntries * sizeof(RTMAC));
-            AssertRCReturn(rc, rc);
+            pHlp->pfnSSMGetBool(pSSM, &pThis->fPromiscuous);
+            pHlp->pfnSSMGetBool(pSSM, &pThis->fAllMulti);
+            pHlp->pfnSSMGetU32(pSSM, &pThis->nMacFilterEntries);
+            pHlp->pfnSSMGetMem(pSSM, pThis->aMacFilter, pThis->nMacFilterEntries * sizeof(RTMAC));
+
             /* Clear the rest. */
             if (pThis->nMacFilterEntries < VNET_MAC_FILTER_LEN)
                 memset(&pThis->aMacFilter[pThis->nMacFilterEntries],
                        0,
-                       (VNET_MAC_FILTER_LEN - pThis->nMacFilterEntries)
-                       * sizeof(RTMAC));
-            rc = SSMR3GetMem(pSSM, pThis->aVlanFilter,
-                             sizeof(pThis->aVlanFilter));
+                       (VNET_MAC_FILTER_LEN - pThis->nMacFilterEntries) * sizeof(RTMAC));
+            rc = pHlp->pfnSSMGetMem(pSSM, pThis->aVlanFilter, sizeof(pThis->aVlanFilter));
             AssertRCReturn(rc, rc);
         }
@@ -1946 +1931 @@
  *                      loading.}
  */
-static DECLCALLBACK(int) vnetLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) vnetR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
     RT_NOREF(pSSM);
@@ -1959 +1944 @@
      */
     if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
-        vnetTempLinkDown(pThis);
+        vnetR3TempLinkDown(pThis);
 
     return VINF_SUCCESS;
@@ -1970 +1955 @@
  * @callback_method_impl{FNPCIIOREGIONMAP}
  */
-static DECLCALLBACK(int) vnetMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
-                                 RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
+static DECLCALLBACK(int) vnetR3Map(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
+                                   RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
 {
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
@@ -2005 +1990 @@
 
 /**
- * @interface_method_impl{PDMDEVREG,pfnDetach}
- */
-static DECLCALLBACK(void) vnetDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
+ * @interface_method_impl{PDMDEVREGR3,pfnDetach}
+ */
+static DECLCALLBACK(void) vnetR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
     RT_NOREF(fFlags);
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    Log(("%s vnetDetach:\n", INSTANCE(pThis)));
+    Log(("%s vnetR3Detach:\n", INSTANCE(pThis)));
 
     AssertLogRelReturnVoid(iLUN == 0);
 
-    int rc = vnetCsEnter(pThis, VERR_SEM_BUSY);
+    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
     if (RT_FAILURE(rc))
     {
-        LogRel(("vnetDetach failed to enter critical section!\n"));
+        LogRel(("vnetR3Detach failed to enter critical section!\n"));
         return;
     }
 
-    vnetDestroyTxThreadAndEvent(pThis);
+    vnetR3DestroyTxThreadAndEvent(pThis);
     /*
      * Zero some important members.
@@ -2029 +2014 @@
     pThis->pDrv = NULL;
 
-    vnetCsLeave(pThis);
-}
-
-
-/**
- * @interface_method_impl{PDMDEVREG,pfnAttach}
- */
-static DECLCALLBACK(int) vnetAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
+    vnetR3CsLeave(pThis);
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVREGR3,pfnAttach}
+ */
+static DECLCALLBACK(int) vnetR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
     RT_NOREF(fFlags);
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    LogFlow(("%s vnetAttach:\n",  INSTANCE(pThis)));
+    LogFlow(("%s vnetR3Attach:\n",  INSTANCE(pThis)));
 
     AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
 
-    int rc = vnetCsEnter(pThis, VERR_SEM_BUSY);
+    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
     if (RT_FAILURE(rc))
     {
-        LogRel(("vnetAttach failed to enter critical section!\n"));
+        LogRel(("vnetR3Attach failed to enter critical section!\n"));
         return rc;
     }
@@ -2071 +2056 @@
                       rc = VERR_PDM_MISSING_INTERFACE_BELOW);
 
-        vnetCreateTxThreadAndEvent(pDevIns, pThis);
+        vnetR3CreateTxThreadAndEvent(pDevIns, pThis);
     }
     else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
@@ -2087 +2072 @@
      */
     if (RT_SUCCESS(rc))
-        vnetTempLinkDown(pThis);
-
-    vnetCsLeave(pThis);
+        vnetR3TempLinkDown(pThis);
+
+    vnetR3CsLeave(pThis);
     return rc;
 
@@ -2096 +2081 @@
 
 /**
- * @interface_method_impl{PDMDEVREG,pfnSuspend}
- */
-static DECLCALLBACK(void) vnetSuspend(PPDMDEVINS pDevIns)
+ * @interface_method_impl{PDMDEVREGR3,pfnSuspend}
+ */
+static DECLCALLBACK(void) vnetR3Suspend(PPDMDEVINS pDevIns)
 {
     /* Poke thread waiting for buffer space. */
-    vnetWakeupReceive(pDevIns);
-}
-
-
-/**
- * @interface_method_impl{PDMDEVREG,pfnPowerOff}
- */
-static DECLCALLBACK(void) vnetPowerOff(PPDMDEVINS pDevIns)
+    vnetR3WakeupReceive(pDevIns);
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVREGR3,pfnPowerOff}
+ */
+static DECLCALLBACK(void) vnetR3PowerOff(PPDMDEVINS pDevIns)
 {
     /* Poke thread waiting for buffer space. */
-    vnetWakeupReceive(pDevIns);
-}
-
-
-/**
- * @interface_method_impl{PDMDEVREG,pfnRelocate}
- */
-static DECLCALLBACK(void) vnetRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
+    vnetR3WakeupReceive(pDevIns);
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVREGR3,pfnRelocate}
+ */
+static DECLCALLBACK(void) vnetR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
@@ -2131 +2116 @@
 
 /**
- * @interface_method_impl{PDMDEVREG,pfnDestruct}
- */
-static DECLCALLBACK(int) vnetDestruct(PPDMDEVINS pDevIns)
+ * @interface_method_impl{PDMDEVREGR3,pfnDestruct}
+ */
+static DECLCALLBACK(int) vnetR3Destruct(PPDMDEVINS pDevIns)
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
@@ -2158 +2143 @@
 
 /**
- * @interface_method_impl{PDMDEVREG,pfnConstruct}
- */
-static DECLCALLBACK(int) vnetConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
+ * @interface_method_impl{PDMDEVREGR3,pfnConstruct}
+ */
+static DECLCALLBACK(int) vnetR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
 {
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    int        rc;
-
-    /* Initialize the instance data suffiencently for the destructor not to blow up. */
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
+    int             rc;
+
+    /*
+     * Initialize the instance data suffiencently for the destructor not to blow up.
+     */
     pThis->hEventMoreRxDescAvail = NIL_RTSEMEVENT;
 
@@ -2175 +2163 @@
     /* Initialize PCI part. */
     pThis->VPCI.IBase.pfnQueryInterface    = vnetQueryInterface;
-    rc = vpciConstruct(pDevIns, &pThis->VPCI, iInstance,
-                       VNET_NAME_FMT, VIRTIO_NET_ID,
-                       VNET_PCI_CLASS, VNET_N_QUEUES);
-    pThis->pRxQueue  = vpciAddQueue(&pThis->VPCI, 256, vnetQueueReceive,  "RX ");
-    pThis->pTxQueue  = vpciAddQueue(&pThis->VPCI, 256, vnetQueueTransmit, "TX ");
-    pThis->pCtlQueue = vpciAddQueue(&pThis->VPCI, 16,  vnetQueueControl,  "CTL");
+
+    rc = vpciConstruct(pDevIns, &pThis->VPCI, iInstance, VNET_NAME_FMT, VIRTIO_NET_ID, VNET_PCI_CLASS, VNET_N_QUEUES);
+    AssertRCReturn(rc, rc);
+
+    pThis->pRxQueue  = vpciAddQueue(&pThis->VPCI, 256, vnetR3QueueReceive,  "RX ");
+    pThis->pTxQueue  = vpciAddQueue(&pThis->VPCI, 256, vnetR3QueueTransmit, "TX ");
+    pThis->pCtlQueue = vpciAddQueue(&pThis->VPCI, 16,  vnetR3QueueControl,  "CTL");
 
     Log(("%s Constructing new instance\n", INSTANCE(pThis)));
@@ -2187 +2176 @@
      * Validate configuration.
      */
-    if (!CFGMR3AreValuesValid(pCfg, "MAC\0" "CableConnected\0" "LineSpeed\0" "LinkUpDelay\0"))
-        return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES, N_("Invalid configuration for VirtioNet device"));
+    PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "MAC|CableConnected|LineSpeed|LinkUpDelay", "");
 
     /* Get config params */
-    rc = CFGMR3QueryBytes(pCfg, "MAC", pThis->macConfigured.au8,
-                          sizeof(pThis->macConfigured));
+    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"));
-    rc = CFGMR3QueryBool(pCfg, "CableConnected", &pThis->fCableConnected);
+        return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get MAC address"));
+    rc = pHlp->pfnCFGMQueryBool(pCfg, "CableConnected", &pThis->fCableConnected);
     if (RT_FAILURE(rc))
-        return PDMDEV_SET_ERROR(pDevIns, rc,
-                                N_("Configuration error: Failed to get the value of 'CableConnected'"));
-    rc = CFGMR3QueryU32Def(pCfg, "LinkUpDelay", (uint32_t*)&pThis->cMsLinkUpDelay, 5000); /* ms */
+        return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the value of 'CableConnected'"));
+    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'"));
+        return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the value of 'LinkUpDelay'"));
     Assert(pThis->cMsLinkUpDelay <= 300000); /* less than 5 minutes */
     if (pThis->cMsLinkUpDelay > 5000 || pThis->cMsLinkUpDelay < 100)
-    {
         LogRel(("%s WARNING! Link up delay is set to %u seconds!\n",
                 INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
-    }
     Log(("%s Link up delay is set to %u seconds\n",
          INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
-
 
     vnetPrintFeatures(pThis, vnetIoCb_GetHostFeatures(pThis), "Device supports the following features");
@@ -2224 +2205 @@
 
     /* Interfaces */
-    pThis->INetworkDown.pfnWaitReceiveAvail = vnetNetworkDown_WaitReceiveAvail;
-    pThis->INetworkDown.pfnReceive          = vnetNetworkDown_Receive;
-    pThis->INetworkDown.pfnReceiveGso       = vnetNetworkDown_ReceiveGso;
-    pThis->INetworkDown.pfnXmitPending      = vnetNetworkDown_XmitPending;
-
-    pThis->INetworkConfig.pfnGetMac         = vnetGetMac;
-    pThis->INetworkConfig.pfnGetLinkState   = vnetGetLinkState;
-    pThis->INetworkConfig.pfnSetLinkState   = vnetSetLinkState;
+    pThis->INetworkDown.pfnWaitReceiveAvail = vnetR3NetworkDown_WaitReceiveAvail;
+    pThis->INetworkDown.pfnReceive          = vnetR3NetworkDown_Receive;
+    pThis->INetworkDown.pfnReceiveGso       = vnetR3NetworkDown_ReceiveGso;
+    pThis->INetworkDown.pfnXmitPending      = vnetR3NetworkDown_XmitPending;
+
+    pThis->INetworkConfig.pfnGetMac         = vnetR3NetworkConfig_GetMac;
+    pThis->INetworkConfig.pfnGetLinkState   = vnetR3NetworkConfig_GetLinkState;
+    pThis->INetworkConfig.pfnSetLinkState   = vnetR3NetworkConfig_SetLinkState;
 
     /* Initialize critical section. */
@@ -2241 +2222 @@
 
     /* Map our ports to IO space. */
-    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0,
-                                      VPCI_CONFIG + sizeof(VNetPCIConfig),
-                                      PCI_ADDRESS_SPACE_IO, vnetMap);
-    if (RT_FAILURE(rc))
-        return rc;
-
+    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, VPCI_CONFIG + sizeof(VNetPCIConfig), PCI_ADDRESS_SPACE_IO, vnetR3Map);
+    AssertRCReturn(rc, rc);
 
     /* Register save/restore state handlers. */
     rc = PDMDevHlpSSMRegisterEx(pDevIns, VIRTIO_SAVEDSTATE_VERSION, sizeof(VNETSTATE), NULL,
-                                NULL,         vnetLiveExec, NULL,
-                                vnetSavePrep, vnetSaveExec, NULL,
-                                vnetLoadPrep, vnetLoadExec, vnetLoadDone);
-    if (RT_FAILURE(rc))
-        return rc;
+                                NULL,           vnetR3LiveExec, NULL,
+                                vnetR3SavePrep, vnetR3SaveExec, NULL,
+                                vnetR3LoadPrep, vnetR3LoadExec, vnetR3LoadDone);
+    AssertRCReturn(rc, rc);
 
     /* Create the RX notifier signaller. */
     rc = PDMDevHlpQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
-                              vnetCanRxQueueConsumer, true, "VNet-Rcv", &pThis->pCanRxQueueR3);
-    if (RT_FAILURE(rc))
-        return rc;
+                              vnetR3CanRxQueueConsumer, true, "VNet-Rcv", &pThis->pCanRxQueueR3);
+    AssertRCReturn(rc, rc);
     pThis->pCanRxQueueR0 = PDMQueueR0Ptr(pThis->pCanRxQueueR3);
     pThis->pCanRxQueueRC = PDMQueueRCPtr(pThis->pCanRxQueueR3);
 
     /* Create Link Up Timer */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetLinkUpTimer, pThis,
-                                TMTIMER_FLAGS_NO_CRIT_SECT,
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
                                 "VirtioNet Link Up Timer", &pThis->pLinkUpTimer);
-    if (RT_FAILURE(rc))
-        return rc;
+    AssertRCReturn(rc, rc);
 
 #ifndef VNET_TX_DELAY
@@ -2277 +2250 @@
 #else /* VNET_TX_DELAY */
     /* Create Transmit Delay Timer */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetTxTimer, pThis,
-                                TMTIMER_FLAGS_NO_CRIT_SECT,
+    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
                                 "VirtioNet TX Delay Timer", &pThis->pTxTimerR3);
-    if (RT_FAILURE(rc))
-        return rc;
+    AssertRCReturn(rc, rc);
     pThis->pTxTimerR0 = TMTimerR0Ptr(pThis->pTxTimerR3);
     pThis->pTxTimerRC = TMTimerRCPtr(pThis->pTxTimerR3);
@@ -2301 +2272 @@
                         VERR_PDM_MISSING_INTERFACE_BELOW);
 
-        vnetCreateTxThreadAndEvent(pDevIns, pThis);
+        vnetR3CreateTxThreadAndEvent(pDevIns, pThis);
     }
     else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
@@ -2313 +2284 @@
 
     rc = RTSemEventCreate(&pThis->hEventMoreRxDescAvail);
-    if (RT_FAILURE(rc))
-        return rc;
+    AssertRCReturn(rc, rc);
 
     rc = vnetIoCb_Reset(pThis);
-    AssertRC(rc);
+    AssertRCReturn(rc, rc);
 
     PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveBytes,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data received",            "/Public/Net/VNet%u/BytesReceived", iInstance);
     PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitBytes,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data transmitted",         "/Public/Net/VNet%u/BytesTransmitted", iInstance);
 
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveBytes,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data received",            "/Devices/VNet%d/ReceiveBytes", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitBytes,      STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,          "Amount of data transmitted",         "/Devices/VNet%d/TransmitBytes", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveGSO,         STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Number of received GSO packets",     "/Devices/VNet%d/Packets/ReceiveGSO", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitPackets,    STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Number of sent packets",             "/Devices/VNet%d/Packets/Transmit", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitGSO,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Number of sent GSO packets",         "/Devices/VNet%d/Packets/Transmit-Gso", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitCSum,       STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Number of completed TX checksums",   "/Devices/VNet%d/Packets/Transmit-Csum", iInstance);
-#if defined(VBOX_WITH_STATISTICS)
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceive,            STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive",                  "/Devices/VNet%d/Receive/Total", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatReceiveStore,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive storing",          "/Devices/VNet%d/Receive/Store", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflow,         STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows",        "/Devices/VNet%d/RxOverflow", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatRxOverflowWakeup,   STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Nr of RX overflow wakeups",          "/Devices/VNet%d/RxOverflowWakeup", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmit,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in HC",          "/Devices/VNet%d/Transmit/Total", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitSend,       STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling send transmit in HC",      "/Devices/VNet%d/Transmit/Send", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitByNetwork,  STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Network-initiated transmissions",    "/Devices/VNet%d/Transmit/ByNetwork", iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatTransmitByThread,   STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,          "Thread-initiated transmissions",     "/Devices/VNet%d/Transmit/ByThread", iInstance);
-#endif /* VBOX_WITH_STATISTICS */
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatReceiveBytes,        STAMTYPE_COUNTER, "ReceiveBytes",           STAMUNIT_BYTES,          "Amount of data received");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitBytes,       STAMTYPE_COUNTER, "TransmitBytes",          STAMUNIT_BYTES,          "Amount of data transmitted");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatReceiveGSO,          STAMTYPE_COUNTER, "Packets/ReceiveGSO",     STAMUNIT_COUNT,          "Number of received GSO packets");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitPackets,     STAMTYPE_COUNTER, "Packets/Transmit",       STAMUNIT_COUNT,          "Number of sent packets");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitGSO,         STAMTYPE_COUNTER, "Packets/Transmit-Gso",   STAMUNIT_COUNT,          "Number of sent GSO packets");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitCSum,        STAMTYPE_COUNTER, "Packets/Transmit-Csum",  STAMUNIT_COUNT,          "Number of completed TX checksums");
+# ifdef VBOX_WITH_STATISTICS
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatReceive,             STAMTYPE_PROFILE, "Receive/Total",          STAMUNIT_TICKS_PER_CALL, "Profiling receive");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatReceiveStore,        STAMTYPE_PROFILE, "Receive/Store",          STAMUNIT_TICKS_PER_CALL, "Profiling receive storing");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatRxOverflow,          STAMTYPE_PROFILE, "RxOverflow",             STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatRxOverflowWakeup,    STAMTYPE_COUNTER, "RxOverflowWakeup",       STAMUNIT_OCCURENCES,     "Nr of RX overflow wakeups");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmit,            STAMTYPE_PROFILE, "Transmit/Total",         STAMUNIT_TICKS_PER_CALL, "Profiling transmits in HC");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitSend,        STAMTYPE_PROFILE, "Transmit/Send",          STAMUNIT_TICKS_PER_CALL, "Profiling send transmit in HC");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitByNetwork,   STAMTYPE_COUNTER, "Transmit/ByNetwork",     STAMUNIT_COUNT,          "Network-initiated transmissions");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTransmitByThread,    STAMTYPE_COUNTER, "Transmit/ByThread",      STAMUNIT_COUNT,          "Thread-initiated transmissions");
+# endif
 
     return VINF_SUCCESS;
@@ -2369 +2339 @@
     /* .pszRCMod = */               "VBoxDDRC.rc",
     /* .pszR0Mod = */               "VBoxDDR0.r0",
-    /* .pfnConstruct = */           vnetConstruct,
-    /* .pfnDestruct = */            vnetDestruct,
-    /* .pfnRelocate = */            vnetRelocate,
+    /* .pfnConstruct = */           vnetR3Construct,
+    /* .pfnDestruct = */            vnetR3Destruct,
+    /* .pfnRelocate = */            vnetR3Relocate,
     /* .pfnMemSetup = */            NULL,
     /* .pfnPowerOn = */             NULL,
     /* .pfnReset = */               NULL,
-    /* .pfnSuspend = */             vnetSuspend,
+    /* .pfnSuspend = */             vnetR3Suspend,
     /* .pfnResume = */              NULL,
-    /* .pfnAttach = */              vnetAttach,
-    /* .pfnDetach = */              vnetDetach,
+    /* .pfnAttach = */              vnetR3Attach,
+    /* .pfnDetach = */              vnetR3Detach,
     /* .pfnQueryInterface = */      NULL,
     /* .pfnInitComplete = */        NULL,
-    /* .pfnPowerOff = */            vnetPowerOff,
+    /* .pfnPowerOff = */            vnetR3PowerOff,
     /* .pfnSoftReset = */           NULL,
     /* .pfnReserved0 = */           NULL,