Changeset 81720 in vbox for trunk/src/VBox

Timestamp:

Nov 6, 2019 8:23:17 PM (5 years ago)

Author:

vboxsync

Message:

DevVirtioNet,Virtio: Converted to new PDM device model. bugref:9218

Location:

trunk/src/VBox/Devices

Files:

• Network/DevVirtioNet.cpp (modified) (99 diffs)
• VirtIO/Virtio.cpp (modified) (29 diffs)
• VirtIO/Virtio.h (modified) (5 diffs)

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

@@ -21 +21 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DEV_VIRTIO_NET
-#define VNET_GC_SUPPORT
 #define VNET_WITH_GSO
 #define VNET_WITH_MERGEABLE_RX_BUFS
@@ -32 +31 @@
 #include <iprt/string.h>
 #ifdef IN_RING3
-# include <iprt/mem.h>
 # include <iprt/uuid.h>
 #endif
@@ -46 +44 @@
 
 #define INSTANCE(pThis) pThis->VPCI.szInstance
-#define STATUS pThis->config.uStatus
 
 #ifdef IN_RING3
@@ -52 +49 @@
 # define VNET_PCI_CLASS              0x0200
 # define VNET_N_QUEUES               3
-# define VNET_NAME_FMT               "VNet%d"
 
 # if 0
@@ -58 +54 @@
 #  define VNET_PCI_CLASS             0x0180
 #  define VNET_N_QUEUES              2
-#  define VNET_NAME_FMT              "VBlk%d"
 # endif
 
@@ -113 +108 @@
 
 /**
- * Device state structure. Holds the current state of device.
+ * The virtio-net shared instance data.
  *
  * @extends     VPCISTATE
- * @implements  PDMINETWORKDOWN
- * @implements  PDMINETWORKCONFIG
- */
-typedef struct VNetState_st
-{
-    /* VPCISTATE must be the first member! */
+ */
+typedef struct VNETSTATE
+{
     VPCISTATE               VPCI;
 
 //    PDMCRITSECT             csRx;                           /**< Protects RX queue. */
 
-    PDMINETWORKDOWN         INetworkDown;
-    PDMINETWORKCONFIG       INetworkConfig;
-    R3PTRTYPE(PPDMIBASE)    pDrvBase;                 /**< Attached network driver. */
-    R3PTRTYPE(PPDMINETWORKUP) pDrv;    /**< Connector of attached network driver. */
-
-    /**< Link Up(/Restore) Timer. */
-    PTMTIMERR3              pLinkUpTimer;
-
 #ifdef VNET_TX_DELAY
-    /**< Transmit Delay Timer - R3. */
-    PTMTIMERR3              pTxTimerR3;
-    /**< Transmit Delay Timer - R0. */
-    PTMTIMERR0              pTxTimerR0;
-    /**< Transmit Delay Timer - GC. */
-    PTMTIMERRC              pTxTimerRC;
-
-# if HC_ARCH_BITS == 64
-    uint32_t                padding2;
-# endif
-
+    /** Transmit Delay Timer. */
+    TMTIMERHANDLE           hTxTimer;
     uint32_t                u32i;
     uint32_t                u32AvgDiff;
@@ -151 +126 @@
     uint32_t                u32MaxDiff;
     uint64_t                u64NanoTS;
-#else /* !VNET_TX_DELAY */
-    /** The support driver session handle. */
-    R3R0PTRTYPE(PSUPDRVSESSION)     pSupDrvSession;
+#else  /* !VNET_TX_DELAY */
     /** The event semaphore TX thread waits on. */
-    SUPSEMEVENT                     hTxEvent;
-    R3PTRTYPE(PPDMTHREAD)           pTxThread;
+    SUPSEMEVENT             hTxEvent;
 #endif /* !VNET_TX_DELAY */
 
@@ -184 +156 @@
     bool                    fAllMulti;
     /** The number of actually used slots in aMacTable. */
-    uint32_t                nMacFilterEntries;
+    uint32_t                cMacFilterEntries;
     /** Array of MAC addresses accepted by RX filter. */
     RTMAC                   aMacFilter[VNET_MAC_FILTER_LEN];
@@ -190 +162 @@
     uint8_t                 aVlanFilter[VNET_MAX_VID / sizeof(uint8_t)];
 
-    R3PTRTYPE(PVQUEUE)      pRxQueue;
-    R3PTRTYPE(PVQUEUE)      pTxQueue;
-    R3PTRTYPE(PVQUEUE)      pCtlQueue;
     /* 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
@@ -218 +190 @@
     /** @}  */
 } VNETSTATE;
-/** Pointer to a virtual I/O network device state. */
+/** Pointer to the virtio-net shared instance data. */
 typedef VNETSTATE *PVNETSTATE;
+
+
+/**
+ * The virtio-net ring-3 instance data.
+ *
+ * @extends     VPCISTATER3
+ * @implements  PDMINETWORKDOWN
+ * @implements  PDMINETWORKCONFIG
+ */
+typedef struct VNETSTATER3
+{
+    VPCISTATER3             VPCI;
+
+    PDMINETWORKDOWN         INetworkDown;
+    PDMINETWORKCONFIG       INetworkConfig;
+    R3PTRTYPE(PPDMIBASE)    pDrvBase;                 /**< Attached network driver. */
+    R3PTRTYPE(PPDMINETWORKUP) pDrv;    /**< Connector of attached network driver. */
+    /** The device instance.
+     * @note This is _only_ for use when dealing with interface callbacks. */
+    PPDMDEVINSR3            pDevIns;
+
+#ifndef VNET_TX_DELAY
+    R3PTRTYPE(PPDMTHREAD)   pTxThread;
+#endif
+
+    R3PTRTYPE(PVQUEUE)      pRxQueue;
+    R3PTRTYPE(PVQUEUE)      pTxQueue;
+    R3PTRTYPE(PVQUEUE)      pCtlQueue;
+
+    /** Link Up(/Restore) Timer. */
+    TMTIMERHANDLE           hLinkUpTimer;
+} VNETSTATER3;
+/** Pointer to the virtio-net ring-3 instance data. */
+typedef VNETSTATER3 *PVNETSTATER3;
+
+
+/**
+ * The virtio-net ring-0 instance data.
+ *
+ * @extends     VPCISTATER0
+ */
+typedef struct VNETSTATER0
+{
+    VPCISTATER0             VPCI;
+} VNETSTATER0;
+/** Pointer to the virtio-net ring-0 instance data. */
+typedef VNETSTATER0 *PVNETSTATER0;
+
+
+/**
+ * The virtio-net raw-mode instance data.
+ *
+ * @extends     VPCISTATERC
+ */
+typedef struct VNETSTATERC
+{
+    VPCISTATERC             VPCI;
+} VNETSTATERC;
+/** Pointer to the virtio-net ring-0 instance data. */
+typedef VNETSTATERC *PVNETSTATERC;
+
+
+/** The virtio-net currenct context instance data. */
+typedef CTX_SUFF(VNETSTATE) VNETSTATECC;
+/** Pointer to the virtio-net currenct context instance data. */
+typedef CTX_SUFF(PVNETSTATE) PVNETSTATECC;
+
+
 
 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
@@ -289 +329 @@
 }
 
-DECLINLINE(int) vnetR3CsEnter(PVNETSTATE pThis, int rcBusy)
-{
-    return vpciCsEnter(&pThis->VPCI, rcBusy);
-}
-
-DECLINLINE(void) vnetR3CsLeave(PVNETSTATE pThis)
-{
-    vpciCsLeave(&pThis->VPCI);
+DECLINLINE(int) vnetR3CsEnter(PPDMDEVINS pDevIns, PVNETSTATE pThis, int rcBusy)
+{
+    return vpciCsEnter(pDevIns, &pThis->VPCI, rcBusy);
+}
+
+DECLINLINE(void) vnetR3CsLeave(PPDMDEVINS pDevIns, PVNETSTATE pThis)
+{
+    vpciCsLeave(pDevIns, &pThis->VPCI);
 }
 
@@ -322 +362 @@
  * Dump a packet to debug log.
  *
- * @param   pThis       The device state structure.
+ * @param   pThis       The virtio-net shared instance data.
  * @param   pbPacket    The packet.
  * @param   cb          The size of the packet.
@@ -346 +386 @@
  * Print features given in uFeatures to debug log.
  *
- * @param   pThis      The device state structure.
+ * @param   pThis      The virtio-net shared instance data.
  * @param   fFeatures   Descriptions of which features to print.
  * @param   pcszText    A string to print before the list of features.
@@ -482 +522 @@
  * Hardware reset. Revert all registers to initial values.
  */
-static DECLCALLBACK(int) vnetIoCb_Reset(PVPCISTATE pVPciState)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
+static DECLCALLBACK(int) vnetIoCb_Reset(PPDMDEVINS pDevIns)
+{
+    PVNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+#ifdef IN_RING3
+    PVNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+#endif
     Log(("%s Reset triggered\n", INSTANCE(pThis)));
 
@@ -493 +536 @@
         return rc;
     }
-    vpciReset(&pThis->VPCI);
+    vpciReset(pDevIns, &pThis->VPCI);
     vnetCsRxLeave(pThis);
 
     /// @todo Implement reset
     if (pThis->fCableConnected)
-        STATUS = VNET_S_LINK_UP;
+        pThis->config.uStatus = VNET_S_LINK_UP;
     else
-        STATUS = 0;
+        pThis->config.uStatus = 0;
     Log(("%s vnetIoCb_Reset: Link is %s\n", INSTANCE(pThis), pThis->fCableConnected ? "up" : "down"));
 
@@ -509 +552 @@
     pThis->fPromiscuous      = true;
     pThis->fAllMulti         = false;
-    pThis->nMacFilterEntries = 0;
+    pThis->cMacFilterEntries = 0;
     memset(pThis->aMacFilter,  0, VNET_MAC_FILTER_LEN * sizeof(RTMAC));
     memset(pThis->aVlanFilter, 0, sizeof(pThis->aVlanFilter));
@@ -516 +559 @@
     return VINF_IOM_R3_IOPORT_WRITE;
 #else
-    if (pThis->pDrv)
-        pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv, true);
+    if (pThisCC->pDrv)
+        pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, true);
     return VINF_SUCCESS;
 #endif
@@ -544 +587 @@
  * Helper function that raises an interrupt if the guest is ready to receive it.
  */
-static int vnetR3RaiseInterrupt(PVNETSTATE pThis, int rcBusy, uint8_t u8IntCause)
+static int vnetR3RaiseInterrupt(PPDMDEVINS pDevIns, PVNETSTATE pThis, int rcBusy, uint8_t u8IntCause)
 {
     if (pThis->VPCI.uStatus & VPCI_STATUS_DRV_OK)
-        return vpciRaiseInterrupt(&pThis->VPCI, rcBusy, u8IntCause);
+        return vpciRaiseInterrupt(pDevIns, &pThis->VPCI, rcBusy, u8IntCause);
     return rcBusy;
 }
@@ -561 +604 @@
  * renegotiate any DHCP lease.
  *
- * @param  pThis        The Virtual I/O network device state.
- */
-static void vnetR3TempLinkDown(PVNETSTATE pThis)
-{
-    if (STATUS & VNET_S_LINK_UP)
-    {
-        STATUS &= ~VNET_S_LINK_UP;
-        vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The virtio-net shared instance data.
+ * @param   pThisCC     The virtio-net ring-3 instance data.
+ */
+static void vnetR3TempLinkDown(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
+{
+    if (pThis->config.uStatus & VNET_S_LINK_UP)
+    {
+        pThis->config.uStatus &= ~VNET_S_LINK_UP;
+        vnetR3RaiseInterrupt(pDevIns, pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
         /* Restore the link back in 5 seconds. */
-        int rc = TMTimerSetMillies(pThis->pLinkUpTimer, pThis->cMsLinkUpDelay);
+        int rc = PDMDevHlpTimerSetMillies(pDevIns, pThisCC->hLinkUpTimer, pThis->cMsLinkUpDelay);
         AssertRC(rc);
         Log(("%s vnetR3TempLinkDown: Link is down temporarily\n", INSTANCE(pThis)));
@@ -582 +627 @@
 static DECLCALLBACK(void) vnetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
-    RT_NOREF(pTimer);
-    PVNETSTATE pThis = (PVNETSTATE)pvUser;
-
-    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
-    if (RT_UNLIKELY(rc != VINF_SUCCESS))
-        return;
-    STATUS |= VNET_S_LINK_UP;
-    vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+    PVNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+    RT_NOREF(pTimer, pvUser);
+
+    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
+    AssertRCReturnVoid(rc);
+
+    pThis->config.uStatus |= VNET_S_LINK_UP;
+    vnetR3RaiseInterrupt(pDevIns, pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
     vnetWakeupReceive(pDevIns);
-    vnetR3CsLeave(pThis);
+
+    vnetR3CsLeave(pDevIns, pThis);
+
     Log(("%s vnetR3LinkUpTimer: Link is up\n", INSTANCE(pThis)));
-    if (pThis->pDrv)
-        pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, PDMNETWORKLINKSTATE_UP);
+    if (pThisCC->pDrv)
+        pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, PDMNETWORKLINKSTATE_UP);
 }
 
@@ -604 +652 @@
  * This function is called when the driver becomes ready.
  */
-static DECLCALLBACK(void) vnetIoCb_Ready(PVPCISTATE pVPciState)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
-    Log(("%s Driver became ready, waking up RX thread...\n", INSTANCE(pThis)));
-    vnetWakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
+static DECLCALLBACK(void) vnetIoCb_Ready(PPDMDEVINS pDevIns)
+{
+    Log(("%s Driver became ready, waking up RX thread...\n", INSTANCE(PDMDEVINS_2_DATA(pDevIns, PVNETSTATE))));
+    vnetWakeupReceive(pDevIns);
 }
 
@@ -628 +675 @@
 
 /**
- * @callback_method_impl{FNIOMIOPORTIN}
- */
-PDMBOTHCBDECL(int) vnetIOPortIn(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t *pu32, unsigned cb)
+ * @callback_method_impl{FNIOMIOPORTNEWIN}
+ */
+static DECLCALLBACK(VBOXSTRICTRC) vnetIOPortIn(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
 {
     PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     RT_NOREF(pvUser);
-    return vpciIOPortIn(pDevIns, &pThis->VPCI, port, pu32, cb, &g_IOCallbacks);
-}
-
-
-/**
- * @callback_method_impl{FNIOMIOPORTOUT}
- */
-PDMBOTHCBDECL(int) vnetIOPortOut(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t u32, unsigned cb)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    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)
+{
+    PVNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
     RT_NOREF(pvUser);
-    return vpciIOPortOut(pDevIns, &pThis->VPCI, port, u32, cb, &g_IOCallbacks);
+    return vpciIOPortOut(pDevIns, &pThis->VPCI, &pThisCC->VPCI, offPort, u32, cb, &g_IOCallbacks);
 }
 
@@ -660 +708 @@
  *
  * @returns VERR_NET_NO_BUFFER_SPACE if it cannot.
- * @param   pInterface      Pointer to the interface structure containing the called function pointer.
  * @thread  RX
  */
-static int vnetR3CanReceive(PVNETSTATE pThis)
+static int vnetR3CanReceive(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
 {
     int rc = vnetCsRxEnter(pThis, VERR_SEM_BUSY);
@@ -671 +718 @@
     if (!(pThis->VPCI.uStatus & VPCI_STATUS_DRV_OK))
         rc = VERR_NET_NO_BUFFER_SPACE;
-    else if (!vqueueIsReady(&pThis->VPCI, pThis->pRxQueue))
+    else if (!vqueueIsReady(pThisCC->pRxQueue))
         rc = VERR_NET_NO_BUFFER_SPACE;
-    else if (vqueueIsEmpty(&pThis->VPCI, pThis->pRxQueue))
-    {
-        vringSetNotification(&pThis->VPCI, &pThis->pRxQueue->VRing, true);
+    else if (vqueueIsEmpty(pDevIns, pThisCC->pRxQueue))
+    {
+        vringSetNotification(pDevIns, &pThisCC->pRxQueue->VRing, true);
         rc = VERR_NET_NO_BUFFER_SPACE;
     }
     else
     {
-        vringSetNotification(&pThis->VPCI, &pThis->pRxQueue->VRing, false);
+        vringSetNotification(pDevIns, &pThisCC->pRxQueue->VRing, false);
         rc = VINF_SUCCESS;
     }
@@ -694 +741 @@
 static DECLCALLBACK(int) vnetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
-    PPDMDEVINS pDevIns = pThis->VPCI.pDevInsR3;
+    PVNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkDown);
+    PPDMDEVINS   pDevIns = pThisCC->pDevIns;
+    PVNETSTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     LogFlow(("%s vnetR3NetworkDown_WaitReceiveAvail(cMillies=%u)\n", INSTANCE(pThis), cMillies));
 
-    int rc = vnetR3CanReceive(pThis);
+    int rc = vnetR3CanReceive(pDevIns, pThis, pThisCC);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
@@ -710 +758 @@
 
     VMSTATE enmVMState;
-    while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pThis->VPCI.CTX_SUFF(pDevIns))) == VMSTATE_RUNNING
+    while (RT_LIKELY(   (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING
                      ||  enmVMState == VMSTATE_RUNNING_LS))
     {
-        int rc2 = vnetR3CanReceive(pThis);
+        int rc2 = vnetR3CanReceive(pDevIns, pThis, pThisCC);
         if (RT_SUCCESS(rc2))
         {
@@ -733 +781 @@
 
 /**
- * @interface_method_impl{PDMIBASE,pfnQueryInterface}
+ * @interface_method_impl{PDMIBASE,pfnQueryInterface,
+ * For VNETSTATECC::VPCI.IBase}
  */
 static DECLCALLBACK(void *) vnetQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, VPCI.IBase);
-    Assert(&pThis->VPCI.IBase == pInterface);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
-    return vpciQueryInterface(pInterface, pszIID);
+    PVNETSTATECC pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, VPCI.IBase);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
+
+    return vpciR3QueryInterface(&pThisCC->VPCI, pszIID);
 }
 
@@ -802 +851 @@
     Log4(("%s vnetR3AddressFilter: %RTmac (conf) != %RTmac (dest)\n", INSTANCE(pThis), pThis->config.mac.au8, pvBuf));
 
-    for (unsigned i = 0; i < pThis->nMacFilterEntries; i++)
+    for (unsigned i = 0; i < pThis->cMacFilterEntries; i++)
         if (!memcmp(&pThis->aMacFilter[i], pvBuf, sizeof(RTMAC)))
             return true;
@@ -819 +868 @@
  *
  * @returns VBox status code.
- * @param   pThis          The device state structure.
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The virtio-net shared instance data.
  * @param   pvBuf           The available data.
  * @param   cb              Number of bytes available in the buffer.
  * @thread  RX
  */
-static int vnetR3HandleRxPacket(PVNETSTATE pThis, const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso)
+static int vnetR3HandleRxPacket(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC,
+                                const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso)
 {
     VNETHDRMRX  Hdr;
@@ -877 +928 @@
         unsigned int nSeg = 0, uElemSize = 0, cbReserved = 0;
 
-        if (!vqueueGet(&pThis->VPCI, pThis->pRxQueue, &elem))
+        if (!vqueueGet(pDevIns, &pThis->VPCI, pThisCC->pRxQueue, &elem))
         {
             /*
@@ -921 +972 @@
         }
         STAM_PROFILE_START(&pThis->StatReceiveStore, a);
-        vqueuePut(&pThis->VPCI, pThis->pRxQueue, &elem, uElemSize, cbReserved);
+        vqueuePut(pDevIns, &pThis->VPCI, pThisCC->pRxQueue, &elem, uElemSize, cbReserved);
         STAM_PROFILE_STOP(&pThis->StatReceiveStore, a);
         if (!vnetR3MergeableRxBuffers(pThis))
@@ -930 +981 @@
     {
         Hdr.u16NumBufs = nElem;
-        int rc = PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns), addrHdrMrx,
+        int rc = PDMDevHlpPCIPhysWrite(pDevIns, addrHdrMrx,
                                        &Hdr, sizeof(Hdr));
         if (RT_FAILURE(rc))
@@ -938 +989 @@
         }
     }
-    vqueueSync(&pThis->VPCI, pThis->pRxQueue);
+    vqueueSync(pDevIns, &pThis->VPCI, pThisCC->pRxQueue);
     if (uOffset < cb)
     {
@@ -951 +1002 @@
  * @interface_method_impl{PDMINETWORKDOWN,pfnReceiveGso}
  */
-static DECLCALLBACK(int) vnetR3NetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface,
-                                                    const void *pvBuf, size_t cb,
-                                                    PCPDMNETWORKGSO pGso)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
+static DECLCALLBACK(int) vnetR3NetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface, const void *pvBuf,
+                                                      size_t cb, PCPDMNETWORKGSO pGso)
+{
+    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkDown);
+    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
 
     if (pGso)
@@ -985 +1037 @@
 
     Log2(("%s vnetR3NetworkDown_ReceiveGso: pvBuf=%p cb=%u pGso=%p\n", INSTANCE(pThis), pvBuf, cb, pGso));
-    int rc = vnetR3CanReceive(pThis);
+    int rc = vnetR3CanReceive(pDevIns, pThis, pThisCC);
     if (RT_FAILURE(rc))
         return rc;
 
     /* Drop packets if VM is not running or cable is disconnected. */
-    VMSTATE enmVMState = PDMDevHlpVMState(pThis->VPCI.CTX_SUFF(pDevIns));
+    VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
     if ((   enmVMState != VMSTATE_RUNNING
          && enmVMState != VMSTATE_RUNNING_LS)
-        || !(STATUS & VNET_S_LINK_UP))
+        || !(pThis->config.uStatus & VNET_S_LINK_UP))
         return VINF_SUCCESS;
 
     STAM_PROFILE_START(&pThis->StatReceive, a);
-    vpciSetReadLed(&pThis->VPCI, true);
+    vpciR3SetReadLed(&pThis->VPCI, true);
     if (vnetR3AddressFilter(pThis, pvBuf, cb))
     {
@@ -1003 +1055 @@
         if (RT_SUCCESS(rc))
         {
-            rc = vnetR3HandleRxPacket(pThis, pvBuf, cb, pGso);
+            rc = vnetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso);
             STAM_REL_COUNTER_ADD(&pThis->StatReceiveBytes, cb);
             vnetCsRxLeave(pThis);
         }
     }
-    vpciSetReadLed(&pThis->VPCI, false);
+    vpciR3SetReadLed(&pThis->VPCI, false);
     STAM_PROFILE_STOP(&pThis->StatReceive, a);
     return rc;
@@ -1022 +1074 @@
 
 /**
- * Gets the current Media Access Control (MAC) address.
- *
- * @returns VBox status code.
- * @param   pInterface      Pointer to the interface structure containing the called function pointer.
- * @param   pMac            Where to store the MAC address.
- * @thread  EMT
+ * @interface_method_impl{PDMINETWORKCONFIG,pfnGetMac}
  */
 static DECLCALLBACK(int) vnetR3NetworkConfig_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
+    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkConfig);
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVNETSTATE);
     memcpy(pMac, pThis->config.mac.au8, sizeof(RTMAC));
     return VINF_SUCCESS;
@@ -1037 +1085 @@
 
 /**
- * Gets the new link state.
- *
- * @returns The current link state.
- * @param   pInterface      Pointer to the interface structure containing the called function pointer.
- * @thread  EMT
+ * @interface_method_impl{PDMINETWORKCONFIG,pfnGetLinkState}
  */
 static DECLCALLBACK(PDMNETWORKLINKSTATE) vnetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
-    if (STATUS & VNET_S_LINK_UP)
+    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkConfig);
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVNETSTATE);
+    if (pThis->config.uStatus & VNET_S_LINK_UP)
         return PDMNETWORKLINKSTATE_UP;
     return PDMNETWORKLINKSTATE_DOWN;
 }
 
-
-/**
- * Sets the new link state.
- *
- * @returns VBox status code.
- * @param   pInterface      Pointer to the interface structure containing the called function pointer.
- * @param   enmState        The new link state
+/**
+ * @interface_method_impl{PDMINETWORKCONFIG,pfnSetLinkState}
  */
 static DECLCALLBACK(int) vnetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
-    bool fOldUp = !!(STATUS & VNET_S_LINK_UP);
+    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkConfig);
+    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    bool fOldUp = !!(pThis->config.uStatus & VNET_S_LINK_UP);
     bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
 
@@ -1074 +1116 @@
              * notification will be sent when the link actually goes up in vnetR3LinkUpTimer().
              */
-            vnetR3TempLinkDown(pThis);
-            if (pThis->pDrv)
-                pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, enmState);
+            vnetR3TempLinkDown(pDevIns, pThis, pThisCC);
+            if (pThisCC->pDrv)
+                pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
         }
     }
@@ -1085 +1127 @@
             Log(("%s Link is up\n", INSTANCE(pThis)));
             pThis->fCableConnected = true;
-            STATUS |= VNET_S_LINK_UP;
-            vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+            pThis->config.uStatus |= VNET_S_LINK_UP;
+            vnetR3RaiseInterrupt(pDevIns, pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
         }
         else
         {
             /* The link was brought down explicitly, make sure it won't come up by timer.  */
-            TMTimerStop(pThis->pLinkUpTimer);
+            PDMDevHlpTimerStop(pDevIns, pThisCC->hLinkUpTimer);
             Log(("%s Link is down\n", INSTANCE(pThis)));
             pThis->fCableConnected = false;
-            STATUS &= ~VNET_S_LINK_UP;
-            vnetR3RaiseInterrupt(pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
-        }
-        if (pThis->pDrv)
-            pThis->pDrv->pfnNotifyLinkChanged(pThis->pDrv, enmState);
+            pThis->config.uStatus &= ~VNET_S_LINK_UP;
+            vnetR3RaiseInterrupt(pDevIns, pThis, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
+        }
+        if (pThisCC->pDrv)
+            pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
     }
     return VINF_SUCCESS;
 }
 
-static DECLCALLBACK(void) vnetR3QueueReceive(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
+/**
+ * @callback_method_impl{FNVPCIQUEUECALLBACK, The RX queue}
+ */
+static DECLCALLBACK(void) vnetR3QueueReceive(PPDMDEVINS pDevIns, PVQUEUE pQueue)
+{
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     RT_NOREF(pThis, pQueue);
     Log(("%s Receive buffers has been added, waking up receive thread.\n", INSTANCE(pThis)));
@@ -1177 +1222 @@
     AssertReturnVoid(uStart < cbSize);
     AssertReturnVoid(uStart + uOffset + sizeof(uint16_t) <= cbSize);
-    *(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? */
+    *(uint16_t *)(pBuf + uStart + uOffset) = vnetR3CSum16(pBuf + uStart, cbSize - uStart);
+}
+
+static bool vnetR3ReadHeader(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, PVNETHDR pHdr, uint32_t cbMax)
+{
+    int rc = PDMDevHlpPhysRead(pDevIns, GCPhys, pHdr, sizeof(*pHdr)); /** @todo r=bird: Why not PDMDevHlpPCIPhysRead? */
     if (RT_FAILURE(rc))
         return false;
@@ -1223 +1268 @@
 }
 
-static int vnetR3TransmitFrame(PVNETSTATE pThis, PPDMSCATTERGATHER pSgBuf, PPDMNETWORKGSO pGso, PVNETHDR pHdr)
+static int vnetR3TransmitFrame(PVNETSTATE pThis, PVNETSTATECC pThisCC, PPDMSCATTERGATHER pSgBuf,
+                               PPDMNETWORKGSO pGso, PVNETHDR pHdr)
 {
     vnetR3PacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
@@ -1270 +1316 @@
     }
 
-    return pThis->pDrv->pfnSendBuf(pThis->pDrv, pSgBuf, false);
-}
-
-static void vnetR3TransmitPendingPackets(PVNETSTATE pThis, PVQUEUE pQueue, bool fOnWorkerThread)
+    return pThisCC->pDrv->pfnSendBuf(pThisCC->pDrv, pSgBuf, false);
+}
+
+static void vnetR3TransmitPendingPackets(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC,
+                                         PVQUEUE pQueue, bool fOnWorkerThread)
 {
     /*
@@ -1295 +1342 @@
     }
 
-    PPDMINETWORKUP pDrv = pThis->pDrv;
+    PPDMINETWORKUP pDrv = pThisCC->pDrv;
     if (pDrv)
     {
@@ -1314 +1361 @@
 
     Log3(("%s vnetR3TransmitPendingPackets: About to transmit %d pending packets\n",
-          INSTANCE(pThis), vringReadAvailIndex(&pThis->VPCI, &pThis->pTxQueue->VRing) - pThis->pTxQueue->uNextAvailIndex));
-
-    vpciSetWriteLed(&pThis->VPCI, true);
+          INSTANCE(pThis), vringReadAvailIndex(pDevIns, &pThisCC->pTxQueue->VRing) - pThisCC->pTxQueue->uNextAvailIndex));
+
+    vpciR3SetWriteLed(&pThis->VPCI, true);
 
     /*
@@ -1323 +1370 @@
      */
     VQUEUEELEM elem; /* This bugger is big! ~48KB on 64-bit hosts. */
-    while (vqueuePeek(&pThis->VPCI, pQueue, &elem))
+    while (vqueuePeek(pDevIns, &pThis->VPCI, pQueue, &elem))
     {
         unsigned int uOffset = 0;
@@ -1347 +1394 @@
         if (uSize > VNET_MAX_FRAME_SIZE)
             uSize = VNET_MAX_FRAME_SIZE;
-        if (pThis->pDrv && vnetR3ReadHeader(pThis, elem.aSegsOut[0].addr, &Hdr, uSize))
+        if (pThisCC->pDrv && vnetR3ReadHeader(pDevIns, elem.aSegsOut[0].addr, &Hdr, uSize))
         {
             RT_UNTRUSTED_VALIDATED_FENCE();
@@ -1358 +1405 @@
             /** @todo Optimize away the extra copying! (lazy bird) */
             PPDMSCATTERGATHER pSgBuf;
-            int rc = pThis->pDrv->pfnAllocBuf(pThis->pDrv, uSize, pGso, &pSgBuf);
+            int rc = pThisCC->pDrv->pfnAllocBuf(pThisCC->pDrv, uSize, pGso, &pSgBuf);
             if (RT_SUCCESS(rc))
             {
@@ -1368 +1415 @@
                 {
                     unsigned int cbSegment = RT_MIN(uSize, elem.aSegsOut[i].cb);
-                    PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns), elem.aSegsOut[i].addr,
+                    PDMDevHlpPhysRead(pDevIns, elem.aSegsOut[i].addr,
                                       ((uint8_t*)pSgBuf->aSegs[0].pvSeg) + uOffset,
                                       cbSegment);
@@ -1374 +1421 @@
                     uSize -= cbSegment;
                 }
-                rc = vnetR3TransmitFrame(pThis, pSgBuf, pGso, &Hdr);
+                rc = vnetR3TransmitFrame(pThis, pThisCC, pSgBuf, pGso, &Hdr);
             }
             else
@@ -1390 +1437 @@
 
         /* Remove this descriptor chain from the available ring */
-        vqueueSkip(&pThis->VPCI, pQueue);
-        vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(VNETHDR) + uOffset);
-        vqueueSync(&pThis->VPCI, pQueue);
+        vqueueSkip(pDevIns, &pThis->VPCI, pQueue);
+        vqueuePut(pDevIns, &pThis->VPCI, pQueue, &elem, sizeof(VNETHDR) + uOffset);
+        vqueueSync(pDevIns, &pThis->VPCI, pQueue);
         STAM_PROFILE_ADV_STOP(&pThis->StatTransmit, a);
     }
-    vpciSetWriteLed(&pThis->VPCI, false);
+    vpciR3SetWriteLed(&pThis->VPCI, false);
 
     if (pDrv)
@@ -1407 +1454 @@
 static DECLCALLBACK(void) vnetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
 {
-    PVNETSTATE pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
+    PVNETSTATECC    pThisCC = RT_FROM_MEMBER(pInterface, VNETSTATECC, INetworkDown);
+    PPDMDEVINS      pDevIns = pThisCC->pDevIns;
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVNETSTATE);
     STAM_COUNTER_INC(&pThis->StatTransmitByNetwork);
-    vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
+    vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pThisCC->pTxQueue, false /*fOnWorkerThread*/);
 }
 
 # ifdef VNET_TX_DELAY
 
-static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
-    RT_NOREF(pDevIns);
-
-    if (TMTimerIsActive(pThis->CTX_SUFF(pTxTimer)))
-    {
-        TMTimerStop(pThis->CTX_SUFF(pTxTimer));
+/**
+ * @callback_method_impl{FNVPCIQUEUECALLBACK, The TX queue}
+ */
+static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVQUEUE pQueue)
+{
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+
+    if (PDMDevHlpTimerIsActive(pDevIns, pThis->hTxTimer))
+    {
+        PDMDevHlpTimerStop(pDevIns, pThis->hTxTimer);
         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)))
+        vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pQueue, false /*fOnWorkerThread*/);
+        if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
             LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
         else
         {
-            vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, true);
-            vnetR3CsLeave(pThis);
+            vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
+            vnetR3CsLeave(pDevIns, pThis);
         }
     }
     else
     {
-        if (RT_FAILURE(vnetR3CsEnter(pThis, VERR_SEM_BUSY)))
+        if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
             LogRel(("vnetR3QueueTransmit: Failed to enter critical section!/n"));
         else
         {
-            vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, false);
-            TMTimerSetMicro(pThis->CTX_SUFF(pTxTimer), VNET_TX_DELAY);
+            vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, false);
+            PDMDevHlpTimerSetMicro(pDevIns, pThis->hTxTimer, VNET_TX_DELAY);
             pThis->u64NanoTS = RTTimeNanoTS();
-            vnetR3CsLeave(pThis);
+            vnetR3CsLeave(pDevIns, pThis);
         }
     }
@@ -1451 +1503 @@
 static DECLCALLBACK(void) vnetR3TxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
-    RT_NOREF(pDevIns, pTimer);
-    PVNETSTATE pThis = (PVNETSTATE)pvUser;
-
-    uint32_t u32MicroDiff = (uint32_t)((RTTimeNanoTS() - pThis->u64NanoTS)/1000);
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+    RT_NOREF(pTimer, pvUser);
+
+    uint32_t u32MicroDiff = (uint32_t)((RTTimeNanoTS() - pThis->u64NanoTS) / 1000);
     if (u32MicroDiff < pThis->u32MinDiff)
         pThis->u32MinDiff = u32MicroDiff;
@@ -1465 +1518 @@
 
 //    Log3(("%s vnetR3TxTimer: Expired\n", INSTANCE(pThis)));
-    vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
-    if (RT_FAILURE(vnetR3CsEnter(pThis, VERR_SEM_BUSY)))
+    vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pThisCC->pTxQueue, false /*fOnWorkerThread*/);
+    if (RT_FAILURE(vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY)))
     {
         LogRel(("vnetR3TxTimer: Failed to enter critical section!/n"));
         return;
     }
-    vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, true);
-    vnetR3CsLeave(pThis);
-}
-
-DECLINLINE(int) vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
-{
-    RT_NOREF(pDevIns, pThis);
+    vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
+    vnetR3CsLeave(pDevIns, pThis);
+}
+
+DECLINLINE(int) vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
+{
+    RT_NOREF(pDevIns, pThis, pThisCC);
     return VINF_SUCCESS;
 }
 
-DECLINLINE(void) vnetR3DestroyTxThreadAndEvent(PVNETSTATE pThis)
-{
-    RT_NOREF(pThis);
+DECLINLINE(void) vnetR3DestroyTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
+{
+    RT_NOREF(pDevIns, pThis, pThisCC);
 }
 
 # else /* !VNET_TX_DELAY */
 
+/**
+ * @callback_method_impl{FNPDMTHREADDEV}
+ */
 static DECLCALLBACK(int) vnetR3TxThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    RT_NOREF(pDevIns);
-    PVNETSTATE pThis = (PVNETSTATE)pThread->pvUser;
-    int rc = VINF_SUCCESS;
+    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)
     {
@@ -1505 +1561 @@
         while (true)
         {
-            vnetR3TransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/); /// @todo shouldn't it be true instead?
+            vnetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, pThisCC->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))
+            vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, true);
+            if (vqueueIsEmpty(pDevIns, pThisCC->pTxQueue))
                 break;
-            vringSetNotification(&pThis->VPCI, &pThis->pTxQueue->VRing, false);
+            vringSetNotification(pDevIns, &pThisCC->pTxQueue->VRing, false);
         }
     }
@@ -1518 +1574 @@
 
 /**
- * Unblock TX thread so it can respond to a state change.
- *
- * @returns VBox status code.
- * @param   pDevIns     The device instance.
- * @param   pThread     The send thread.
+ * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
  */
 static DECLCALLBACK(int) vnetR3TxThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    PVNETSTATE pThis = (PVNETSTATE)pThread->pvUser;
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    RT_NOREF(pThread);
     return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
 }
 
-static int vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
+static int vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC)
 {
     int rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hTxEvent);
-    if (RT_FAILURE(rc))
-        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create SUP event semaphore"));
-
-    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->pTxThread, pThis, vnetR3TxThread,
-                               vnetR3TxThreadWakeUp, 0, RTTHREADTYPE_IO, INSTANCE(pThis));
-    if (RT_FAILURE(rc))
-        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create worker thread %s"), INSTANCE(pThis));
-    return VINF_SUCCESS;
-}
-
-static void vnetR3DestroyTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
-{
-    if (pThis->pTxThread)
-    {
+    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, PVNETSTATE pThis, PVNETSTATECC pThisCC)
+{
+    if (pThisCC->pTxThread)
+    {
+        /* Destroy the thread. */
         int rcThread;
-        /* Destroy the thread. */
-        int rc = PDMR3ThreadDestroy(pThis->pTxThread, &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));
-        pThis->pTxThread = NULL;
-    }
+        pThisCC->pTxThread = NULL;
+    }
+
     if (pThis->hTxEvent != NIL_SUPSEMEVENT)
     {
@@ -1561 +1617 @@
 }
 
-static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
+/**
+ * @callback_method_impl{FNVPCIQUEUECALLBACK, The TX queue}
+ */
+static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVQUEUE pQueue)
+{
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
 
     Log(("vnetR3QueueTransmit: disable kicking and wake up TX thread\n"));
-    vringSetNotification(&pThis->VPCI, &pQueue->VRing, false);
-    PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
+    vringSetNotification(pDevIns, &pQueue->VRing, false);
+    int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
+    AssertRC(rc);
 }
 
 # endif /* !VNET_TX_DELAY */
 
-static uint8_t vnetR3ControlRx(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+static uint8_t vnetR3ControlRx(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETSTATECC pThisCC,
+                               PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint8_t u8Ack = VNET_OK;
     uint8_t fOn, fDrvWasPromisc = pThis->fPromiscuous | pThis->fAllMulti;
-    PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                      pElem->aSegsOut[1].addr,
-                      &fOn, sizeof(fOn));
+    PDMDevHlpPhysRead(pDevIns, pElem->aSegsOut[1].addr, &fOn, sizeof(fOn));
     Log(("%s vnetR3ControlRx: uCommand=%u fOn=%u\n", INSTANCE(pThis), pCtlHdr->u8Command, fOn));
     switch (pCtlHdr->u8Command)
@@ -1591 +1650 @@
             u8Ack = VNET_ERROR;
     }
-    if (fDrvWasPromisc != (pThis->fPromiscuous | pThis->fAllMulti) && pThis->pDrv)
-        pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv,
+    if (fDrvWasPromisc != (pThis->fPromiscuous | pThis->fAllMulti) && pThisCC->pDrv)
+        pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv,
             (pThis->fPromiscuous | pThis->fAllMulti));
 
@@ -1598 +1657 @@
 }
 
-static uint8_t vnetR3ControlMac(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+static uint8_t vnetR3ControlMac(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint32_t nMacs = 0;
 
-    if (pCtlHdr->u8Command != VNET_CTRL_CMD_MAC_TABLE_SET
+    if (   pCtlHdr->u8Command != VNET_CTRL_CMD_MAC_TABLE_SET
         || pElem->nOut != 3
         || pElem->aSegsOut[1].cb < sizeof(nMacs)
@@ -1613 +1672 @@
 
     /* Load unicast addresses */
-    PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                      pElem->aSegsOut[1].addr,
-                      &nMacs, sizeof(nMacs));
+    PDMDevHlpPhysRead(pDevIns, pElem->aSegsOut[1].addr, &nMacs, sizeof(nMacs));
 
     if (pElem->aSegsOut[1].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
@@ -1632 +1689 @@
     {
         if (nMacs)
-            PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                              pElem->aSegsOut[1].addr + sizeof(nMacs),
-                              pThis->aMacFilter, nMacs * sizeof(RTMAC));
-        pThis->nMacFilterEntries = nMacs;
-#ifdef DEBUG
+            PDMDevHlpPhysRead(pDevIns, pElem->aSegsOut[1].addr + sizeof(nMacs), pThis->aMacFilter, nMacs * sizeof(RTMAC));
+        pThis->cMacFilterEntries = nMacs;
+#ifdef LOG_ENABLED
         Log(("%s vnetR3ControlMac: unicast macs:\n", INSTANCE(pThis)));
         for(unsigned i = 0; i < nMacs; i++)
             Log(("         %RTmac\n", &pThis->aMacFilter[i]));
-#endif /* DEBUG */
+#endif
     }
 
     /* Load multicast addresses */
-    PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                      pElem->aSegsOut[2].addr,
-                      &nMacs, sizeof(nMacs));
+    PDMDevHlpPhysRead(pDevIns, pElem->aSegsOut[2].addr, &nMacs, sizeof(nMacs));
 
     if (pElem->aSegsOut[2].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
@@ -1655 +1708 @@
     }
 
-    if (nMacs > VNET_MAC_FILTER_LEN - pThis->nMacFilterEntries)
+    if (nMacs > VNET_MAC_FILTER_LEN - pThis->cMacFilterEntries)
     {
         Log(("%s vnetR3ControlMac: MAC table is too big, have to use allmulti mode (nMacs=%u)\n", INSTANCE(pThis), nMacs));
@@ -1663 +1716 @@
     {
         if (nMacs)
-            PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
+            PDMDevHlpPhysRead(pDevIns,
                               pElem->aSegsOut[2].addr + sizeof(nMacs),
-                              &pThis->aMacFilter[pThis->nMacFilterEntries],
+                              &pThis->aMacFilter[pThis->cMacFilterEntries],
                               nMacs * sizeof(RTMAC));
-#ifdef DEBUG
+#ifdef LOG_ENABLED
         Log(("%s vnetR3ControlMac: multicast macs:\n", INSTANCE(pThis)));
         for(unsigned i = 0; i < nMacs; i++)
             Log(("         %RTmac\n",
-                 &pThis->aMacFilter[i+pThis->nMacFilterEntries]));
-#endif /* DEBUG */
-        pThis->nMacFilterEntries += nMacs;
+                 &pThis->aMacFilter[i+pThis->cMacFilterEntries]));
+#endif
+        pThis->cMacFilterEntries += nMacs;
     }
 
@@ -1679 +1732 @@
 }
 
-static uint8_t vnetR3ControlVlan(PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
+static uint8_t vnetR3ControlVlan(PPDMDEVINS pDevIns, PVNETSTATE pThis, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
 {
     uint8_t  u8Ack = VNET_OK;
@@ -1691 +1744 @@
     }
 
-    PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
-                      pElem->aSegsOut[1].addr,
-                      &u16Vid, sizeof(u16Vid));
+    PDMDevHlpPhysRead(pDevIns, pElem->aSegsOut[1].addr, &u16Vid, sizeof(u16Vid));
 
     if (u16Vid >= VNET_MAX_VID)
@@ -1719 +1770 @@
 
 
-static DECLCALLBACK(void) vnetR3QueueControl(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
-{
-    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
-    VQUEUEELEM elem;
-    while (vqueueGet(&pThis->VPCI, pQueue, &elem))
+/**
+ * @callback_method_impl{FNVPCIQUEUECALLBACK, The CLT queue}
+ */
+static DECLCALLBACK(void) vnetR3QueueControl(PPDMDEVINS pDevIns, PVQUEUE pQueue)
+{
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+
+    VQUEUEELEM      elem;
+    while (vqueueGet(pDevIns, &pThis->VPCI, pQueue, &elem))
     {
         if (elem.nOut < 1 || elem.aSegsOut[0].cb < sizeof(VNETCTLHDR))
@@ -1745 +1801 @@
         {
             case VNET_CTRL_CLS_RX_MODE:
-                bAck = vnetR3ControlRx(pThis, &CtlHdr, &elem);
+                bAck = vnetR3ControlRx(pDevIns, pThis, pThisCC, &CtlHdr, &elem);
                 break;
             case VNET_CTRL_CLS_MAC:
-                bAck = vnetR3ControlMac(pThis, &CtlHdr, &elem);
+                bAck = vnetR3ControlMac(pDevIns, pThis, &CtlHdr, &elem);
                 break;
             case VNET_CTRL_CLS_VLAN:
-                bAck = vnetR3ControlVlan(pThis, &CtlHdr, &elem);
+                bAck = vnetR3ControlVlan(pDevIns, pThis, &CtlHdr, &elem);
                 break;
             default:
@@ -1759 +1815 @@
         PDMDevHlpPCIPhysWrite(pDevIns, elem.aSegsIn[elem.nIn - 1].addr, &bAck, sizeof(bAck));
 
-        vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(bAck));
-        vqueueSync(&pThis->VPCI, pQueue);
-    }
+        vqueuePut(pDevIns, &pThis->VPCI, pQueue, &elem, sizeof(bAck));
+        vqueueSync(pDevIns, &pThis->VPCI, pQueue);
+    }
+}
+
+/* -=-=-=-=- Debug info item -=-=-=-=- */
+
+/**
+ * @callback_method_impl{FNDBGFINFOARGVDEV}
+ */
+static DECLCALLBACK(void) vnetR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, int cArgs, char **papszArgs)
+{
+    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    RT_NOREF(cArgs, papszArgs);
+    vpcR3iDumpStateWorker(&pThis->VPCI, pHlp);
 }
 
@@ -1819 +1887 @@
 
     /* Save the common part */
-    int rc = vpciSaveExec(&pThis->VPCI, pSSM);
+    int rc = vpciR3SaveExec(pHlp, &pThis->VPCI, pSSM);
     AssertRCReturn(rc, rc);
 
@@ -1826 +1894 @@
     pHlp->pfnSSMPutBool(    pSSM, pThis->fPromiscuous);
     pHlp->pfnSSMPutBool(    pSSM, pThis->fAllMulti);
-    pHlp->pfnSSMPutU32(     pSSM, pThis->nMacFilterEntries);
-    pHlp->pfnSSMPutMem(     pSSM, pThis->aMacFilter, pThis->nMacFilterEntries * sizeof(RTMAC));
+    pHlp->pfnSSMPutU32(     pSSM, pThis->cMacFilterEntries);
+    pHlp->pfnSSMPutMem(     pSSM, pThis->aMacFilter, pThis->cMacFilterEntries * sizeof(RTMAC));
     rc = pHlp->pfnSSMPutMem(pSSM, pThis->aVlanFilter, sizeof(pThis->aVlanFilter));
     AssertRCReturn(rc, rc);
@@ -1858 +1926 @@
 {
     PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
     PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
 
@@ -1868 +1937 @@
         LogRel(("%s: The mac address differs: config=%RTmac saved=%RTmac\n", INSTANCE(pThis), &pThis->macConfigured, &macConfigured));
 
-    rc = vpciLoadExec(&pThis->VPCI, pSSM, uVersion, uPass, VNET_N_QUEUES);
+    rc = vpciR3LoadExec(pHlp, &pThis->VPCI, pSSM, uVersion, uPass, VNET_N_QUEUES);
     AssertRCReturn(rc, rc);
 
@@ -1880 +1949 @@
             pHlp->pfnSSMGetBool(pSSM, &pThis->fPromiscuous);
             pHlp->pfnSSMGetBool(pSSM, &pThis->fAllMulti);
-            pHlp->pfnSSMGetU32(pSSM, &pThis->nMacFilterEntries);
-            pHlp->pfnSSMGetMem(pSSM, pThis->aMacFilter, pThis->nMacFilterEntries * sizeof(RTMAC));
+            pHlp->pfnSSMGetU32(pSSM, &pThis->cMacFilterEntries);
+            pHlp->pfnSSMGetMem(pSSM, pThis->aMacFilter, pThis->cMacFilterEntries * sizeof(RTMAC));
 
             /* Clear the rest. */
-            if (pThis->nMacFilterEntries < VNET_MAC_FILTER_LEN)
-                memset(&pThis->aMacFilter[pThis->nMacFilterEntries],
+            if (pThis->cMacFilterEntries < VNET_MAC_FILTER_LEN)
+                memset(&pThis->aMacFilter[pThis->cMacFilterEntries],
                        0,
-                       (VNET_MAC_FILTER_LEN - pThis->nMacFilterEntries) * sizeof(RTMAC));
+                       (VNET_MAC_FILTER_LEN - pThis->cMacFilterEntries) * sizeof(RTMAC));
             rc = pHlp->pfnSSMGetMem(pSSM, pThis->aVlanFilter, sizeof(pThis->aVlanFilter));
             AssertRCReturn(rc, rc);
@@ -1895 +1964 @@
             pThis->fPromiscuous = true;
             pThis->fAllMulti = false;
-            pThis->nMacFilterEntries = 0;
+            pThis->cMacFilterEntries = 0;
             memset(pThis->aMacFilter, 0, VNET_MAC_FILTER_LEN * sizeof(RTMAC));
             memset(pThis->aVlanFilter, 0, sizeof(pThis->aVlanFilter));
-            if (pThis->pDrv)
-                pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv, true);
+            if (pThisCC->pDrv)
+                pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, true);
         }
     }
@@ -1913 +1982 @@
 static DECLCALLBACK(int) vnetR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
     RT_NOREF(pSSM);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-
-    if (pThis->pDrv)
-        pThis->pDrv->pfnSetPromiscuousMode(pThis->pDrv,
-            (pThis->fPromiscuous | pThis->fAllMulti));
+
+    if (pThisCC->pDrv)
+        pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, (pThis->fPromiscuous | pThis->fAllMulti));
     /*
      * Indicate link down to the guest OS that all network connections have
@@ -1924 +1993 @@
      */
     if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
-        vnetR3TempLinkDown(pThis);
+        vnetR3TempLinkDown(pDevIns, pThis, pThisCC);
 
     return VINF_SUCCESS;
@@ -1930 +1999 @@
 
 
-/* -=-=-=-=- PCI Device -=-=-=-=- */
-
-/**
- * @callback_method_impl{FNPCIIOREGIONMAP}
- */
-static DECLCALLBACK(int) vnetR3Map(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
-                                   RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
-{
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    RT_NOREF(pPciDev, iRegion);
-
-    if (enmType != PCI_ADDRESS_SPACE_IO)
-    {
-        /* We should never get here */
-        AssertMsgFailed(("Invalid PCI address space param in map callback"));
-        return VERR_INTERNAL_ERROR;
-    }
-
-    pThis->VPCI.IOPortBase = (RTIOPORT)GCPhysAddress;
-    int rc = PDMDevHlpIOPortRegister(pDevIns, pThis->VPCI.IOPortBase,
-                                     cb, 0, vnetIOPortOut, vnetIOPortIn,
-                                     NULL, NULL, "VirtioNet");
-#ifdef VNET_GC_SUPPORT
-    AssertRCReturn(rc, rc);
-    rc = PDMDevHlpIOPortRegisterR0(pDevIns, pThis->VPCI.IOPortBase,
-                                   cb, 0, "vnetIOPortOut", "vnetIOPortIn",
-                                   NULL, NULL, "VirtioNet");
-    AssertRCReturn(rc, rc);
-    rc = PDMDevHlpIOPortRegisterRC(pDevIns, pThis->VPCI.IOPortBase,
-                                   cb, 0, "vnetIOPortOut", "vnetIOPortIn",
-                                   NULL, NULL, "VirtioNet");
-#endif
-    AssertRC(rc);
-    return rc;
-}
-
-
 /* -=-=-=-=- PDMDEVREG -=-=-=-=- */
 
@@ -1974 +2006 @@
 static DECLCALLBACK(void) vnetR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+    Log(("%s vnetR3Detach:\n", INSTANCE(pThis)));
     RT_NOREF(fFlags);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    Log(("%s vnetR3Detach:\n", INSTANCE(pThis)));
 
     AssertLogRelReturnVoid(iLUN == 0);
 
-    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
+    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
     if (RT_FAILURE(rc))
     {
@@ -1987 +2020 @@
     }
 
-    vnetR3DestroyTxThreadAndEvent(pDevIns, pThis);
+    vnetR3DestroyTxThreadAndEvent(pDevIns, pThis, pThisCC);
 
     /*
      * Zero important members.
      */
-    pThis->pDrvBase = NULL;
-    pThis->pDrv = NULL;
-
-    vnetR3CsLeave(pThis);
+    pThisCC->pDrvBase = NULL;
+    pThisCC->pDrv     = NULL;
+
+    vnetR3CsLeave(pDevIns, pThis);
 }
 
@@ -2004 +2037 @@
 static DECLCALLBACK(int) vnetR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
 {
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
     RT_NOREF(fFlags);
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     LogFlow(("%s vnetR3Attach:\n",  INSTANCE(pThis)));
 
     AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
 
-    int rc = vnetR3CsEnter(pThis, VERR_SEM_BUSY);
+    int rc = vnetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
     if (RT_FAILURE(rc))
     {
@@ -2020 +2054 @@
      * Attach the driver.
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->VPCI.IBase, &pThis->pDrvBase, "Network Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->VPCI.IBase, &pThisCC->pDrvBase, "Network Port");
     if (RT_SUCCESS(rc))
     {
@@ -2033 +2067 @@
 #endif
         }
-        pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
-        AssertMsgStmt(pThis->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
+        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
+        AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
                       rc = VERR_PDM_MISSING_INTERFACE_BELOW);
 
-        vnetR3CreateTxThreadAndEvent(pDevIns, pThis);
+        vnetR3CreateTxThreadAndEvent(pDevIns, pThis, pThisCC);
     }
     else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
@@ -2053 +2087 @@
      */
     if (RT_SUCCESS(rc))
-        vnetR3TempLinkDown(pThis);
-
-    vnetR3CsLeave(pThis);
+        vnetR3TempLinkDown(pDevIns, pThis, pThisCC);
+
+    vnetR3CsLeave(pDevIns, pThis);
     return rc;
-
 }
 
@@ -2078 +2111 @@
     /* Poke thread waiting for buffer space. */
     vnetWakeupReceive(pDevIns);
-}
-
-
-/**
- * @interface_method_impl{PDMDEVREGR3,pfnRelocate}
- */
-static DECLCALLBACK(void) vnetR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
-{
-    vpciRelocate(pDevIns, offDelta);
-#ifdef VNET_TX_DELAY
-    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
-    pThis->pTxTimerRC = TMTimerRCPtr(pThis->pTxTimerR3);
-#endif
 }
 
@@ -2117 +2137 @@
     //     PDMR3CritSectDelete(&pThis->csRx);
 
-    return vpciDestruct(&pThis->VPCI);
+    return vpciR3Term(pDevIns, &pThis->VPCI);
 }
 
@@ -2128 +2148 @@
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
     PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
     PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     int             rc;
@@ -2134 +2155 @@
      * Initialize the instance data suffiencently for the destructor not to blow up.
      */
-    pThis->hEventMoreRxDescAvail = NIL_SUPSEMEVENT;
+    RTStrPrintf(pThis->VPCI.szInstance, sizeof(pThis->VPCI.szInstance), "VNet%d", iInstance);
+    pThisCC->pDevIns                = pDevIns;
+    pThis->hEventMoreRxDescAvail    = NIL_SUPSEMEVENT;
 #ifndef VNET_TX_DELAY
-    pThis->hTxEvent              = NIL_SUPSEMEVENT;
-    pThis->pTxThread             = NULL;
+    pThis->hTxEvent                 = NIL_SUPSEMEVENT;
+    pThisCC->pTxThread              = NULL;
 #endif
+
+    /* Initialize state structure */
+    pThis->u32PktNo     = 1;
+
+    /* Interfaces */
+    pThisCC->INetworkDown.pfnWaitReceiveAvail = vnetR3NetworkDown_WaitReceiveAvail;
+    pThisCC->INetworkDown.pfnReceive          = vnetR3NetworkDown_Receive;
+    pThisCC->INetworkDown.pfnReceiveGso       = vnetR3NetworkDown_ReceiveGso;
+    pThisCC->INetworkDown.pfnXmitPending      = vnetR3NetworkDown_XmitPending;
+
+    pThisCC->INetworkConfig.pfnGetMac         = vnetR3NetworkConfig_GetMac;
+    pThisCC->INetworkConfig.pfnGetLinkState   = vnetR3NetworkConfig_GetLinkState;
+    pThisCC->INetworkConfig.pfnSetLinkState   = vnetR3NetworkConfig_SetLinkState;
+
 
     /* Do our own locking. */
@@ -2144 +2181 @@
     AssertRCReturn(rc, rc);
 
-    /* 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);
+    /*
+     * Initialize VPCI part.
+     */
+    pThisCC->VPCI.IBase.pfnQueryInterface = vnetQueryInterface;
+
+    rc = vpciR3Init(pDevIns, &pThis->VPCI, &pThisCC->VPCI, 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");
+    pThisCC->pRxQueue  = vpciR3AddQueue(&pThis->VPCI, &pThisCC->VPCI, 256, vnetR3QueueReceive,  "RX ");
+    pThisCC->pTxQueue  = vpciR3AddQueue(&pThis->VPCI, &pThisCC->VPCI, 256, vnetR3QueueTransmit, "TX ");
+    pThisCC->pCtlQueue = vpciR3AddQueue(&pThis->VPCI, &pThisCC->VPCI, 16,  vnetR3QueueControl,  "CTL");
+    AssertLogRelReturn(pThisCC->pCtlQueue && pThisCC->pTxQueue && pThisCC->pRxQueue, VERR_INTERNAL_ERROR_5);
 
     Log(("%s Constructing new instance\n", INSTANCE(pThis)));
@@ -2182 +2222 @@
     pThis->config.uStatus = 0;
 
-    /* Initialize state structure */
-    pThis->u32PktNo     = 1;
-
-    /* Interfaces */
-    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. */
     // char szTmp[sizeof(pThis->VPCI.szInstance) + 2];
@@ -2203 +2230 @@
 
     /* Map our ports to IO space. */
-    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, VPCI_CONFIG + sizeof(VNetPCIConfig), PCI_ADDRESS_SPACE_IO, vnetR3Map);
+    rc = PDMDevHlpPCIIORegionCreateIo(pDevIns, 0 /*iPciReion*/, VPCI_CONFIG + sizeof(VNetPCIConfig),
+                                      vnetIOPortOut, vnetIOPortIn, NULL /*pvUser*/, "VirtioNet", NULL /*paExtDescs*/,
+                                      &pThis->hIoPorts);
     AssertRCReturn(rc, rc);
 
@@ -2214 +2243 @@
 
     /* Create Link Up Timer */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
-                                "VirtioNet Link Up Timer", &pThis->pLinkUpTimer);
+    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3LinkUpTimer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
+                              "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
     AssertRCReturn(rc, rc);
 
 #ifdef VNET_TX_DELAY
     /* Create Transmit Delay Timer */
-    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
-                                "VirtioNet TX Delay Timer", &pThis->pTxTimerR3);
+    rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
+                              "VirtioNet TX Delay Timer", &pThis->hTxTimer);
     AssertRCReturn(rc, rc);
-    pThis->pTxTimerR0 = TMTimerR0Ptr(pThis->pTxTimerR3);
-    pThis->pTxTimerRC = TMTimerRCPtr(pThis->pTxTimerR3);
 
     pThis->u32i = pThis->u32AvgDiff = pThis->u32MaxDiff = 0;
@@ -2230 +2257 @@
 #endif /* VNET_TX_DELAY */
 
-    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->VPCI.IBase, &pThis->pDrvBase, "Network Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->VPCI.IBase, &pThisCC->pDrvBase, "Network Port");
     if (RT_SUCCESS(rc))
     {
@@ -2238 +2265 @@
                                        N_("A Domain Name Server (DNS) for NAT networking could not be determined. Ensure that your host is correctly connected to an ISP. If you ignore this warning the guest will not be able to perform nameserver lookups and it will probably observe delays if trying so"));
         }
-        pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);
-        AssertMsgReturn(pThis->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
+        pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
+        AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
                         VERR_PDM_MISSING_INTERFACE_BELOW);
 
-        vnetR3CreateTxThreadAndEvent(pDevIns, pThis);
+        vnetR3CreateTxThreadAndEvent(pDevIns, pThis, pThisCC);
     }
     else if (   rc == VERR_PDM_NO_ATTACHED_DRIVER
@@ -2256 +2283 @@
     AssertRCReturn(rc, rc);
 
-    rc = vnetIoCb_Reset(&pThis->VPCI);
+    ASMCompilerBarrier(); /* paranoia */
+    rc = vnetIoCb_Reset(pDevIns);
     AssertRCReturn(rc, rc);
 
+    /*
+     * Statistics and debug stuff.
+     */
     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);
@@ -2279 +2310 @@
 # endif
 
+    char szInfo[16];
+    RTStrPrintf(szInfo, sizeof(szInfo), pDevIns->iInstance ? "vionet%u" : "vionet", pDevIns->iInstance);
+    PDMDevHlpDBGFInfoRegisterArgv(pDevIns, szInfo, "virtio-net info", vnetR3Info);
+
     return VINF_SUCCESS;
 }
 
-#endif /* IN_RING3 */
+#else  /* !IN_RING3 */
+
+/**
+ * @callback_method_impl{PDMDEVREGR0,pfnConstruct}
+ */
+static DECLCALLBACK(int) vnetRZConstruct(PPDMDEVINS pDevIns)
+{
+    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
+    PVNETSTATE      pThis   = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
+    PVNETSTATECC    pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVNETSTATECC);
+
+    int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
+    AssertRCReturn(rc, rc);
+
+    rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPorts, vnetIOPortOut, vnetIOPortIn, NULL /*pvUser*/);
+    AssertRCReturn(rc, rc);
+
+    return vpciRZInit(pDevIns, &pThis->VPCI, &pThisCC->VPCI);
+}
+
+#endif /* !IN_RING3 */
 
 /**
@@ -2292 +2347 @@
     /* .uReserved0 = */             0,
     /* .szName = */                 "virtio-net",
-#ifdef VNET_GC_SUPPORT
-    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ,
-#else
-    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS,
-#endif
+    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ | PDM_DEVREG_FLAGS_NEW_STYLE,
     /* .fClass = */                 PDM_DEVREG_CLASS_NETWORK,
     /* .cMaxInstances = */          ~0U,
     /* .uSharedVersion = */         42,
     /* .cbInstanceShared = */       sizeof(VNETSTATE),
-    /* .cbInstanceCC = */           0,
-    /* .cbInstanceRC = */           0,
+    /* .cbInstanceCC = */           sizeof(VNETSTATECC),
+    /* .cbInstanceRC = */           sizeof(VNETSTATERC),
     /* .cMaxPciDevices = */         1,
     /* .cMaxMsixVectors = */        0,
@@ -2311 +2362 @@
     /* .pfnConstruct = */           vnetR3Construct,
     /* .pfnDestruct = */            vnetR3Destruct,
-    /* .pfnRelocate = */            vnetR3Relocate,
+    /* .pfnRelocate = */            NULL,
     /* .pfnMemSetup = */            NULL,
     /* .pfnPowerOn = */             NULL,
@@ -2333 +2384 @@
 #elif defined(IN_RING0)
     /* .pfnEarlyConstruct = */      NULL,
-    /* .pfnConstruct = */           NULL,
+    /* .pfnConstruct = */           vnetRZConstruct,
     /* .pfnDestruct = */            NULL,
     /* .pfnFinalDestruct = */       NULL,
@@ -2346 +2397 @@
     /* .pfnReserved7 = */           NULL,
 #elif defined(IN_RC)
-    /* .pfnConstruct = */           NULL,
+    /* .pfnConstruct = */           vnetRZConstruct,
     /* .pfnReserved0 = */           NULL,
     /* .pfnReserved1 = */           NULL,

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

@@ -25 +25 @@
 #include <iprt/uuid.h>
 #include <VBox/vmm/pdmdev.h>
+#include <VBox/AssertGuest.h>
 #include "Virtio.h"
 
-#define INSTANCE(pState) pState->szInstance
-#define IFACE_TO_STATE(pIface, ifaceName) ((VPCISTATE *)((char*)(pIface) - RT_UOFFSETOF(VPCISTATE, ifaceName)))
-
-#ifdef LOG_ENABLED
-# define QUEUENAME(s, q) (q->pcszName)
-#endif
-
-
-
-#ifndef VBOX_DEVICE_STRUCT_TESTCASE
-
-//RT_C_DECLS_BEGIN
-//RT_C_DECLS_END
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define INSTANCE(pThis) (pThis->szInstance)
 
 
@@ -68 +61 @@
 // }
 
-void vringReadDesc(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex, PVRINGDESC pDesc)
-{
-    //Log(("%s vringReadDesc: ring=%p idx=%u\n", INSTANCE(pState), pVRing, uIndex));
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
+void vringReadDesc(PPDMDEVINS pDevIns, PVRING pVRing, uint32_t uIndex, PVRINGDESC pDesc)
+{
+    //Log(("%s vringReadDesc: ring=%p idx=%u\n", INSTANCE(pThis), pVRing, uIndex));
+    PDMDevHlpPhysRead(pDevIns,
                       pVRing->addrDescriptors + sizeof(VRINGDESC) * (uIndex % pVRing->uSize),
                       pDesc, sizeof(VRINGDESC));
-}
-
-uint16_t vringReadAvail(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex)
-{
-    uint16_t tmp;
-
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVRing->addrAvail + RT_UOFFSETOF_DYN(VRINGAVAIL, auRing[uIndex % pVRing->uSize]),
+    /** @todo r=bird: Why exactly are we sometimes using PDMDevHlpPhysRead rather
+     *        than PDMDevHlpPCIPhysRead? */
+}
+
+uint16_t vringReadAvail(PPDMDEVINS pDevIns, PVRING pVRing, uint32_t uIndex)
+{
+    uint16_t tmp = 0;
+    PDMDevHlpPhysRead(pDevIns, pVRing->addrAvail + RT_UOFFSETOF_DYN(VRINGAVAIL, auRing[uIndex % pVRing->uSize]),
                       &tmp, sizeof(tmp));
     return tmp;
 }
 
-uint16_t vringReadAvailFlags(PVPCISTATE pState, PVRING pVRing)
-{
-    uint16_t tmp;
-
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVRing->addrAvail + RT_UOFFSETOF(VRINGAVAIL, uFlags),
-                      &tmp, sizeof(tmp));
+uint16_t vringReadAvailFlags(PPDMDEVINS pDevIns, PVRING pVRing)
+{
+    uint16_t tmp = 0;
+    PDMDevHlpPhysRead(pDevIns, pVRing->addrAvail + RT_UOFFSETOF(VRINGAVAIL, uFlags), &tmp, sizeof(tmp));
     return tmp;
 }
 
-void vringSetNotification(PVPCISTATE pState, PVRING pVRing, bool fEnabled)
-{
-    uint16_t tmp;
-
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uFlags),
-                      &tmp, sizeof(tmp));
+void vringSetNotification(PPDMDEVINS pDevIns, PVRING pVRing, bool fEnabled)
+{
+    uint16_t fState = 0;
+    PDMDevHlpPhysRead(pDevIns, pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uFlags), &fState, sizeof(fState));
 
     if (fEnabled)
-        tmp &= ~ VRINGUSED_F_NO_NOTIFY;
+        fState &= ~ VRINGUSED_F_NO_NOTIFY;
     else
-        tmp |= VRINGUSED_F_NO_NOTIFY;
-
-    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
-                          pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uFlags),
-                          &tmp, sizeof(tmp));
-}
-
-bool vqueueSkip(PVPCISTATE pState, PVQUEUE pQueue)
-{
-    if (vqueueIsEmpty(pState, pQueue))
+        fState |= VRINGUSED_F_NO_NOTIFY;
+
+    PDMDevHlpPCIPhysWrite(pDevIns, pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uFlags), &fState, sizeof(fState));
+}
+
+bool vqueueSkip(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue)
+{
+    if (vqueueIsEmpty(pDevIns, pQueue))
         return false;
 
-    Log2(("%s vqueueSkip: %s avail_idx=%u\n", INSTANCE(pState),
-          QUEUENAME(pState, pQueue), pQueue->uNextAvailIndex));
+    Log2(("%s vqueueSkip: %s avail_idx=%u\n", INSTANCE(pThis), pQueue->szName, pQueue->uNextAvailIndex));
     pQueue->uNextAvailIndex++;
     return true;
 }
 
-bool vqueueGet(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove)
-{
-    if (vqueueIsEmpty(pState, pQueue))
+bool vqueueGet(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove)
+{
+    if (vqueueIsEmpty(pDevIns, pQueue))
         return false;
 
     pElem->nIn = pElem->nOut = 0;
 
-    Log2(("%s vqueueGet: %s avail_idx=%u\n", INSTANCE(pState),
-          QUEUENAME(pState, pQueue), pQueue->uNextAvailIndex));
+    Log2(("%s vqueueGet: %s avail_idx=%u\n", INSTANCE(pThis), pQueue->szName, pQueue->uNextAvailIndex));
 
     VRINGDESC desc;
-    uint16_t  idx = vringReadAvail(pState, &pQueue->VRing, pQueue->uNextAvailIndex);
+    uint16_t  idx = vringReadAvail(pDevIns, &pQueue->VRing, pQueue->uNextAvailIndex);
     if (fRemove)
         pQueue->uNextAvailIndex++;
@@ -157 +140 @@
             {
                 LogRel(("%s: too many linked descriptors; check if the guest arranges descriptors in a loop.\n",
-                        INSTANCE(pState)));
+                        INSTANCE(pThis)));
                 if (ASMAtomicReadU32(&s_cMessages) != 1)
                     LogRel(("%s: (the above error has occured %u times so far)\n",
-                            INSTANCE(pState), ASMAtomicReadU32(&s_cMessages)));
+                            INSTANCE(pThis), ASMAtomicReadU32(&s_cMessages)));
                 ASMAtomicWriteU32(&s_cThreshold, ASMAtomicReadU32(&s_cThreshold) * 10);
             }
@@ -167 +150 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        vringReadDesc(pState, &pQueue->VRing, idx, &desc);
+        vringReadDesc(pDevIns, &pQueue->VRing, idx, &desc);
         if (desc.u16Flags & VRINGDESC_F_WRITE)
         {
-            Log2(("%s vqueueGet: %s IN  seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pState),
-                  QUEUENAME(pState, pQueue), pElem->nIn, idx, desc.u64Addr, desc.uLen));
+            Log2(("%s vqueueGet: %s IN  seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pThis),
+                  pQueue->szName, pElem->nIn, idx, desc.u64Addr, desc.uLen));
             pSeg = &pElem->aSegsIn[pElem->nIn++];
         }
         else
         {
-            Log2(("%s vqueueGet: %s OUT seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pState),
-                  QUEUENAME(pState, pQueue), pElem->nOut, idx, desc.u64Addr, desc.uLen));
+            Log2(("%s vqueueGet: %s OUT seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pThis),
+                  pQueue->szName, pElem->nOut, idx, desc.u64Addr, desc.uLen));
             pSeg = &pElem->aSegsOut[pElem->nOut++];
         }
@@ -188 +171 @@
     } while (desc.u16Flags & VRINGDESC_F_NEXT);
 
-    Log2(("%s vqueueGet: %s head_desc_idx=%u nIn=%u nOut=%u\n", INSTANCE(pState),
-          QUEUENAME(pState, pQueue), pElem->uIndex, pElem->nIn, pElem->nOut));
+    Log2(("%s vqueueGet: %s head_desc_idx=%u nIn=%u nOut=%u\n", INSTANCE(pThis),
+          pQueue->szName, pElem->uIndex, pElem->nIn, pElem->nOut));
     return true;
 }
 
-uint16_t vringReadUsedIndex(PVPCISTATE pState, PVRING pVRing)
-{
-    uint16_t tmp;
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uIndex),
-                      &tmp, sizeof(tmp));
+#ifdef LOG_ENABLED
+static uint16_t vringReadUsedIndex(PPDMDEVINS pDevIns, PVRING pVRing)
+{
+    uint16_t tmp = 0;
+    PDMDevHlpPhysRead(pDevIns, pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uIndex), &tmp, sizeof(tmp));
     return tmp;
 }
-
-void vringWriteUsedIndex(PVPCISTATE pState, PVRING pVRing, uint16_t u16Value)
-{
-    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
+#endif
+
+static void vringWriteUsedIndex(PPDMDEVINS pDevIns, PVRING pVRing, uint16_t u16Value)
+{
+    PDMDevHlpPCIPhysWrite(pDevIns,
                           pVRing->addrUsed + RT_UOFFSETOF(VRINGUSED, uIndex),
                           &u16Value, sizeof(u16Value));
 }
 
-void vringWriteUsedElem(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex, uint32_t uId, uint32_t uLen)
+static void vringWriteUsedElem(PPDMDEVINS pDevIns, PVRING pVRing, uint32_t uIndex, uint32_t uId, uint32_t uLen)
 {
     VRINGUSEDELEM elem;
@@ -215 +198 @@
     elem.uId = uId;
     elem.uLen = uLen;
-    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
+    PDMDevHlpPCIPhysWrite(pDevIns,
                           pVRing->addrUsed + RT_UOFFSETOF_DYN(VRINGUSED, aRing[uIndex % pVRing->uSize]),
                           &elem, sizeof(elem));
@@ -221 +204 @@
 
 
-void vqueuePut(PVPCISTATE pState, PVQUEUE pQueue,
-               PVQUEUEELEM pElem, uint32_t uTotalLen, uint32_t uReserved)
-{
-    Log2(("%s vqueuePut: %s"
-          " desc_idx=%u acb=%u (%u)\n",
-          INSTANCE(pState), QUEUENAME(pState, pQueue),
-          pElem->uIndex, uTotalLen, uReserved));
+void vqueuePut(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t uTotalLen, uint32_t uReserved)
+{
+    Log2(("%s vqueuePut: %s desc_idx=%u acb=%u (%u)\n", INSTANCE(pThis), pQueue->szName, pElem->uIndex, uTotalLen, uReserved));
 
     Assert(uReserved < uTotalLen);
@@ -252 +231 @@
         if (pElem->aSegsIn[i].pv != NULL)
         {
-            Log2(("%s vqueuePut: %s"
-                  " used_idx=%u seg=%u addr=%p pv=%p cb=%u acb=%u\n",
-                  INSTANCE(pState), QUEUENAME(pState, pQueue),
-                  pQueue->uNextUsedIndex, i,
-                  (void *)pElem->aSegsIn[i].addr, pElem->aSegsIn[i].pv,
-                  pElem->aSegsIn[i].cb, cbSegLen));
-
-            PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
+            Log2(("%s vqueuePut: %s used_idx=%u seg=%u addr=%RGp pv=%p cb=%u acb=%u\n", INSTANCE(pThis), pQueue->szName,
+                  pQueue->uNextUsedIndex, i, pElem->aSegsIn[i].addr, pElem->aSegsIn[i].pv, pElem->aSegsIn[i].cb, cbSegLen));
+
+            PDMDevHlpPCIPhysWrite(pDevIns,
                                   pElem->aSegsIn[i].addr + cbSkip,
                                   pElem->aSegsIn[i].pv,
@@ -269 +244 @@
     }
 
-    Log2(("%s vqueuePut: %s"
-          " used_idx=%u guest_used_idx=%u id=%u len=%u\n",
-          INSTANCE(pState), QUEUENAME(pState, pQueue),
-          pQueue->uNextUsedIndex, vringReadUsedIndex(pState, &pQueue->VRing),
-          pElem->uIndex, uTotalLen));
-
-    vringWriteUsedElem(pState, &pQueue->VRing,
+    Log2(("%s vqueuePut: %s used_idx=%u guest_used_idx=%u id=%u len=%u\n", INSTANCE(pThis), pQueue->szName,
+          pQueue->uNextUsedIndex, vringReadUsedIndex(pDevIns, &pQueue->VRing), pElem->uIndex, uTotalLen));
+
+    vringWriteUsedElem(pDevIns, &pQueue->VRing,
                        pQueue->uNextUsedIndex++,
                        pElem->uIndex, uTotalLen);
@@ -281 +253 @@
 
 
-void vqueueNotify(PVPCISTATE pState, PVQUEUE pQueue)
-{
-    LogFlow(("%s vqueueNotify: %s availFlags=%x guestFeatures=%x vqueue is %sempty\n",
-             INSTANCE(pState), QUEUENAME(pState, pQueue),
-             vringReadAvailFlags(pState, &pQueue->VRing),
-             pState->uGuestFeatures, vqueueIsEmpty(pState, pQueue)?"":"not "));
-    if (!(vringReadAvailFlags(pState, &pQueue->VRing) & VRINGAVAIL_F_NO_INTERRUPT)
-        || ((pState->uGuestFeatures & VPCI_F_NOTIFY_ON_EMPTY) && vqueueIsEmpty(pState, pQueue)))
-    {
-        int rc = vpciRaiseInterrupt(pState, VERR_INTERNAL_ERROR, VPCI_ISR_QUEUE);
+void vqueueNotify(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue)
+{
+    uint16_t const fAvail = vringReadAvailFlags(pDevIns, &pQueue->VRing);
+    LogFlow(("%s vqueueNotify: %s availFlags=%x guestFeatures=%x vqueue is %sempty\n", INSTANCE(pThis), pQueue->szName,
+             fAvail, pThis->uGuestFeatures, vqueueIsEmpty(pDevIns, pQueue)?"":"not "));
+    if (   !(fAvail & VRINGAVAIL_F_NO_INTERRUPT)
+        || ((pThis->uGuestFeatures & VPCI_F_NOTIFY_ON_EMPTY) && vqueueIsEmpty(pDevIns, pQueue)))
+    {
+        int rc = vpciRaiseInterrupt(pDevIns, pThis, VERR_INTERNAL_ERROR, VPCI_ISR_QUEUE);
         if (RT_FAILURE(rc))
-            Log(("%s vqueueNotify: Failed to raise an interrupt (%Rrc).\n", INSTANCE(pState), rc));
+            Log(("%s vqueueNotify: Failed to raise an interrupt (%Rrc).\n", INSTANCE(pThis), rc));
     }
     else
-    {
-        STAM_COUNTER_INC(&pState->StatIntsSkipped);
-    }
-
-}
-
-void vqueueSync(PVPCISTATE pState, PVQUEUE pQueue)
-{
-    Log2(("%s vqueueSync: %s old_used_idx=%u new_used_idx=%u\n", INSTANCE(pState),
-          QUEUENAME(pState, pQueue), vringReadUsedIndex(pState, &pQueue->VRing), pQueue->uNextUsedIndex));
-    vringWriteUsedIndex(pState, &pQueue->VRing, pQueue->uNextUsedIndex);
-    vqueueNotify(pState, pQueue);
+        STAM_COUNTER_INC(&pThis->StatIntsSkipped);
+
+}
+
+void vqueueSync(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue)
+{
+    Log2(("%s vqueueSync: %s old_used_idx=%u new_used_idx=%u\n", INSTANCE(pThis),
+          pQueue->szName, vringReadUsedIndex(pDevIns, &pQueue->VRing), pQueue->uNextUsedIndex));
+    vringWriteUsedIndex(pDevIns, &pQueue->VRing, pQueue->uNextUsedIndex);
+    vqueueNotify(pDevIns, pThis, pQueue);
 }
 
@@ -313 +282 @@
  * Raise interrupt.
  *
- * @param   pState      The device state structure.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared virtio core instance data.
  * @param   rcBusy      Status code to return when the critical section is busy.
  * @param   u8IntCause  Interrupt cause bit mask to set in PCI ISR port.
  */
-int vpciRaiseInterrupt(VPCISTATE *pState, int rcBusy, uint8_t u8IntCause)
+int vpciRaiseInterrupt(PPDMDEVINS pDevIns, PVPCISTATE pThis, int rcBusy, uint8_t u8IntCause)
 {
     RT_NOREF_PV(rcBusy);
-    // int rc = vpciCsEnter(pState, rcBusy);
+    // int rc = vpciCsEnter(pThis, rcBusy);
     // if (RT_UNLIKELY(rc != VINF_SUCCESS))
     //     return rc;
 
-    STAM_COUNTER_INC(&pState->StatIntsRaised);
-    LogFlow(("%s vpciRaiseInterrupt: u8IntCause=%x\n",
-             INSTANCE(pState), u8IntCause));
-
-    pState->uISR |= u8IntCause;
-    PDMDevHlpPCISetIrq(pState->CTX_SUFF(pDevIns), 0, 1);
-    // vpciCsLeave(pState);
+    STAM_COUNTER_INC(&pThis->StatIntsRaised);
+    LogFlow(("%s vpciRaiseInterrupt: u8IntCause=%x\n", INSTANCE(pThis), u8IntCause));
+
+    pThis->uISR |= u8IntCause;
+    PDMDevHlpPCISetIrq(pDevIns, 0, 1);
+    // vpciCsLeave(pThis);
     return VINF_SUCCESS;
 }
@@ -337 +306 @@
  * Lower interrupt.
  *
- * @param   pState      The device state structure.
- */
-static void vpciLowerInterrupt(VPCISTATE *pState)
-{
-    LogFlow(("%s vpciLowerInterrupt\n", INSTANCE(pState)));
-    PDMDevHlpPCISetIrq(pState->CTX_SUFF(pDevIns), 0, 0);
-}
-
-
-void vpciReset(PVPCISTATE pState)
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared virtio core instance data.
+ */
+static void vpciLowerInterrupt(PPDMDEVINS pDevIns, PVPCISTATE pThis)
+{
+    LogFlow(("%s vpciLowerInterrupt\n", INSTANCE(pThis)));
+    RT_NOREF(pThis);
+    PDMDevHlpPCISetIrq(pDevIns, 0, 0);
+}
+
+
+void vpciReset(PPDMDEVINS pDevIns, PVPCISTATE pThis)
 {
     /* No interrupts should survive device reset, see @bugref(9556). */
-    if (pState->uISR)
-        vpciLowerInterrupt(pState);
-
-    pState->uGuestFeatures = 0;
-    pState->uQueueSelector = 0;
-    pState->uStatus        = 0;
-    pState->uISR           = 0;
-
-    for (unsigned i = 0; i < pState->nQueues; i++)
-        vqueueReset(&pState->Queues[i]);
-}
-
-
-DECLINLINE(uint32_t) vpciGetHostFeatures(PVPCISTATE pState, PCVPCIIOCALLBACKS  pCallbacks)
-{
-    return pCallbacks->pfnGetHostFeatures(pState)
+    if (pThis->uISR)
+        vpciLowerInterrupt(pDevIns, pThis);
+
+    pThis->uGuestFeatures = 0;
+    pThis->uQueueSelector = 0;
+    pThis->uStatus        = 0;
+    pThis->uISR           = 0;
+
+    for (unsigned i = 0; i < pThis->cQueues; i++)
+        vqueueReset(&pThis->Queues[i]);
+}
+
+
+DECLINLINE(uint32_t) vpciGetHostFeatures(PVPCISTATE pThis, PCVPCIIOCALLBACKS  pCallbacks)
+{
+    return pCallbacks->pfnGetHostFeatures(pThis)
         | VPCI_F_NOTIFY_ON_EMPTY;
 }
@@ -374 +345 @@
  *
  * @param   pDevIns     The device instance.
- * @param   pState      The VPCI core state.
- * @param   Port        Port number used for the IN operation.
+ * @param   pThis       The shared virtio core instance data.
+ * @param   offPort     The offset into the I/O range of the port being read.
  * @param   pu32        Where to store the result.
  * @param   cb          Number of bytes read.
@@ -382 +353 @@
  */
 int vpciIOPortIn(PPDMDEVINS         pDevIns,
-                 PVPCISTATE         pState,
-                 RTIOPORT           Port,
+                 PVPCISTATE         pThis,
+                 RTIOPORT           offPort,
                  uint32_t          *pu32,
                  unsigned           cb,
                  PCVPCIIOCALLBACKS  pCallbacks)
 {
-    STAM_PROFILE_ADV_START(&pState->CTX_SUFF(StatIORead), a);
-    int rc = VINF_SUCCESS;
+    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF(StatIORead), a);
 
     /*
@@ -400 +370 @@
      * holding cs transmitting queued packets.
      *
-    rc = vpciCsEnter(pState, VINF_IOM_R3_IOPORT_READ);
+    int rc = vpciCsEnter(pThis, VINF_IOM_R3_IOPORT_READ);
     if (RT_UNLIKELY(rc != VINF_SUCCESS))
     {
-        STAM_PROFILE_ADV_STOP(&pState->CTX_SUFF(StatIORead), a);
+        STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF(StatIORead), a);
         return rc;
         }*/
-
-    Port -= pState->IOPortBase;
-    switch (Port)
+    int rc = VINF_SUCCESS;
+
+    switch (offPort)
     {
         case VPCI_HOST_FEATURES:
             /* Tell the guest what features we support. */
-            *pu32 = vpciGetHostFeatures(pState, pCallbacks) | VPCI_F_BAD_FEATURE;
+            ASSERT_GUEST_MSG(cb == 4, ("%d\n", cb));
+            *pu32 = vpciGetHostFeatures(pThis, pCallbacks) | VPCI_F_BAD_FEATURE;
             break;
 
         case VPCI_GUEST_FEATURES:
-            *pu32 = pState->uGuestFeatures;
+            ASSERT_GUEST_MSG(cb == 4, ("%d\n", cb));
+            *pu32 = pThis->uGuestFeatures;
             break;
 
         case VPCI_QUEUE_PFN:
-            *pu32 = pState->Queues[pState->uQueueSelector].uPageNumber;
+            ASSERT_GUEST_MSG(cb == 4, ("%d\n", cb));
+            *pu32 = pThis->Queues[pThis->uQueueSelector].uPageNumber;
             break;
 
         case VPCI_QUEUE_NUM:
-            Assert(cb == 2);
-            *(uint16_t*)pu32 = pState->Queues[pState->uQueueSelector].VRing.uSize;
+            ASSERT_GUEST_MSG(cb == 2, ("%d\n", cb));
+            *pu32 = pThis->Queues[pThis->uQueueSelector].VRing.uSize;
             break;
 
         case VPCI_QUEUE_SEL:
-            Assert(cb == 2);
-            *(uint16_t*)pu32 = pState->uQueueSelector;
+            ASSERT_GUEST_MSG(cb == 2, ("%d\n", cb));
+            *pu32 = pThis->uQueueSelector;
             break;
 
         case VPCI_STATUS:
-            Assert(cb == 1);
-            *(uint8_t*)pu32 = pState->uStatus;
+            ASSERT_GUEST_MSG(cb == 1, ("%d\n", cb));
+            *pu32 = pThis->uStatus;
             break;
 
         case VPCI_ISR:
-            Assert(cb == 1);
-            *(uint8_t*)pu32 = pState->uISR;
-            pState->uISR = 0; /* read clears all interrupts */
-            vpciLowerInterrupt(pState);
+            ASSERT_GUEST_MSG(cb == 1, ("%d\n", cb));
+            *pu32 = pThis->uISR;
+            pThis->uISR = 0; /* read clears all interrupts */
+            vpciLowerInterrupt(pDevIns, pThis);
             break;
 
         default:
-            if (Port >= VPCI_CONFIG)
-                rc = pCallbacks->pfnGetConfig(pState, Port - VPCI_CONFIG, cb, pu32);
+            if (offPort >= VPCI_CONFIG)
+                rc = pCallbacks->pfnGetConfig(pThis, offPort - VPCI_CONFIG, cb, pu32);
             else
             {
-                *pu32 = 0xFFFFFFFF;
+                *pu32 = UINT32_MAX;
                 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "%s vpciIOPortIn: no valid port at offset port=%RTiop cb=%08x\n",
-                                       INSTANCE(pState), Port, cb);
+                                       INSTANCE(pThis), offPort, cb);
             }
             break;
     }
-    Log3(("%s vpciIOPortIn:  At %RTiop in  %0*x\n", INSTANCE(pState), Port, cb*2, *pu32));
-    STAM_PROFILE_ADV_STOP(&pState->CTX_SUFF(StatIORead), a);
-    //vpciCsLeave(pState);
+    Log3(("%s vpciIOPortIn:  At %RTiop in  %0*x\n", INSTANCE(pThis), offPort, cb*2, *pu32));
+
+    //vpciCsLeave(pThis);
+
+    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF(StatIORead), a);
     return rc;
 }
@@ -469 +444 @@
  *
  * @param   pDevIns     The device instance.
- * @param   pState      The VPCI core state.
- * @param   Port        Port number used for the IN operation.
+ * @param   pThis       The shared virtio core instance data.
+ * @param   offPort     The offset into the I/O range of the port being written.
  * @param   u32         The value to output.
  * @param   cb          The value size in bytes.
@@ -477 +452 @@
  */
 int vpciIOPortOut(PPDMDEVINS         pDevIns,
-                  PVPCISTATE         pState,
-                  RTIOPORT           Port,
+                  PVPCISTATE         pThis,
+                  PVPCISTATECC       pThisCC,
+                  RTIOPORT           offPort,
                   uint32_t           u32,
                   unsigned           cb,
                   PCVPCIIOCALLBACKS  pCallbacks)
 {
-    STAM_PROFILE_ADV_START(&pState->CTX_SUFF(StatIOWrite), a);
+    STAM_PROFILE_ADV_START(&pThis->CTX_SUFF(StatIOWrite), a);
     int  rc = VINF_SUCCESS;
     bool fHasBecomeReady;
 
-    Port -= pState->IOPortBase;
-    Log3(("%s virtioIOPortOut: At %RTiop out          %0*x\n", INSTANCE(pState), Port, cb*2, u32));
-
-    switch (Port)
+    Log3(("%s virtioIOPortOut: At offPort=%RTiop out  %0*x\n", INSTANCE(pThis), offPort, cb*2, u32));
+
+    switch (offPort)
     {
         case VPCI_GUEST_FEATURES:
         {
-            const uint32_t fHostFeatures = vpciGetHostFeatures(pState, pCallbacks);
+            const uint32_t fHostFeatures = vpciGetHostFeatures(pThis, pCallbacks);
 
             if (RT_LIKELY((u32 & ~fHostFeatures) == 0))
-            {
-                pState->uGuestFeatures = u32;
-            }
+                pThis->uGuestFeatures = u32;
             else
             {
@@ -510 +483 @@
                 {
                     Log(("%s WARNING! Guest failed to negotiate properly (guest=%x)\n",
-                         INSTANCE(pState), u32));
-                    pState->uGuestFeatures = pCallbacks->pfnGetHostMinimalFeatures(pState);
+                         INSTANCE(pThis), u32));
+                    pThis->uGuestFeatures = pCallbacks->pfnGetHostMinimalFeatures(pThis);
                 }
                 else
                 {
                     Log(("%s Guest asked for features host does not support! (host=%x guest=%x)\n",
-                         INSTANCE(pState), fHostFeatures, u32));
-                    pState->uGuestFeatures = u32 & fHostFeatures;
+                         INSTANCE(pThis), fHostFeatures, u32));
+                    pThis->uGuestFeatures = u32 & fHostFeatures;
                 }
             }
-            pCallbacks->pfnSetHostFeatures(pState, pState->uGuestFeatures);
+            pCallbacks->pfnSetHostFeatures(pThis, pThis->uGuestFeatures);
             break;
         }
@@ -531 +504 @@
              * VIRTIO_PCI_QUEUE_NUM.
              */
-            pState->Queues[pState->uQueueSelector].uPageNumber = u32;
+            pThis->Queues[pThis->uQueueSelector].uPageNumber = u32;
             if (u32)
-                vqueueInit(&pState->Queues[pState->uQueueSelector], u32);
+                vqueueInit(&pThis->Queues[pThis->uQueueSelector], u32);
             else
-                rc = pCallbacks->pfnReset(pState);
+                rc = pCallbacks->pfnReset(pDevIns);
             break;
 
         case VPCI_QUEUE_SEL:
-            Assert(cb == 2);
+            ASSERT_GUEST_MSG(cb == 2, ("cb=%u\n", cb));
             u32 &= 0xFFFF;
-            if (u32 < pState->nQueues)
-                pState->uQueueSelector = u32;
+            if (u32 < pThis->cQueues)
+                pThis->uQueueSelector = u32;
             else
-                Log3(("%s vpciIOPortOut: Invalid queue selector %08x\n", INSTANCE(pState), u32));
+                Log3(("%s vpciIOPortOut: Invalid queue selector %08x\n", INSTANCE(pThis), u32));
             break;
 
         case VPCI_QUEUE_NOTIFY:
 #ifdef IN_RING3
-            Assert(cb == 2);
+            ASSERT_GUEST_MSG(cb == 2, ("cb=%u\n", cb));
             u32 &= 0xFFFF;
-            if (u32 < pState->nQueues)
+            if (u32 < pThis->cQueues)
             {
                 RT_UNTRUSTED_VALIDATED_FENCE();
-                if (pState->Queues[u32].VRing.addrDescriptors)
+                if (pThis->Queues[u32].VRing.addrDescriptors)
                 {
-                    // rc = vpciCsEnter(pState, VERR_SEM_BUSY);
+
+                    // rc = vpciCsEnter(pThis, VERR_SEM_BUSY);
                     // if (RT_LIKELY(rc == VINF_SUCCESS))
                     // {
-                        pState->Queues[u32].pfnCallback(pDevIns, pState, &pState->Queues[u32]);
-                    //     vpciCsLeave(pState);
+                        pThisCC->Queues[u32].pfnCallback(pDevIns, &pThis->Queues[u32]);
+                    //     vpciCsLeave(pThis);
                     // }
                 }
                 else
                     Log(("%s The queue (#%d) being notified has not been initialized.\n",
-                         INSTANCE(pState), u32));
+                         INSTANCE(pThis), u32));
             }
             else
-                Log(("%s Invalid queue number (%d)\n", INSTANCE(pState), u32));
+                Log(("%s Invalid queue number (%d)\n", INSTANCE(pThis), u32));
 #else
+            RT_NOREF(pThisCC);
             rc = VINF_IOM_R3_IOPORT_WRITE;
 #endif
@@ -575 +550 @@
 
         case VPCI_STATUS:
-            Assert(cb == 1);
+            ASSERT_GUEST_MSG(cb == 1, ("cb=%u\n", cb));
             u32 &= 0xFF;
-            fHasBecomeReady = !(pState->uStatus & VPCI_STATUS_DRV_OK) && (u32 & VPCI_STATUS_DRV_OK);
-            pState->uStatus = u32;
+            fHasBecomeReady = !(pThis->uStatus & VPCI_STATUS_DRV_OK) && (u32 & VPCI_STATUS_DRV_OK);
+            pThis->uStatus = u32;
             /* Writing 0 to the status port triggers device reset. */
             if (u32 == 0)
-                rc = pCallbacks->pfnReset(pState);
+                rc = pCallbacks->pfnReset(pDevIns);
             else if (fHasBecomeReady)
             {
@@ -592 +567 @@
                 PDMPciDevSetCommand(pPciDev, PDMPciDevGetCommand(pPciDev) | PCI_COMMAND_BUSMASTER);
 
-                pCallbacks->pfnReady(pState);
+                pCallbacks->pfnReady(pDevIns);
             }
             break;
 
         default:
-            if (Port >= VPCI_CONFIG)
-                rc = pCallbacks->pfnSetConfig(pState, Port - VPCI_CONFIG, cb, &u32);
+            if (offPort >= VPCI_CONFIG)
+                rc = pCallbacks->pfnSetConfig(pThis, offPort - VPCI_CONFIG, cb, &u32);
             else
-                rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "%s vpciIOPortOut: no valid port at offset Port=%RTiop cb=%08x\n",
-                                       INSTANCE(pState), Port, cb);
+                rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "%s vpciIOPortOut: no valid port at offset offPort=%RTiop cb=%08x\n",
+                                       INSTANCE(pThis), offPort, cb);
             break;
     }
 
-    STAM_PROFILE_ADV_STOP(&pState->CTX_SUFF(StatIOWrite), a);
+    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF(StatIOWrite), a);
     return rc;
 }
@@ -612 +587 @@
 
 /**
- * @interface_method_impl{PDMIBASE,pfnQueryInterface}
- */
-void *vpciQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
-{
-    VPCISTATE *pThis = IFACE_TO_STATE(pInterface, IBase);
-    Assert(&pThis->IBase == pInterface);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
+ * Handles common IBase.pfnQueryInterface requests.
+ */
+void *vpciR3QueryInterface(PVPCISTATECC pThisCC, const char *pszIID)
+{
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
     return NULL;
 }
 
 /**
- * Gets the pointer to the status LED of a unit.
+ * @interface_method_impl{PDMILEDPORTS,pfnQueryStatusLed}
+ */
+static DECLCALLBACK(int) vpciR3QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
+{
+    PVPCISTATECC pThisCC = RT_FROM_MEMBER(pInterface, VPCISTATECC, ILeds);
+    if (iLUN == 0)
+    {
+        *ppLed = &pThisCC->pShared->led;
+        return VINF_SUCCESS;
+    }
+    return VERR_PDM_LUN_NOT_FOUND;
+}
+
+/**
+ * Turns on/off the write status LED.
  *
  * @returns VBox status code.
- * @param   pInterface      Pointer to the interface structure.
- * @param   iLUN            The unit which status LED we desire.
- * @param   ppLed           Where to store the LED pointer.
- * @thread  EMT
- */
-static DECLCALLBACK(int) vpciQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
-{
-    VPCISTATE *pState = IFACE_TO_STATE(pInterface, ILeds);
-    int        rc     = VERR_PDM_LUN_NOT_FOUND;
-
-    if (iLUN == 0)
-    {
-        *ppLed = &pState->led;
-        rc     = VINF_SUCCESS;
-    }
-    return rc;
-}
-
-/**
- * Turns on/off the write status LED.
+ * @param   pThis          Pointer to the device state structure.
+ * @param   fOn             New LED state.
+ */
+void vpciR3SetWriteLed(PVPCISTATE pThis, bool fOn)
+{
+    LogFlow(("%s vpciR3SetWriteLed: %s\n", INSTANCE(pThis), fOn?"on":"off"));
+    if (fOn)
+        pThis->led.Asserted.s.fWriting = pThis->led.Actual.s.fWriting = 1;
+    else
+        pThis->led.Actual.s.fWriting = fOn;
+}
+
+/**
+ * Turns on/off the read status LED.
  *
  * @returns VBox status code.
- * @param   pState          Pointer to the device state structure.
+ * @param   pThis          Pointer to the device state structure.
  * @param   fOn             New LED state.
  */
-void vpciSetWriteLed(PVPCISTATE pState, bool fOn)
-{
-    LogFlow(("%s vpciSetWriteLed: %s\n", INSTANCE(pState), fOn?"on":"off"));
+void vpciR3SetReadLed(PVPCISTATE pThis, bool fOn)
+{
+    LogFlow(("%s vpciR3SetReadLed: %s\n", INSTANCE(pThis), fOn?"on":"off"));
     if (fOn)
-        pState->led.Asserted.s.fWriting = pState->led.Actual.s.fWriting = 1;
+        pThis->led.Asserted.s.fReading = pThis->led.Actual.s.fReading = 1;
     else
-        pState->led.Actual.s.fWriting = fOn;
-}
-
-/**
- * Turns on/off the read status LED.
- *
- * @returns VBox status code.
- * @param   pState          Pointer to the device state structure.
- * @param   fOn             New LED state.
- */
-void vpciSetReadLed(PVPCISTATE pState, bool fOn)
-{
-    LogFlow(("%s vpciSetReadLed: %s\n", INSTANCE(pState), fOn?"on":"off"));
-    if (fOn)
-        pState->led.Asserted.s.fReading = pState->led.Actual.s.fReading = 1;
-    else
-        pState->led.Actual.s.fReading = fOn;
-}
-
-
-#if 0 /* unused */
+        pThis->led.Actual.s.fReading = fOn;
+}
+
+
+# if 0 /* unused */
 /**
  * Sets 32-bit register in PCI configuration space.
@@ -692 +656 @@
     *(uint32_t*)&refPciDev.config[uOffset] = u32Value;
 }
-#endif /* unused */
-
-
-#ifdef DEBUG
-static void vpciDumpState(PVPCISTATE pState, const char *pcszCaller)
-{
-    Log2(("vpciDumpState: (called from %s)\n"
-          "  uGuestFeatures = 0x%08x\n"
-          "  uQueueSelector = 0x%04x\n"
-          "  uStatus        = 0x%02x\n"
-          "  uISR           = 0x%02x\n",
-          pcszCaller,
-          pState->uGuestFeatures,
-          pState->uQueueSelector,
-          pState->uStatus,
-          pState->uISR));
-
-    for (unsigned i = 0; i < pState->nQueues; i++)
-        Log2((" %s queue:\n"
-              "  VRing.uSize           = %u\n"
-              "  VRing.addrDescriptors = %p\n"
-              "  VRing.addrAvail       = %p\n"
-              "  VRing.addrUsed        = %p\n"
-              "  uNextAvailIndex       = %u\n"
-              "  uNextUsedIndex        = %u\n"
-              "  uPageNumber           = %x\n",
-              pState->Queues[i].pcszName,
-              pState->Queues[i].VRing.uSize,
-              pState->Queues[i].VRing.addrDescriptors,
-              pState->Queues[i].VRing.addrAvail,
-              pState->Queues[i].VRing.addrUsed,
-              pState->Queues[i].uNextAvailIndex,
-              pState->Queues[i].uNextUsedIndex,
-              pState->Queues[i].uPageNumber));
-}
-#else
-# define vpciDumpState(x, s)  do {} while (0)
-#endif
-
-/**
- * Saves the state of device.
+# endif /* unused */
+
+
+/**
+ * Dumps the state (useful for both logging and info items).
+ */
+void vpcR3iDumpStateWorker(PVPCISTATE pThis, PCDBGFINFOHLP pHlp)
+{
+
+    pHlp->pfnPrintf(pHlp,
+                    "  uGuestFeatures = 0x%08x\n"
+                    "  uQueueSelector = 0x%04x\n"
+                    "  uStatus        = 0x%02x\n"
+                    "  uISR           = 0x%02x\n",
+                    pThis->uGuestFeatures,
+                    pThis->uQueueSelector,
+                    pThis->uStatus,
+                    pThis->uISR);
+
+    for (unsigned i = 0; i < pThis->cQueues; i++)
+        pHlp->pfnPrintf(pHlp,
+                        " %s queue:\n"
+                        "  VRing.uSize           = %u\n"
+                        "  VRing.addrDescriptors = %p\n"
+                        "  VRing.addrAvail       = %p\n"
+                        "  VRing.addrUsed        = %p\n"
+                        "  uNextAvailIndex       = %u\n"
+                        "  uNextUsedIndex        = %u\n"
+                        "  uPageNumber           = %x\n",
+                        pThis->Queues[i].szName,
+                        pThis->Queues[i].VRing.uSize,
+                        pThis->Queues[i].VRing.addrDescriptors,
+                        pThis->Queues[i].VRing.addrAvail,
+                        pThis->Queues[i].VRing.addrUsed,
+                        pThis->Queues[i].uNextAvailIndex,
+                        pThis->Queues[i].uNextUsedIndex,
+                        pThis->Queues[i].uPageNumber);
+}
+
+# ifdef LOG_ENABLED
+void vpciR3DumpState(PVPCISTATE pThis, const char *pcszCaller)
+{
+    if (LogIs2Enabled())
+    {
+        Log2(("vpciR3DumpState: (called from %s)\n", pcszCaller));
+        vpcR3iDumpStateWorker(pThis, DBGFR3InfoLogHlp());
+    }
+}
+# else
+#  define vpciR3DumpState(x, s)  do {} while (0)
+# endif
+
+/**
+ * Saved the core virtio state.
  *
  * @returns VBox status code.
- * @param   pDevIns     The device instance.
+ * @param   pHlp        The device helpers.
+ * @param   pThis       The shared virtio core instance data.
  * @param   pSSM        The handle to the saved state.
  */
-int vpciSaveExec(PVPCISTATE pState, PSSMHANDLE pSSM)
-{
-    int rc;
-
-    vpciDumpState(pState, "vpciSaveExec");
-
-    rc = SSMR3PutU32(pSSM, pState->uGuestFeatures);
+int vpciR3SaveExec(PCPDMDEVHLPR3 pHlp, PVPCISTATE pThis, PSSMHANDLE pSSM)
+{
+    vpciR3DumpState(pThis, "vpciR3SaveExec");
+
+    pHlp->pfnSSMPutU32(pSSM, pThis->uGuestFeatures);
+    pHlp->pfnSSMPutU16(pSSM, pThis->uQueueSelector);
+    pHlp->pfnSSMPutU8( pSSM, pThis->uStatus);
+    pHlp->pfnSSMPutU8( pSSM, pThis->uISR);
+
+    /* Save queue states */
+    int rc = pHlp->pfnSSMPutU32(pSSM, pThis->cQueues);
     AssertRCReturn(rc, rc);
-    rc = SSMR3PutU16(pSSM, pState->uQueueSelector);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutU8( pSSM, pState->uStatus);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutU8( pSSM, pState->uISR);
-    AssertRCReturn(rc, rc);
-
-    /* Save queue states */
-    rc = SSMR3PutU32(pSSM, pState->nQueues);
-    AssertRCReturn(rc, rc);
-    for (unsigned i = 0; i < pState->nQueues; i++)
-    {
-        rc = SSMR3PutU16(pSSM, pState->Queues[i].VRing.uSize);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3PutU32(pSSM, pState->Queues[i].uPageNumber);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3PutU16(pSSM, pState->Queues[i].uNextAvailIndex);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3PutU16(pSSM, pState->Queues[i].uNextUsedIndex);
+    for (unsigned i = 0; i < pThis->cQueues; i++)
+    {
+        pHlp->pfnSSMPutU16(pSSM, pThis->Queues[i].VRing.uSize);
+        pHlp->pfnSSMPutU32(pSSM, pThis->Queues[i].uPageNumber);
+        pHlp->pfnSSMPutU16(pSSM, pThis->Queues[i].uNextAvailIndex);
+        rc = pHlp->pfnSSMPutU16(pSSM, pThis->Queues[i].uNextUsedIndex);
         AssertRCReturn(rc, rc);
     }
@@ -775 +744 @@
  *
  * @returns VBox status code.
- * @param   pDevIns     The device instance.
+ * @param   pHlp        The device helpers.
+ * @param   pThis       The shared virtio core instance data.
  * @param   pSSM        The handle to the saved state.
  * @param   uVersion    The data unit version number.
  * @param   uPass       The data pass.
- */
-int vpciLoadExec(PVPCISTATE pState, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t nQueues)
+ * @param   cQueues     The default queue count (for old states).
+ */
+int vpciR3LoadExec(PCPDMDEVHLPR3 pHlp, PVPCISTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t cQueues)
 {
     int rc;
@@ -787 +758 @@
     {
         /* Restore state data */
-        rc = SSMR3GetU32(pSSM, &pState->uGuestFeatures);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3GetU16(pSSM, &pState->uQueueSelector);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3GetU8( pSSM, &pState->uStatus);
-        AssertRCReturn(rc, rc);
-        rc = SSMR3GetU8( pSSM, &pState->uISR);
-        AssertRCReturn(rc, rc);
+        pHlp->pfnSSMGetU32(pSSM, &pThis->uGuestFeatures);
+        pHlp->pfnSSMGetU16(pSSM, &pThis->uQueueSelector);
+        pHlp->pfnSSMGetU8( pSSM, &pThis->uStatus);
+        pHlp->pfnSSMGetU8( pSSM, &pThis->uISR);
 
         /* Restore queues */
         if (uVersion > VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1)
         {
-            rc = SSMR3GetU32(pSSM, &pState->nQueues);
+            rc = pHlp->pfnSSMGetU32(pSSM, &pThis->cQueues);
             AssertRCReturn(rc, rc);
         }
         else
-            pState->nQueues = nQueues;
-        AssertLogRelMsgReturn(pState->nQueues <= VIRTIO_MAX_NQUEUES, ("%#x\n", pState->nQueues), VERR_SSM_LOAD_CONFIG_MISMATCH);
-        AssertLogRelMsgReturn(pState->uQueueSelector < pState->nQueues || (pState->nQueues == 0 && pState->uQueueSelector),
-                              ("uQueueSelector=%u nQueues=%u\n", pState->uQueueSelector, pState->nQueues),
+            pThis->cQueues = cQueues;
+        AssertLogRelMsgReturn(pThis->cQueues <= VIRTIO_MAX_NQUEUES, ("%#x\n", pThis->cQueues), VERR_SSM_LOAD_CONFIG_MISMATCH);
+        AssertLogRelMsgReturn(pThis->uQueueSelector < pThis->cQueues || (pThis->cQueues == 0 && pThis->uQueueSelector),
+                              ("uQueueSelector=%u cQueues=%u\n", pThis->uQueueSelector, pThis->cQueues),
                               VERR_SSM_LOAD_CONFIG_MISMATCH);
 
-        for (unsigned i = 0; i < pState->nQueues; i++)
+        for (unsigned i = 0; i < pThis->cQueues; i++)
         {
-            rc = SSMR3GetU16(pSSM, &pState->Queues[i].VRing.uSize);
+            rc = pHlp->pfnSSMGetU16(pSSM, &pThis->Queues[i].VRing.uSize);
             AssertRCReturn(rc, rc);
-            rc = SSMR3GetU32(pSSM, &pState->Queues[i].uPageNumber);
+            rc = pHlp->pfnSSMGetU32(pSSM, &pThis->Queues[i].uPageNumber);
             AssertRCReturn(rc, rc);
 
-            if (pState->Queues[i].uPageNumber)
-                vqueueInit(&pState->Queues[i], pState->Queues[i].uPageNumber);
-
-            rc = SSMR3GetU16(pSSM, &pState->Queues[i].uNextAvailIndex);
+            if (pThis->Queues[i].uPageNumber)
+                vqueueInit(&pThis->Queues[i], pThis->Queues[i].uPageNumber);
+
+            rc = pHlp->pfnSSMGetU16(pSSM, &pThis->Queues[i].uNextAvailIndex);
             AssertRCReturn(rc, rc);
-            rc = SSMR3GetU16(pSSM, &pState->Queues[i].uNextUsedIndex);
+            rc = pHlp->pfnSSMGetU16(pSSM, &pThis->Queues[i].uNextUsedIndex);
             AssertRCReturn(rc, rc);
         }
     }
 
-    vpciDumpState(pState, "vpciLoadExec");
+    vpciR3DumpState(pThis, "vpciLoadExec");
 
     return VINF_SUCCESS;
@@ -839 +806 @@
  * @thread  EMT
  */
-static DECLCALLBACK(void) vpciConfigure(PPDMPCIDEV pPciDev,
-                                        uint16_t uDeviceId,
-                                        uint16_t uClass)
+static void vpciConfigure(PPDMPCIDEV pPciDev, uint16_t uDeviceId, uint16_t uClass)
 {
     /* Configure PCI Device, assume 32-bit mode ******************************/
@@ -857 +822 @@
     PDMPciDevSetByte(pPciDev, VBOX_PCI_INTERRUPT_PIN,       0x01);
 
-#ifdef VBOX_WITH_MSI_DEVICES
+# ifdef VBOX_WITH_MSI_DEVICES
     PDMPciDevSetCapabilityList(pPciDev,                     0x80);
     PDMPciDevSetStatus(pPciDev,                             VBOX_PCI_STATUS_CAP_LIST);
-#endif
-}
-
-#ifdef VBOX_WITH_STATISTICS
-/* WARNING! This function must never be used in multithreaded context! */
-static const char *vpciCounter(const char *pszDevFmt,
-                               const char *pszCounter)
-{
-    static char s_szCounterName[80];
-
-    RTStrPrintf(s_szCounterName, sizeof(s_szCounterName),
-                "/Devices/%s/%s", pszDevFmt, pszCounter);
-
-    return s_szCounterName;
-}
-#endif
-
-/// @todo header
-int vpciConstruct(PPDMDEVINS pDevIns, VPCISTATE *pState,
-                  int iInstance, const char *pcszNameFmt,
-                  uint16_t uDeviceId, uint16_t uClass,
-                  uint32_t nQueues)
-{
-    /* Init handles and log related stuff. */
-    RTStrPrintf(pState->szInstance, sizeof(pState->szInstance),
-                pcszNameFmt, iInstance);
-
-    pState->pDevInsR3    = pDevIns;
-    pState->pDevInsR0    = PDMDEVINS_2_R0PTR(pDevIns);
-    pState->pDevInsRC    = PDMDEVINS_2_RCPTR(pDevIns);
-    pState->led.u32Magic = PDMLED_MAGIC;
-
-    pState->ILeds.pfnQueryStatusLed = vpciQueryStatusLed;
+# endif
+}
+
+
+int vpciR3Init(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVPCISTATECC pThisCC, uint16_t uDeviceId, uint16_t uClass, uint32_t cQueues)
+{
+    /* Init data members. */
+    pThis->cQueues                   = cQueues;
+    pThis->led.u32Magic              = PDMLED_MAGIC;
+    pThisCC->pShared                 = pThis;
+    pThisCC->ILeds.pfnQueryStatusLed = vpciR3QueryStatusLed;
+    AssertReturn(pThisCC->IBase.pfnQueryInterface, VERR_INVALID_POINTER);
+    AssertReturn(pThis->szInstance[0], VERR_INVALID_PARAMETER);
+    AssertReturn(strlen(pThis->szInstance) < sizeof(pThis->szInstance), VERR_INVALID_PARAMETER);
 
     /* Initialize critical section. */
-    int rc = PDMDevHlpCritSectInit(pDevIns, &pState->cs, RT_SRC_POS, "%s", pState->szInstance);
-    if (RT_FAILURE(rc))
-        return rc;
-
+    int rc = PDMDevHlpCritSectInit(pDevIns, &pThis->cs, RT_SRC_POS, "%s", pThis->szInstance);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Set up the PCI device.
+     */
     PPDMPCIDEV pPciDev = pDevIns->apPciDevs[0];
     PDMPCIDEV_ASSERT_VALID(pDevIns, pPciDev);
+
     /* Set PCI config registers */
     vpciConfigure(pPciDev, uDeviceId, uClass);
+
     /* Register PCI device */
     rc = PDMDevHlpPCIRegister(pDevIns, pPciDev);
-    if (RT_FAILURE(rc))
-        return rc;
-
-#ifdef VBOX_WITH_MSI_DEVICES
-#if 0
+    AssertRCReturn(rc, rc);
+
+# ifdef VBOX_WITH_MSI_DEVICES
+#  if 0
     {
         PDMMSIREG aMsiReg;
@@ -920 +869 @@
         rc = PDMDevHlpPCIRegisterMsi(pDevIns, &aMsiReg);
         if (RT_FAILURE (rc))
-            PCIDevSetCapabilityList(&pState->pciDevice, 0x0);
+            PCIDevSetCapabilityList(&pThis->pciDevice, 0x0);
     }
-#endif
-#endif
-
-    /* Status driver */
+#  endif
+# endif
+
+    /*
+     * Attach the status driver (optional).
+     */
     PPDMIBASE pBase;
-    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pState->IBase, &pBase, "Status Port");
-    if (RT_FAILURE(rc))
+    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port");
+    if (RT_SUCCESS(rc))
+        pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
+    else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the status LUN"));
-    pState->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
-
-    pState->nQueues = nQueues;
-
-#if defined(VBOX_WITH_STATISTICS)
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOReadR3,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in R3",      vpciCounter(pcszNameFmt, "IO/ReadR3"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOReadR0,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in R0",      vpciCounter(pcszNameFmt, "IO/ReadR0"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOReadRC,           STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in RC",      vpciCounter(pcszNameFmt, "IO/ReadRC"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOWriteR3,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R3",     vpciCounter(pcszNameFmt, "IO/WriteR3"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOWriteR0,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R0",     vpciCounter(pcszNameFmt, "IO/WriteR0"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOWriteRC,          STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in RC",     vpciCounter(pcszNameFmt, "IO/WriteRC"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIntsRaised,         STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of raised interrupts",   vpciCounter(pcszNameFmt, "Interrupts/Raised"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIntsSkipped,        STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES,     "Number of skipped interrupts",   vpciCounter(pcszNameFmt, "Interrupts/Skipped"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatCsR3,               STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R3",      vpciCounter(pcszNameFmt, "Cs/CsR3"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatCsR0,               STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R0",      vpciCounter(pcszNameFmt, "Cs/CsR0"), iInstance);
-    PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatCsRC,               STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in RC",      vpciCounter(pcszNameFmt, "Cs/CsRC"), iInstance);
-#endif /* VBOX_WITH_STATISTICS */
-
-    return rc;
+
+    /*
+     * Statistics.
+     */
+# ifdef VBOX_WITH_STATISTICS
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOReadR3,    STAMTYPE_PROFILE, "IO/ReadR3",          STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in R3");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOReadR0,    STAMTYPE_PROFILE, "IO/ReadR0",          STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in R0");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOReadRC,    STAMTYPE_PROFILE, "IO/ReadRC",          STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in RC");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOWriteR3,   STAMTYPE_PROFILE, "IO/WriteR3",         STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R3");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOWriteR0,   STAMTYPE_PROFILE, "IO/WriteR0",         STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in R0");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIOWriteRC,   STAMTYPE_PROFILE, "IO/WriteRC",         STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in RC");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIntsRaised,  STAMTYPE_COUNTER, "Interrupts/Raised",  STAMUNIT_OCCURENCES,     "Number of raised interrupts");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIntsSkipped, STAMTYPE_COUNTER, "Interrupts/Skipped", STAMUNIT_OCCURENCES,     "Number of skipped interrupts");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsR3,        STAMTYPE_PROFILE, "Cs/CsR3",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R3");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsR0,        STAMTYPE_PROFILE, "Cs/CsR0",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in R0");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatCsRC,        STAMTYPE_PROFILE, "Cs/CsRC",            STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in RC");
+# endif /* VBOX_WITH_STATISTICS */
+
+    return VINF_SUCCESS;
 }
 
@@ -957 +910 @@
  *
  * @returns VBox status code.
- * @param   pState      The device state structure.
- */
-int vpciDestruct(VPCISTATE* pState)
-{
-    Log(("%s Destroying PCI instance\n", INSTANCE(pState)));
-
-    if (PDMCritSectIsInitialized(&pState->cs))
-        PDMR3CritSectDelete(&pState->cs);
+ * @param   pThis      The shared virtio core instance data.
+ */
+int vpciR3Term(PPDMDEVINS pDevIns, PVPCISTATE pThis)
+{
+    Log(("%s Destroying PCI instance\n", INSTANCE(pThis)));
+
+    if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->cs))
+        PDMDevHlpCritSectDelete(pDevIns, &pThis->cs);
 
     return VINF_SUCCESS;
 }
 
-/**
- * Device relocation callback.
- *
- * When this callback is called the device instance data, and if the
- * device have a GC component, is being relocated, or/and the selectors
- * have been changed. The device must use the chance to perform the
- * necessary pointer relocations and data updates.
- *
- * Before the GC code is executed the first time, this function will be
- * called with a 0 delta so GC pointer calculations can be one in one place.
- *
- * @param   pDevIns     Pointer to the device instance.
- * @param   offDelta    The relocation delta relative to the old location.
- *
- * @remark  A relocation CANNOT fail.
- */
-void vpciRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
-{
-    RT_NOREF(offDelta);
-    VPCISTATE *pState = PDMINS_2_DATA(pDevIns, VPCISTATE*);
-    pState->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    // TBD
-}
-
-PVQUEUE vpciAddQueue(VPCISTATE* pState, unsigned uSize, PFNVPCIQUEUECALLBACK pfnCallback, const char *pcszName)
-{
-    PVQUEUE pQueue = NULL;
+PVQUEUE vpciR3AddQueue(PVPCISTATE pThis, PVPCISTATECC pThisCC, unsigned uSize,
+                       PFNVPCIQUEUECALLBACK pfnCallback, const char *pcszName)
+{
     /* Find an empty queue slot */
-    for (unsigned i = 0; i < pState->nQueues; i++)
-    {
-        if (pState->Queues[i].VRing.uSize == 0)
+    for (unsigned i = 0; i < pThis->cQueues; i++)
+    {
+        if (pThis->Queues[i].VRing.uSize == 0)
         {
-            pQueue = &pState->Queues[i];
-            break;
+            PVQUEUE pQueue = &pThis->Queues[i];
+            pQueue->VRing.uSize = uSize;
+            pQueue->VRing.addrDescriptors = 0;
+            pQueue->uPageNumber = 0;
+            int rc = RTStrCopy(pQueue->szName, sizeof(pQueue->szName), pcszName);
+            AssertRC(rc);
+            pThisCC->Queues[i].pfnCallback = pfnCallback;
+            return pQueue;
         }
     }
-
-    if (!pQueue)
-    {
-        Log(("%s Too many queues being added, no empty slots available!\n", INSTANCE(pState)));
-    }
-    else
-    {
-        pQueue->VRing.uSize = uSize;
-        pQueue->VRing.addrDescriptors = 0;
-        pQueue->uPageNumber = 0;
-        pQueue->pfnCallback = pfnCallback;
-        pQueue->pcszName = pcszName;
-    }
-
-    return pQueue;
-}
-
-#endif /* IN_RING3 */
-
-#endif /* VBOX_DEVICE_STRUCT_TESTCASE */
-
+    AssertMsgFailedReturn(("%s Too many queues being added, no empty slots available!\n", INSTANCE(pThis)), NULL);
+}
+
+#else  /* !IN_RING3 */
+
+/**
+ * Does ring-0/raw-mode initialization.
+ */
+int vpciRZInit(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVPCISTATECC pThisCC)
+{
+    RT_NOREF(pDevIns, pThis, pThisCC);
+    return VINF_SUCCESS;
+}
+
+#endif /* !IN_RING3 */
+

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

@@ -25 +25 @@
 
 
-/** Pointer to the core (/common) state of a VirtIO PCI device. */
+/** Pointer to the core shared state of a VirtIO PCI device */
 typedef struct VPCISTATE *PVPCISTATE;
+/** Pointer to the core ring-3 state of a VirtIO PCI device */
+typedef struct VPCISTATER3 *PVPCISTATER3;
+/** Pointer to the core ring-0 state of a VirtIO PCI device */
+typedef struct VPCISTATER0 *PVPCISTATER0;
+/** Pointer to the core raw-mode state of a VirtIO PCI device */
+typedef struct VPCISTATERC *PVPCISTATERC;
+
+/** Pointer to the core current context state of a VirtIO PCI device */
+typedef CTX_SUFF(PVPCISTATE) PVPCISTATECC;
+/** The core current context state of a VirtIO PCI device */
+typedef struct CTX_SUFF(VPCISTATE) VPCISTATECC;
 
 
@@ -121 +132 @@
 typedef VRING *PVRING;
 
+typedef struct VQUEUE
+{
+    VRING       VRing;
+    uint16_t    uNextAvailIndex;
+    uint16_t    uNextUsedIndex;
+    uint32_t    uPageNumber;
+    char        szName[16];
+} VQUEUE;
+typedef VQUEUE *PVQUEUE;
+
 /**
  * Queue callback (consumer?).
  *
  * @param   pDevIns         The device instance.
- * @param   pVPciState      Pointer to the VirtIO PCI core state.
  * @param   pQueue          Pointer to the queue structure.
  */
-typedef DECLCALLBACK(void) FNVPCIQUEUECALLBACK(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, struct VQueue *pQueue);
+typedef DECLCALLBACK(void) FNVPCIQUEUECALLBACK(PPDMDEVINS pDevIns, PVQUEUE pQueue);
 /** Pointer to a VQUEUE callback function. */
 typedef FNVPCIQUEUECALLBACK *PFNVPCIQUEUECALLBACK;
 
-typedef struct VQueue
-{
-    VRING    VRing;
-    uint16_t uNextAvailIndex;
-    uint16_t uNextUsedIndex;
-    uint32_t uPageNumber;
+typedef struct VQUEUER3
+{
     R3PTRTYPE(PFNVPCIQUEUECALLBACK) pfnCallback;
-    R3PTRTYPE(const char *)         pcszName;
-} VQUEUE;
-typedef VQUEUE *PVQUEUE;
+} VQUEUER3;
+typedef VQUEUER3 *PVQUEUER3;
 
 typedef struct VQueueElemSeg
@@ -170 +185 @@
 
 /**
- * The core (/common) state of the VirtIO PCI device
+ * The core shared state of a VirtIO PCI device
+ */
+typedef struct VPCISTATE
+{
+    PDMCRITSECT             cs;      /**< Critical section - what is it protecting? */
+    /** Read-only part, never changes after initialization. */
+    char                    szInstance[8];         /**< Instance name, e.g. VNet#1. */
+
+    /* Read/write part, protected with critical section. */
+    /** Status LED. */
+    PDMLED                  led;
+
+    uint32_t                uGuestFeatures;
+    uint16_t                uQueueSelector;         /**< An index in aQueues array. */
+    uint8_t                 uStatus; /**< Device Status (bits are device-specific). */
+    uint8_t                 uISR;                   /**< Interrupt Status Register. */
+
+    /** Number of queues actually used. */
+    uint32_t                cQueues;
+    uint32_t                u32Padding;
+    /** Shared queue data. */
+    VQUEUE                  Queues[VIRTIO_MAX_NQUEUES];
+
+#ifdef VBOX_WITH_STATISTICS
+    STAMPROFILEADV          StatIOReadR3;
+    STAMPROFILEADV          StatIOReadR0;
+    STAMPROFILEADV          StatIOReadRC;
+    STAMPROFILEADV          StatIOWriteR3;
+    STAMPROFILEADV          StatIOWriteR0;
+    STAMPROFILEADV          StatIOWriteRC;
+    STAMCOUNTER             StatIntsRaised;
+    STAMCOUNTER             StatIntsSkipped;
+    STAMPROFILE             StatCsR3;
+    STAMPROFILE             StatCsR0;
+    STAMPROFILE             StatCsRC;
+#endif
+} VPCISTATE;
+
+
+/**
+ * The core ring-3 state of a VirtIO PCI device
  *
  * @implements  PDMILEDPORTS
  */
-typedef struct VPCISTATE
-{
-    PDMCRITSECT            cs;      /**< Critical section - what is it protecting? */
-    /* Read-only part, never changes after initialization. */
-    char                   szInstance[8];         /**< Instance name, e.g. VNet#1. */
-
-#if HC_ARCH_BITS != 64
-    uint32_t               padding1;
-#endif
-
+typedef struct VPCISTATER3
+{
     /** Status LUN: Base interface. */
-    PDMIBASE               IBase;
+    PDMIBASE                        IBase;
     /** Status LUN: LED port interface. */
-    PDMILEDPORTS           ILeds;
+    PDMILEDPORTS                    ILeds;
     /** Status LUN: LED connector (peer). */
-    R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
-
-    PPDMDEVINSR3           pDevInsR3;                   /**< Device instance - R3. */
-    PPDMDEVINSR0           pDevInsR0;                   /**< Device instance - R0. */
-    PPDMDEVINSRC           pDevInsRC;                   /**< Device instance - RC. */
-
-#if HC_ARCH_BITS == 64
-    uint32_t               padding2;
-#endif
-
-    /** Base port of I/O space region. */
-    RTIOPORT               IOPortBase;
-
-    /* Read/write part, protected with critical section. */
-    /** Status LED. */
-    PDMLED                 led;
-
-    uint32_t               uGuestFeatures;
-    uint16_t               uQueueSelector;         /**< An index in aQueues array. */
-    uint8_t                uStatus; /**< Device Status (bits are device-specific). */
-    uint8_t                uISR;                   /**< Interrupt Status Register. */
-
-#if HC_ARCH_BITS != 64
-    uint32_t               padding3;
-#endif
-
-    uint32_t               nQueues;       /**< Actual number of queues used. */
-    VQUEUE                 Queues[VIRTIO_MAX_NQUEUES];
-
-#ifdef VBOX_WITH_STATISTICS
-    STAMPROFILEADV         StatIOReadR3;
-    STAMPROFILEADV         StatIOReadR0;
-    STAMPROFILEADV         StatIOReadRC;
-    STAMPROFILEADV         StatIOWriteR3;
-    STAMPROFILEADV         StatIOWriteR0;
-    STAMPROFILEADV         StatIOWriteRC;
-    STAMCOUNTER            StatIntsRaised;
-    STAMCOUNTER            StatIntsSkipped;
-    STAMPROFILE            StatCsR3;
-    STAMPROFILE            StatCsR0;
-    STAMPROFILE            StatCsRC;
-#endif
-} VPCISTATE;
+    R3PTRTYPE(PPDMILEDCONNECTORS)   pLedsConnector;
+    /** Pointer to the shared state. */
+    R3PTRTYPE(PVPCISTATE)           pShared;
+    /** Ring-3 per-queue data. */
+    VQUEUER3                        Queues[VIRTIO_MAX_NQUEUES];
+} VPCISTATER3;
+
+
+/**
+ * The core ring-0 state of a VirtIO PCI device
+ */
+typedef struct VPCISTATER0
+{
+    uint64_t                uUnused;
+} VPCISTATER0;
+
+
+/**
+ * The core raw-mode state of a VirtIO PCI device
+ */
+typedef struct VPCISTATERC
+{
+    uint64_t                uUnused;
+} VPCISTATERC;
+
 
 /** @name VirtIO port I/O callbacks.
@@ -242 +271 @@
      DECLCALLBACKMEMBER(int,      pfnGetConfig)(PVPCISTATE pVPciState, uint32_t offCfg, uint32_t cb, void *pvData);
      DECLCALLBACKMEMBER(int,      pfnSetConfig)(PVPCISTATE pVPciState, uint32_t offCfg, uint32_t cb, void *pvData);
-     DECLCALLBACKMEMBER(int,      pfnReset)(PVPCISTATE pVPciState);
-     DECLCALLBACKMEMBER(void,     pfnReady)(PVPCISTATE pVPciState);
+     DECLCALLBACKMEMBER(int,      pfnReset)(PPDMDEVINS pDevIns);
+     DECLCALLBACKMEMBER(void,     pfnReady)(PPDMDEVINS pDevIns);
 } VPCIIOCALLBACKS;
 /** Pointer to a const VirtIO port I/O callback structure. */
@@ -249 +278 @@
 /** @} */
 
-int vpciRaiseInterrupt(VPCISTATE *pState, int rcBusy, uint8_t u8IntCause);
-int vpciIOPortIn(PPDMDEVINS         pDevIns,
-                 PVPCISTATE         pState,
-                 RTIOPORT           port,
-                 uint32_t          *pu32,
-                 unsigned           cb,
-                 PCVPCIIOCALLBACKS  pCallbacks);
-
-int vpciIOPortOut(PPDMDEVINS        pDevIns,
-                  PVPCISTATE        pState,
-                  RTIOPORT          port,
-                  uint32_t          u32,
-                  unsigned          cb,
-                  PCVPCIIOCALLBACKS pCallbacks);
-
-void  vpciSetWriteLed(PVPCISTATE pState, bool fOn);
-void  vpciSetReadLed(PVPCISTATE pState, bool fOn);
-int   vpciSaveExec(PVPCISTATE pState, PSSMHANDLE pSSM);
-int   vpciLoadExec(PVPCISTATE pState, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t nQueues);
-int   vpciConstruct(PPDMDEVINS pDevIns, VPCISTATE *pState, int iInstance, const char *pcszNameFmt,
-                    uint16_t uDeviceId, uint16_t uClass, uint32_t nQueues);
-int   vpciDestruct(VPCISTATE* pState);
-void  vpciRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta);
-void  vpciReset(PVPCISTATE pState);
-void *vpciQueryInterface(struct PDMIBASE *pInterface, const char *pszIID);
-PVQUEUE vpciAddQueue(VPCISTATE* pState, unsigned uSize, PFNVPCIQUEUECALLBACK pfnCallback, const char *pcszName);
+int   vpciR3Init(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVPCISTATECC pThisCC, uint16_t uDeviceId, uint16_t uClass, uint32_t cQueues);
+int   vpciRZInit(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVPCISTATECC pThisCC);
+int   vpciR3Term(PPDMDEVINS pDevIns, PVPCISTATE pThis);
+
+int   vpciRaiseInterrupt(PPDMDEVINS pDevIns, PVPCISTATE pThis, int rcBusy, uint8_t u8IntCause);
+int   vpciIOPortIn(PPDMDEVINS pDevIns, PVPCISTATE pThis, RTIOPORT offPort,
+                   uint32_t *pu32, unsigned cb,PCVPCIIOCALLBACKS pCallbacks);
+int   vpciIOPortOut(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVPCISTATECC pThisCC, RTIOPORT offPort,
+                    uint32_t u32, unsigned cb, PCVPCIIOCALLBACKS pCallbacks);
+
+void  vpciR3SetWriteLed(PVPCISTATE pThis, bool fOn);
+void  vpciR3SetReadLed(PVPCISTATE pThis, bool fOn);
+int   vpciR3SaveExec(PCPDMDEVHLPR3 pHlp, PVPCISTATE pThis, PSSMHANDLE pSSM);
+int   vpciR3LoadExec(PCPDMDEVHLPR3 pHlp, PVPCISTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t cQueues);
+void  vpciReset(PPDMDEVINS pDevIns, PVPCISTATE pThis);
+void *vpciR3QueryInterface(PVPCISTATECC pThisCC, const char *pszIID);
+PVQUEUE vpciR3AddQueue(PVPCISTATE pThis, PVPCISTATECC pThisCC, unsigned uSize, PFNVPCIQUEUECALLBACK pfnCallback, const char *pcszName);
 
 #define VPCI_CS
-DECLINLINE(int) vpciCsEnter(VPCISTATE *pState, int rcBusy)
+DECLINLINE(int) vpciCsEnter(PPDMDEVINS pDevIns, PVPCISTATE pThis, int rcBusy)
 {
 #ifdef VPCI_CS
-    STAM_PROFILE_START(&pState->CTX_SUFF(StatCs), a);
-    int rc = PDMCritSectEnter(&pState->cs, rcBusy);
-    STAM_PROFILE_STOP(&pState->CTX_SUFF(StatCs), a);
+    STAM_PROFILE_START(&pThis->CTX_SUFF(StatCs), a);
+    int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->cs, rcBusy);
+    STAM_PROFILE_STOP(&pThis->CTX_SUFF(StatCs), a);
     return rc;
 #else
+    RT_NOREF(pDevIns, pThis, rcBusy);
     return VINF_SUCCESS;
 #endif
 }
 
-DECLINLINE(void) vpciCsLeave(VPCISTATE *pState)
+DECLINLINE(void) vpciCsLeave(PPDMDEVINS pDevIns, PVPCISTATE pThis)
 {
 #ifdef VPCI_CS
-    PDMCritSectLeave(&pState->cs);
+    PDMDevHlpCritSectLeave(pDevIns, &pThis->cs);
 #endif
 }
 
-void vringSetNotification(PVPCISTATE pState, PVRING pVRing, bool fEnabled);
-
-DECLINLINE(uint16_t) vringReadAvailIndex(PVPCISTATE pState, PVRING pVRing)
-{
-    uint16_t tmp;
-
-    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
-                      pVRing->addrAvail + RT_UOFFSETOF(VRINGAVAIL, uNextFreeIndex),
-                      &tmp, sizeof(tmp));
-    return tmp;
-}
-
-bool vqueueSkip(PVPCISTATE pState, PVQUEUE pQueue);
-bool vqueueGet(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove = true);
-void vqueuePut(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t uLen, uint32_t uReserved = 0);
-void vqueueNotify(PVPCISTATE pState, PVQUEUE pQueue);
-void vqueueSync(PVPCISTATE pState, PVQUEUE pQueue);
-
-DECLINLINE(bool) vqueuePeek(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem)
-{
-    return vqueueGet(pState, pQueue, pElem, /* fRemove */ false);
-}
-
-DECLINLINE(bool) vqueueIsReady(PVPCISTATE pState, PVQUEUE pQueue)
-{
-    NOREF(pState);
+void vringSetNotification(PPDMDEVINS pDevIns, PVRING pVRing, bool fEnabled);
+
+DECLINLINE(uint16_t) vringReadAvailIndex(PPDMDEVINS pDevIns, PVRING pVRing)
+{
+    uint16_t idx = 0;
+    PDMDevHlpPhysRead(pDevIns, pVRing->addrAvail + RT_UOFFSETOF(VRINGAVAIL, uNextFreeIndex), &idx, sizeof(idx));
+    return idx;
+}
+
+bool vqueueSkip(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue);
+bool vqueueGet(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove = true);
+void vqueuePut(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t uLen, uint32_t uReserved = 0);
+void vqueueNotify(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue);
+void vqueueSync(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue);
+
+DECLINLINE(bool) vqueuePeek(PPDMDEVINS pDevIns, PVPCISTATE pThis, PVQUEUE pQueue, PVQUEUEELEM pElem)
+{
+    return vqueueGet(pDevIns, pThis, pQueue, pElem, /* fRemove */ false);
+}
+
+DECLINLINE(bool) vqueueIsReady(PVQUEUE pQueue)
+{
     return !!pQueue->VRing.addrAvail;
 }
 
-DECLINLINE(bool) vqueueIsEmpty(PVPCISTATE pState, PVQUEUE pQueue)
-{
-    return (vringReadAvailIndex(pState, &pQueue->VRing) == pQueue->uNextAvailIndex);
-}
+DECLINLINE(bool) vqueueIsEmpty(PPDMDEVINS pDevIns, PVQUEUE pQueue)
+{
+    return vringReadAvailIndex(pDevIns, &pQueue->VRing) == pQueue->uNextAvailIndex;
+}
+
+void vpcR3iDumpStateWorker(PVPCISTATE pThis, PCDBGFINFOHLP pHlp);
 
 #endif /* !VBOX_INCLUDED_SRC_VirtIO_Virtio_h */