Changeset 81675 in vbox

Timestamp:

Nov 5, 2019 4:13:34 PM (5 years ago)

Author:

vboxsync

Message:

Virtio_1_0,DevVirtioScsi: Converting to new PDM model - split up structures. (untested) bugref:9218

Location:

trunk/src/VBox/Devices

Files:

• Storage/DevVirtioSCSI.cpp (modified) (85 diffs)
• VirtIO/Virtio_1_0.cpp (modified) (72 diffs)
• VirtIO/Virtio_1_0.h (modified) (9 diffs)

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

@@ -338 +338 @@
 
 /**
- * Worker thread context
+ * Worker thread context, shared state.
  */
 typedef struct VIRTIOSCSIWORKER
 {
+    SUPSEMEVENT                     hEvtProcess;                /**< handle of associated sleep/wake-up semaphore      */
+} VIRTIOSCSIWORKER;
+/** Pointer to a VirtIO SCSI worker. */
+typedef VIRTIOSCSIWORKER *PVIRTIOSCSIWORKER;
+
+/**
+ * Worker thread context, ring-3 state.
+ */
+typedef struct VIRTIOSCSIWORKERR3
+{
     R3PTRTYPE(PPDMTHREAD)           pThread;                    /**< pointer to worker thread's handle                 */
-    SUPSEMEVENT                     hEvtProcess;                /**< handle of associated sleep/wake-up semaphore      */
-    bool                            fSleeping;                  /**< Flags whether worker thread is sleeping or not    */
-    bool                            fNotified;                  /**< Flags whether worker thread notified              */
-} VIRTIOSCSIWORKER;
-typedef VIRTIOSCSIWORKER *PVIRTIOSCSIWORKER;
+    bool volatile                   fSleeping;                  /**< Flags whether worker thread is sleeping or not    */
+    bool volatile                   fNotified;                  /**< Flags whether worker thread notified              */
+} VIRTIOSCSIWORKERR3;
+/** Pointer to a VirtIO SCSI worker. */
+typedef VIRTIOSCSIWORKERR3 *PVIRTIOSCSIWORKERR3;
+
 
 /**
@@ -354 +365 @@
 typedef struct VIRTIOSCSITARGET
 {
-    /** Pointer to PCI device that owns this target instance. - R3 pointer */
-    R3PTRTYPE(struct VIRTIOSCSI *)  pVirtioScsi;
+    /** The ring-3 device instance so we can easily get our bearings. */
+    PPDMDEVINSR3                    pDevIns;
 
     /** Pointer to attached driver's base interface. */
@@ -361 +372 @@
 
     /** Target number (PDM LUN) */
-    RTUINT                          iTarget;
+    uint32_t                        iTarget;
 
     /** Target Description */
-    char *                          pszTargetName;
+    R3PTRTYPE(char *)               pszTargetName;
 
     /** Target base interface. */
@@ -407 +418 @@
 
 /**
- * PDM instance data (state) for VirtIO Host SCSI device
+ * VirtIO Host SCSI device state, shared edition.
  *
- * @extends     PDMPCIDEV
+ * @extends     VIRTIOSTATE
  */
 typedef struct VIRTIOSCSI
@@ -417 +428 @@
 
     bool                            fBootable;
-    bool                            afPadding[3];
+    bool                            afPadding0[3];
 
     /** Number of targets in paTargetInstances. */
     uint32_t                        cTargets;
+
+    /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
+    VIRTIOSCSIWORKER                aWorkers[VIRTIOSCSI_QUEUE_CNT];
+
+    /** Instance name */
+    char                            szInstance[16];
+
+    /** Device-specific spec-based VirtIO queuenames */
+    char                            aszQueueNames[VIRTIOSCSI_QUEUE_CNT][VIRTIO_MAX_QUEUE_NAME_SIZE];
+
+    /** Track which VirtIO queues we've attached to */
+    bool                            afQueueAttached[VIRTIOSCSI_QUEUE_CNT];
+
+    /** Set if events missed due to lack of bufs avail on eventq */
+    bool                            fEventsMissed;
+
+    /** True if PDMDevHlpAsyncNotificationCompleted should be called when port goes idle
+     * @todo r=bird: What's this for exactly? It's not referenced anywhere... */
+    bool volatile                   fSignalIdle;
+    /** Explicit alignment padding. */
+    bool                            afPadding1[2];
+
+    /** Mask of VirtIO Async Event types this device will deliver */
+    uint32_t                        fAsyncEvtsEnabled;
+
+    /** Total number of requests active across all targets */
+    volatile uint32_t               cActiveReqs;
+
+    /** Events the guest has subscribed to get notifications of */
+    uint32_t                        fSubscribedEvents;
+
+    /** VirtIO Host SCSI device runtime configuration parameters */
+    VIRTIOSCSI_CONFIG_T             virtioScsiConfig;
+
+    /** True if the guest/driver and VirtIO framework are in the ready state */
+    uint32_t                        fVirtioReady;
+
+    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
+    uint32_t                        fHasT10pi;
+
+    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
+    uint32_t                        fHasHotplug;
+
+    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
+    uint32_t                        fHasInOutBufs;
+
+    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
+    uint32_t                        fHasLunChange;
+
+    /** True if in the process of resetting */
+    uint32_t                        fResetting;
+
+} VIRTIOSCSI;
+/** Pointer to the shared state of the VirtIO Host SCSI device. */
+typedef VIRTIOSCSI *PVIRTIOSCSI;
+
+
+/**
+ * VirtIO Host SCSI device state, ring-3 edition.
+ *
+ * @extends     VIRTIOSTATER3
+ */
+typedef struct VIRTIOSCSIR3
+{
+    /** The virtio ring-3 state. */
+    VIRTIOSTATER3                   Virtio;
+
     /** Array of per-target data. */
     R3PTRTYPE(PVIRTIOSCSITARGET)    paTargetInstances;
-#if HC_ARCH_BITS == 32
-    RTR3PTR                         R3PtrPadding0;
-#endif
 
     /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
-    VIRTIOSCSIWORKER                aWorkers[VIRTIOSCSI_QUEUE_CNT];
-
-    /** Instance name */
-    char                            szInstance[16];
-
-    /** Device-specific spec-based VirtIO queuenames */
-    char                            aszQueueNames[VIRTIOSCSI_QUEUE_CNT][VIRTIO_MAX_QUEUE_NAME_SIZE];
-
-    /** Track which VirtIO queues we've attached to */
-    bool                            afQueueAttached[VIRTIOSCSI_QUEUE_CNT];
+    VIRTIOSCSIWORKERR3              aWorkers[VIRTIOSCSI_QUEUE_CNT];
 
     /** Device base interface. */
     PDMIBASE                        IBase;
 
-    /** Pointer to the device instance. - R3 ptr. */
-    PPDMDEVINSR3                    pDevInsR3;
-
-    /** Pointer to the device instance. - R0 ptr. */
-    PPDMDEVINSR0                    pDevInsR0;
-
-    /** Pointer to the device instance. - RC ptr. */
-    PPDMDEVINSRC                    pDevInsRC;
+    /** Pointer to the device instance.
+     * @note Only used in interface callbacks. */
+    PPDMDEVINSR3                    pDevIns;
 
     /** Status Target: LEDs port interface. */
@@ -462 +523 @@
     /** Queue to send tasks to R3. - HC ptr */
     R3PTRTYPE(PPDMQUEUE)            pNotifierQueueR3;
-
-    /** The support driver session handle. */
-    R3R0PTRTYPE(PSUPDRVSESSION)     pSupDrvSession;
-
-    /** Mask of VirtIO Async Event types this device will deliver */
-    uint32_t                        fAsyncEvtsEnabled;
-
-    /** Total number of requests active across all targets */
-    volatile uint32_t               cActiveReqs;
-
-    /** True if PDMDevHlpAsyncNotificationCompleted should be called when port goes idle */
-    bool volatile                   fSignalIdle;
-
-    /** Events the guest has subscribed to get notifications of */
-    uint32_t                        fSubscribedEvents;
-
-    /** Set if events missed due to lack of bufs avail on eventq */
-    bool                            fEventsMissed;
-
-    /** VirtIO Host SCSI device runtime configuration parameters */
-    VIRTIOSCSI_CONFIG_T             virtioScsiConfig;
-
-    /** True if the guest/driver and VirtIO framework are in the ready state */
-    uint32_t                        fVirtioReady;
-
-    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
-    uint32_t                        fHasT10pi;
-
-    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
-    uint32_t                        fHasHotplug;
-
-    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
-    uint32_t                        fHasInOutBufs;
-
-    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
-    uint32_t                        fHasLunChange;
-
-    /** True if in the process of resetting */
-    uint32_t                        fResetting;
 
     /** True if in the process of quiescing I/O */
@@ -507 +529 @@
     VIRTIOSCSIQUIESCINGFOR          enmQuiescingFor;
 
-} VIRTIOSCSI, *PVIRTIOSCSI;
+} VIRTIOSCSIR3;
+/** Pointer to the ring-3 state of the VirtIO Host SCSI device. */
+typedef VIRTIOSCSIR3 *PVIRTIOSCSIR3;
+
+
+/**
+ * VirtIO Host SCSI device state, ring-0 edition.
+ */
+typedef struct VIRTIOSCSIR0
+{
+    /** The virtio ring-0 state. */
+    VIRTIOSTATER0                   Virtio;
+} VIRTIOSCSIR0;
+/** Pointer to the ring-0 state of the VirtIO Host SCSI device. */
+typedef VIRTIOSCSIR0 *PVIRTIOSCSIR0;
+
+
+/**
+ * VirtIO Host SCSI device state, raw-mode edition.
+ */
+typedef struct VIRTIOSCSIRC
+{
+    /** The virtio raw-mode state. */
+    VIRTIOSTATERC                   Virtio;
+} VIRTIOSCSIRC;
+/** Pointer to the ring-0 state of the VirtIO Host SCSI device. */
+typedef VIRTIOSCSIRC *PVIRTIOSCSIRC;
+
+
+/** @typedef VIRTIOSCSICC
+ * The instance data for the current context. */
+typedef CTX_SUFF(VIRTIOSCSI) VIRTIOSCSICC;
+/** @typedef PVIRTIOSCSICC
+ * Pointer to the instance data for the current context. */
+typedef CTX_SUFF(PVIRTIOSCSI) PVIRTIOSCSICC;
+
 
 /**
@@ -613 +670 @@
 #endif /* LOG_ENABLED */
 
-static int virtioScsiR3SendEvent(PVIRTIOSCSI pThis, uint16_t uTarget, uint32_t uEventType, uint32_t uReason)
+static int virtioScsiR3SendEvent(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget, uint32_t uEventType, uint32_t uReason)
 {
 
@@ -671 +728 @@
     }
 
-    if (virtioQueueIsEmpty(&pThis->Virtio, EVENTQ_IDX))
+    if (virtioQueueIsEmpty(pDevIns, &pThis->Virtio, EVENTQ_IDX))
     {
         LogFunc(("eventq is empty, events missed (driver didn't preload queue)!\n"));
@@ -679 +736 @@
 
     PVIRTIO_DESC_CHAIN_T pDescChain;
-    virtioR3QueueGet(&pThis->Virtio, EVENTQ_IDX, &pDescChain, true);
+    virtioR3QueueGet(pDevIns, &pThis->Virtio, EVENTQ_IDX, &pDescChain, true);
 
     RTSGBUF reqSegBuf;
@@ -685 +742 @@
     RTSgBufInit(&reqSegBuf, aReqSegs, RT_ELEMENTS(aReqSegs));
 
-    virtioR3QueuePut( &pThis->Virtio, EVENTQ_IDX, &reqSegBuf, pDescChain, true);
-    virtioQueueSync(&pThis->Virtio, EVENTQ_IDX);
+    virtioR3QueuePut(pDevIns, &pThis->Virtio, EVENTQ_IDX, &reqSegBuf, pDescChain, true);
+    virtioQueueSync(pDevIns, &pThis->Virtio, EVENTQ_IDX);
 
     return VINF_SUCCESS;
@@ -702 +759 @@
  * This is called to complete a request immediately
  *
- * @param   pThis       PDM driver instance state
+ * @param   pDevIns     The device instance.
+ * @param   pThis       VirtIO SCSI shared instance data.
+ * @param   pThisCC     VirtIO SCSI ring-3 instance data.
  * @param   qIdx        Queue index
  * @param   pDescChain  Pointer to pre-processed descriptor chain pulled from virtq
@@ -710 +769 @@
  * @returns VBox status code.
  */
-static int virtioScsiR3ReqErr(PVIRTIOSCSI pThis, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain,
-                              REQ_RESP_HDR_T *pRespHdr, uint8_t *pbSense)
+static int virtioScsiR3ReqErr(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC, uint16_t qIdx,
+                              PVIRTIO_DESC_CHAIN_T pDescChain, REQ_RESP_HDR_T *pRespHdr, uint8_t *pbSense)
 {
     uint8_t *pabSenseBuf = (uint8_t *)RTMemAllocZ(pThis->virtioScsiConfig.uSenseSize);
@@ -735 +794 @@
         pRespHdr->uResponse = VIRTIOSCSI_S_RESET;
 
-    virtioR3QueuePut(&pThis->Virtio, qIdx, &reqSegBuf, pDescChain, true /* fFence */);
-    virtioQueueSync(&pThis->Virtio, qIdx);
+    virtioR3QueuePut(pDevIns, &pThis->Virtio, qIdx, &reqSegBuf, pDescChain, true /* fFence */);
+    virtioQueueSync(pDevIns, &pThis->Virtio, qIdx);
 
     RTMemFree(pabSenseBuf);
 
-    if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThis->fQuiescing)
-        PDMDevHlpAsyncNotificationCompleted(pThis->CTX_SUFF(pDevIns));
+    if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThisCC->fQuiescing)
+        PDMDevHlpAsyncNotificationCompleted(pDevIns);
 
     Log2(("---------------------------------------------------------------------------------\n"));
@@ -779 +838 @@
                                                  void *pvIoReqAlloc, int rcReq)
 {
-    RT_NOREF(pInterface);
-
-    PVIRTIOSCSIREQ    pReq      = (PVIRTIOSCSIREQ)pvIoReqAlloc;
-    PVIRTIOSCSITARGET pTarget   = pReq->pTarget;
-    PVIRTIOSCSI       pThis     = pTarget->pVirtioScsi;
-    PPDMIMEDIAEX      pIMediaEx = pTarget->pDrvMediaEx;
+    PVIRTIOSCSITARGET   pTarget   = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
+    PPDMDEVINS          pDevIns   = pTarget->pDevIns;
+    PVIRTIOSCSI         pThis     = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    PPDMIMEDIAEX        pIMediaEx = pTarget->pDrvMediaEx;
+    PVIRTIOSCSIREQ      pReq      = (PVIRTIOSCSIREQ)pvIoReqAlloc;
 
     size_t cbResidual = 0;
@@ -866 +925 @@
         respHdr.uResidual  = pReq->cbDataIn;
 
-        virtioScsiR3ReqErr(pThis, pReq->qIdx, pReq->pDescChain, &respHdr, abSense);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, pReq->qIdx, pReq->pDescChain, &respHdr, abSense);
     }
     else
@@ -891 +950 @@
 
 
-        virtioR3QueuePut(&pThis->Virtio, pReq->qIdx, &reqSegBuf, pReq->pDescChain, true /* fFence TBD */);
-        virtioQueueSync(&pThis->Virtio, pReq->qIdx);
+        virtioR3QueuePut(pDevIns, &pThis->Virtio, pReq->qIdx, &reqSegBuf, pReq->pDescChain, true /* fFence TBD */);
+        virtioQueueSync(pDevIns, &pThis->Virtio, pReq->qIdx);
 
 
@@ -900 +959 @@
     virtioScsiR3FreeReq(pTarget, pReq);
 
-    if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThis->fQuiescing)
-        PDMDevHlpAsyncNotificationCompleted(pThis->CTX_SUFF(pDevIns));
+    if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThisCC->fQuiescing)
+        PDMDevHlpAsyncNotificationCompleted(pDevIns);
 
     return VINF_SUCCESS;
@@ -914 +973 @@
                                                       void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf, size_t cbCopy)
 {
+    PVIRTIOSCSITARGET   pTarget   = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
+    PPDMDEVINS          pDevIns   = pTarget->pDevIns;
+    PVIRTIOSCSIREQ      pReq      = (PVIRTIOSCSIREQ)pvIoReqAlloc;
     RT_NOREF(hIoReq, cbCopy);
-
-    PVIRTIOSCSIREQ pReq = (PVIRTIOSCSIREQ)pvIoReqAlloc;
 
     if (!pReq->cbDataIn)
         return VINF_SUCCESS;
-
-    PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
-    PVIRTIOSCSI pThis = pTarget->pVirtioScsi;
 
     AssertReturn(pReq->pDescChain, VERR_INVALID_PARAMETER);
@@ -942 +999 @@
         uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->pvSegCur;
         cbCopied = RT_MIN((uint64_t)pSgBuf->cbSegLeft, dstSgLen - (dstSgCur - dstSgStart));
-        PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns),
-                          (RTGCPHYS)pSgPhysReturn->pvSegCur, pSgBuf->pvSegCur, cbCopied);
+        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->pvSegCur, pSgBuf->pvSegCur, cbCopied);
         RTSgBufAdvance(pSgBuf, cbCopied);
         RTSgBufAdvance(pSgPhysReturn, cbCopied);
@@ -964 +1020 @@
                                                     void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf, size_t cbCopy)
 {
+    PVIRTIOSCSITARGET   pTarget   = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
+    PPDMDEVINS          pDevIns   = pTarget->pDevIns;
+    PVIRTIOSCSIREQ      pReq      = (PVIRTIOSCSIREQ)pvIoReqAlloc;
     RT_NOREF(hIoReq, cbCopy);
-
-    PVIRTIOSCSIREQ pReq = (PVIRTIOSCSIREQ)pvIoReqAlloc;
 
     if (!pReq->cbDataOut)
         return VINF_SUCCESS;
-
-    PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
-    PVIRTIOSCSI pThis = pTarget->pVirtioScsi;
 
     PRTSGBUF pSgPhysSend = pReq->pDescChain->pSgPhysSend;
@@ -986 +1040 @@
         uint64_t srcSgCur   = (uint64_t)pSgPhysSend->pvSegCur;
         cbCopied = RT_MIN((uint64_t)pSgBuf->cbSegLeft, srcSgLen - (srcSgCur - srcSgStart));
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
+        PDMDevHlpPhysRead(pDevIns,
                           (RTGCPHYS)pSgPhysSend->pvSegCur, pSgBuf->pvSegCur, cbCopied);
         RTSgBufAdvance(pSgBuf, cbCopied);
@@ -1004 +1058 @@
 static DECLCALLBACK(void) virtioScsiR3MediumEjected(PPDMIMEDIAEXPORT pInterface)
 {
-    PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
-    PVIRTIOSCSI pThis = pTarget->pVirtioScsi;
+    PVIRTIOSCSITARGET   pTarget   = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
+    PPDMDEVINS          pDevIns   = pTarget->pDevIns;
+    PVIRTIOSCSICC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+
     LogFunc(("LUN %d Ejected!\n", pTarget->iTarget));
-    if (pThis->pMediaNotify)
-    {
-        int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pThis->CTX_SUFF(pDevIns)), VMCPUID_ANY,
-                                   (PFNRT)pThis->pMediaNotify->pfnEjected, 2,
-                                   pThis->pMediaNotify, pTarget->iTarget);
+    if (pThisCC->pMediaNotify)
+    {
+        int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
+                                   (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
+                                   pThisCC->pMediaNotify, pTarget->iTarget);
         AssertRC(rc);
     }
@@ -1022 +1078 @@
                                                         void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
 {
-    RT_NOREF4(pInterface, hIoReq, pvIoReqAlloc, enmState);
-    PVIRTIOSCSI pThis = RT_FROM_MEMBER(pInterface, VIRTIOSCSI, IBase);
+    PVIRTIOSCSITARGET   pTarget   = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
+    PPDMDEVINS          pDevIns   = pTarget->pDevIns;
+    PVIRTIOSCSI         pThis     = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    RT_NOREF(hIoReq, pvIoReqAlloc);
 
     switch (enmState)
@@ -1030 +1089 @@
         {
             /* Stop considering this request active */
-            if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThis->fQuiescing)
-                PDMDevHlpAsyncNotificationCompleted(pThis->CTX_SUFF(pDevIns));
+            if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThisCC->fQuiescing)
+                PDMDevHlpAsyncNotificationCompleted(pDevIns);
             break;
         }
@@ -1052 +1111 @@
  * @returns VBox status code (logged by caller).
  */
-static int virtioScsiR3ReqSubmit(PVIRTIOSCSI pThis, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
+static int virtioScsiR3ReqSubmit(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
+                                 uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
 {
     AssertReturn(pDescChain->cbPhysSend, VERR_INVALID_PARAMETER);
@@ -1069 +1129 @@
         size_t cbSeg = cb;
         RTGCPHYS GCPhys = (RTGCPHYS)RTSgBufGetNextSegment(pDescChain->pSgPhysSend, &cbSeg);
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, pb, cbSeg);
+        PDMDevHlpPhysRead(pDevIns, GCPhys, pb, cbSeg);
         pb += cbSeg;
         cb -= cbSeg;
@@ -1076 +1136 @@
     uint8_t  uTarget  = pVirtqReq->ReqHdr.abVirtioLun[1];
     uint32_t uScsiLun = (pVirtqReq->ReqHdr.abVirtioLun[2] << 8 | pVirtqReq->ReqHdr.abVirtioLun[3]) & 0x3fff;
-    PVIRTIOSCSITARGET pTarget = &pThis->paTargetInstances[uTarget];
 
     LogFunc(("[%s] (Target: %d LUN: %d)  CDB: %.*Rhxs\n",
@@ -1092 +1151 @@
     uint32_t cbDataOut = pDescChain->cbPhysSend - uDataOutOff;
     uint32_t cbDataIn  = pDescChain->cbPhysReturn - uDataInOff;
+
     /*
      * Handle submission errors
      */
-
-    if (RT_UNLIKELY(pThis->fResetting))
+/** @todo r=bird: RT_UNLIKELY doesn't work everywhere and is deprecated, convert to RT_LIKELY like in the first instance here. */
+    if (RT_LIKELY(!pThis->fResetting))
+    { /*  likely */ }
+    else
     {
         Log2Func(("Aborting req submission because reset is in progress\n"));
@@ -1104 +1166 @@
         respHdr.uResponse  = VIRTIOSCSI_S_RESET;
         respHdr.uResidual  = cbDataIn + cbDataOut;
-        virtioScsiR3ReqErr(pThis, qIdx, pDescChain, &respHdr, NULL);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, qIdx, pDescChain, &respHdr, NULL);
         RTMemFree(pVirtqReq);
         return VINF_SUCCESS;
@@ -1119 +1181 @@
         respHdr.uResponse  = VIRTIOSCSI_S_OK;
         respHdr.uResidual  = cbDataOut + cbDataIn;
-        virtioScsiR3ReqErr(pThis, qIdx, pDescChain, &respHdr, abSense);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, qIdx, pDescChain, &respHdr, abSense);
         RTMemFree(pVirtqReq);
         return VINF_SUCCESS;
     }
-    if (RT_UNLIKELY(uTarget >= pThis->cTargets || !pTarget->fPresent))
+
+    if (RT_UNLIKELY(   uTarget >= pThis->cTargets
+                    || !pThisCC->paTargetInstances[uTarget].fPresent
+                    || !pThisCC->paTargetInstances[uTarget].pDrvMediaEx))
     {
         Log2Func(("Error submitting request, target not present!!\n"));
@@ -1133 +1198 @@
         respHdr.uResponse  = VIRTIOSCSI_S_BAD_TARGET;
         respHdr.uResidual  = cbDataIn + cbDataOut;
-        virtioScsiR3ReqErr(pThis, qIdx, pDescChain, &respHdr , abSense);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, qIdx, pDescChain, &respHdr , abSense);
         RTMemFree(pVirtqReq);
         return VINF_SUCCESS;
     }
+    PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[uTarget];
+
     if (RT_UNLIKELY(cbDataIn && cbDataOut && !pThis->fHasInOutBufs)) /* VirtIO 1.0, 5.6.6.1.1 */
     {
@@ -1147 +1214 @@
         respHdr.uResponse  = VIRTIOSCSI_S_FAILURE;
         respHdr.uResidual  = cbDataIn + cbDataOut;
-        virtioScsiR3ReqErr(pThis, qIdx, pDescChain, &respHdr , abSense);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, qIdx, pDescChain, &respHdr , abSense);
         RTMemFree(pVirtqReq);
         return VINF_SUCCESS;
@@ -1217 +1284 @@
         respHdr.uResponse  = VIRTIOSCSI_S_FAILURE;
         respHdr.uResidual  = cbDataIn + cbDataOut;
-        virtioScsiR3ReqErr(pThis, qIdx, pDescChain, &respHdr, abSense);
+        virtioScsiR3ReqErr(pDevIns, pThis, pThisCC, qIdx, pDescChain, &respHdr, abSense);
         virtioScsiR3FreeReq(pTarget, pReq);
     }
@@ -1229 +1296 @@
  *
  * @returns VBox status code (ignored by the caller).
- * @param   pThis       The device instance data.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       VirtIO SCSI shared instance data.
+ * @param   pThisCC     VirtIO SCSI ring-3 instance data.
  * @param   qIdx        CONTROLQ_IDX
  * @param   pDescChain  Descriptor chain to process.
  */
-static int virtioScsiR3Ctrl(PVIRTIOSCSI pThis, uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
+static int virtioScsiR3Ctrl(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
+                            uint16_t qIdx, PVIRTIO_DESC_CHAIN_T pDescChain)
 {
     uint8_t bResponse = VIRTIOSCSI_S_OK;
@@ -1262 +1332 @@
         AssertCompile(sizeof(RTGCPHYS) == sizeof(void *)); /* ASSUMING RTGCPHYS and host pointers are interchangable. (horrible!) */
         RTGCPHYS GCPhys = (RTGCPHYS)RTSgBufGetNextSegment(pDescChain->pSgPhysSend, &cbSeg);
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), GCPhys, pb, cbSeg);
+        PDMDevHlpPhysRead(pDevIns, GCPhys, pb, cbSeg);
         pb += cbSeg;
         cb -= cbSeg;
@@ -1289 +1359 @@
                       QUEUENAME(qIdx), uTarget, uScsiLun, virtioGetTMFTypeText(pScsiCtrlUnion->scsiCtrlTmf.uSubtype)));
 
-            PVIRTIOSCSITARGET pTarget = NULL;
-            if (uTarget < pThis->cTargets)
-                pTarget = &pThis->paTargetInstances[uTarget];
-
-            if (uTarget >= pThis->cTargets || !pTarget->fPresent)
+            if (uTarget >= pThis->cTargets || !pThisCC->paTargetInstances[uTarget].fPresent)
                 bResponse = VIRTIOSCSI_S_BAD_TARGET;
             else
@@ -1345 +1411 @@
             uint32_t uScsiLun = (pScsiCtrlAnQuery->abScsiLun[2] << 8 | pScsiCtrlAnQuery->abScsiLun[3]) & 0x3fff;
 
-            PVIRTIOSCSITARGET pTarget = NULL;
-            if (uTarget < pThis->cTargets)
-                pTarget = &pThis->paTargetInstances[uTarget];
-
-            if (uTarget >= pThis->cTargets || !pTarget->fPresent)
+            if (uTarget >= pThis->cTargets || !pThisCC->paTargetInstances[uTarget].fPresent)
                 bResponse = VIRTIOSCSI_S_BAD_TARGET;
             else
@@ -1395 +1457 @@
             }
 #endif
-
-            PVIRTIOSCSITARGET pTarget = NULL;
-            if (uTarget < pThis->cTargets)
-                pTarget = &pThis->paTargetInstances[uTarget];
-
-            if (uTarget >= pThis->cTargets || !pTarget->fPresent)
+            if (uTarget >= pThis->cTargets || !pThisCC->paTargetInstances[uTarget].fPresent)
                 bResponse = VIRTIOSCSI_S_BAD_TARGET;
             else
@@ -1433 +1490 @@
 
     LogFunc(("Response code: %s\n", virtioGetReqRespText(bResponse)));
-    virtioR3QueuePut( &pThis->Virtio, qIdx, &reqSegBuf, pDescChain, true);
-    virtioQueueSync(&pThis->Virtio, qIdx);
+    virtioR3QueuePut(pDevIns, &pThis->Virtio, qIdx, &reqSegBuf, pDescChain, true);
+    virtioQueueSync(pDevIns, &pThis->Virtio, qIdx);
 
     return VINF_SUCCESS;
@@ -1444 +1501 @@
 static DECLCALLBACK(int) virtioScsiR3WorkerWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    RT_NOREF(pThread);
-    uint16_t qIdx = ((uint64_t)pThread->pvUser) & 0xffff;
     PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    return SUPSemEventSignal(pThis->pSupDrvSession, pThis->aWorkers[qIdx].hEvtProcess);
+    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[(uintptr_t)pThread->pvUser].hEvtProcess);
 }
 
@@ -1455 +1510 @@
 static DECLCALLBACK(int) virtioScsiR3WorkerThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
 {
-    uint16_t const qIdx = (uint16_t)(uintptr_t)pThread->pvUser;
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[qIdx];
+    uint16_t const      qIdx      = (uint16_t)(uintptr_t)pThread->pvUser;
+    PVIRTIOSCSI         pThis     = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC       pThisCC   = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    PVIRTIOSCSIWORKER   pWorker   = &pThis->aWorkers[qIdx];
+    PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[qIdx];
 
     if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
@@ -1464 +1521 @@
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        if (virtioQueueIsEmpty(&pThis->Virtio, qIdx))
+        if (virtioQueueIsEmpty(pDevIns, &pThis->Virtio, qIdx))
         {
             /* Atomic interlocks avoid missing alarm while going to sleep & notifier waking the awoken */
-            ASMAtomicWriteBool(&pWorker->fSleeping, true);
-            bool fNotificationSent = ASMAtomicXchgBool(&pWorker->fNotified, false);
+            ASMAtomicWriteBool(&pWorkerR3->fSleeping, true);
+            bool fNotificationSent = ASMAtomicXchgBool(&pWorkerR3->fNotified, false);
             if (!fNotificationSent)
             {
                 Log6Func(("%s worker sleeping...\n", QUEUENAME(qIdx)));
-                Assert(ASMAtomicReadBool(&pWorker->fSleeping));
-                int rc = SUPSemEventWaitNoResume(pThis->pSupDrvSession, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
+                Assert(ASMAtomicReadBool(&pWorkerR3->fSleeping));
+                int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
                 AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
                 if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
                     return VINF_SUCCESS;
                 Log6Func(("%s worker woken\n", QUEUENAME(qIdx)));
-                ASMAtomicWriteBool(&pWorker->fNotified, false);
+                ASMAtomicWriteBool(&pWorkerR3->fNotified, false);
             }
-            ASMAtomicWriteBool(&pWorker->fSleeping, false);
+            ASMAtomicWriteBool(&pWorkerR3->fSleeping, false);
         }
 
@@ -1488 +1545 @@
             break;
         }
-        if (!pThis->fQuiescing)
+        if (!pThisCC->fQuiescing)
         {
              Log6Func(("fetching next descriptor chain from %s\n", QUEUENAME(qIdx)));
              PVIRTIO_DESC_CHAIN_T pDescChain;
-             int rc = virtioR3QueueGet(&pThis->Virtio, qIdx, &pDescChain, true);
+             int rc = virtioR3QueueGet(pDevIns, &pThis->Virtio, qIdx, &pDescChain, true);
              if (rc == VERR_NOT_AVAILABLE)
              {
@@ -1501 +1558 @@
              AssertRC(rc);
              if (qIdx == CONTROLQ_IDX)
-                 virtioScsiR3Ctrl(pThis, qIdx, pDescChain);
+                 virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, qIdx, pDescChain);
              else /* request queue index */
              {
-                  rc = virtioScsiR3ReqSubmit(pThis, qIdx, pDescChain);
+                  rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, qIdx, pDescChain);
                   if (RT_FAILURE(rc))
                   {
@@ -1520 +1577 @@
 *********************************************************************************************************************************/
 
-DECLINLINE(void) virtioScsiR3ReportEventsMissed(PVIRTIOSCSI pThis, uint16_t uTarget)
-{
-    virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_NO_EVENT | VIRTIOSCSI_T_EVENTS_MISSED, 0);
+DECLINLINE(void) virtioScsiR3ReportEventsMissed(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
+{
+    virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_NO_EVENT | VIRTIOSCSI_T_EVENTS_MISSED, 0);
 }
 
@@ -1530 +1587 @@
  * This effectively removes the SCSI Target/LUN on the guest side
  */
-DECLINLINE(void) virtioScsiR3ReportTargetRemoved(PVIRTIOSCSI pThis, uint16_t uTarget)
+DECLINLINE(void) virtioScsiR3ReportTargetRemoved(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fHasHotplug)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_REMOVED);
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_REMOVED);
 }
 
@@ -1539 +1596 @@
  * This effectively adds the SCSI Target/LUN on the guest side
  */
-DECLINLINE(void) virtioScsiR3ReportTargetAdded(PVIRTIOSCSI pThis, uint16_t uTarget)
+DECLINLINE(void) virtioScsiR3ReportTargetAdded(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fHasHotplug)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_RESCAN);
-}
-
-DECLINLINE(void) virtioScsiR3ReportTargetReset(PVIRTIOSCSI pThis, uint16_t uTarget)
-{
-    virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_HARD);
-}
-
-DECLINLINE(void) virtioScsiR3ReportOperChange(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_RESCAN);
+}
+
+DECLINLINE(void) virtioScsiR3ReportTargetReset(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
+{
+    virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_HARD);
+}
+
+DECLINLINE(void) virtioScsiR3ReportOperChange(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE);
-}
-
-DECLINLINE(void) virtioScsiR3ReportPowerMsg(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE);
+}
+
+DECLINLINE(void) virtioScsiR3ReportPowerMsg(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_POWER_MGMT)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_POWER_MGMT);
-}
-
-DECLINLINE(void) virtioScsiR3ReportExtReq(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_POWER_MGMT);
+}
+
+DECLINLINE(void) virtioScsiR3ReportExtReq(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST);
-}
-
-DECLINLINE(void) virtioScsiR3ReportMediaChange(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST);
+}
+
+DECLINLINE(void) virtioScsiR3ReportMediaChange(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE);
-}
-
-DECLINLINE(void) virtioScsiR3ReportMultiHost(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE);
+}
+
+DECLINLINE(void) virtioScsiR3ReportMultiHost(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_MULTI_HOST)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_MULTI_HOST);
-}
-
-DECLINLINE(void) virtioScsiR3ReportDeviceBusy(PVIRTIOSCSI pThis, uint16_t uTarget)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_MULTI_HOST);
+}
+
+DECLINLINE(void) virtioScsiR3ReportDeviceBusy(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSI pThis, uint16_t uTarget)
 {
     if (pThis->fSubscribedEvents & VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY)
-        virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY);
-}
-
-DECLINLINE(void) virtioScsiR3ReportParamChange(PVIRTIOSCSI pThis, uint16_t uTarget, uint32_t uSenseCode, uint32_t uSenseQualifier)
+        virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY);
+}
+
+DECLINLINE(void) virtioScsiR3ReportParamChange(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget,
+                                               uint32_t uSenseCode, uint32_t uSenseQualifier)
 {
     uint32_t uReason = uSenseQualifier << 8 | uSenseCode;
-    virtioScsiR3SendEvent(pThis, uTarget, VIRTIOSCSI_T_PARAM_CHANGE, uReason);
+    virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_PARAM_CHANGE, uReason);
 
 }
@@ -1598 +1656 @@
  * @callback_method_impl{FNVIRTIOQUEUENOTIFIED}
  */
-static DECLCALLBACK(void) virtioScsiR3Notified(PVIRTIOSTATE pVirtio, uint16_t qIdx)
-{
+static DECLCALLBACK(void) virtioScsiR3Notified(PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, uint16_t qIdx)
+{
+    PVIRTIOSCSI         pThis     = RT_FROM_MEMBER(pVirtio, VIRTIOSCSI, Virtio);
+    PVIRTIOSCSICC       pThisCC   = RT_FROM_MEMBER(pVirtioCC, VIRTIOSCSICC, Virtio);
+    PPDMDEVINS          pDevIns   = pThisCC->pDevIns;
     AssertReturnVoid(qIdx < VIRTIOSCSI_QUEUE_CNT);
-    PVIRTIOSCSI pThis = RT_FROM_MEMBER(pVirtio, VIRTIOSCSI, Virtio);
-    PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[qIdx];
-
-    RTLogFlush(RTLogDefaultInstanceEx(RT_MAKE_U32(0, UINT16_MAX)));
+    PVIRTIOSCSIWORKER   pWorker   = &pThis->aWorkers[qIdx];
+    PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[qIdx];
+
+    RTLogFlush(RTLogDefaultInstanceEx(RT_MAKE_U32(0, UINT16_MAX))); /** @todo r=bird: Why? RTLogFlush(NULL) perhaps, and then inside \#ifdef LOG_ENABLED... */
 
     if (qIdx == CONTROLQ_IDX || IS_REQ_QUEUE(qIdx))
@@ -1610 +1671 @@
         Log6Func(("%s has available data\n", QUEUENAME(qIdx)));
         /* Wake queue's worker thread up if sleeping */
-        if (!ASMAtomicXchgBool(&pWorker->fNotified, true))
+        if (!ASMAtomicXchgBool(&pWorkerR3->fNotified, true))
         {
-            if (ASMAtomicReadBool(&pWorker->fSleeping))
+            if (ASMAtomicReadBool(&pWorkerR3->fSleeping))
             {
                 Log6Func(("waking %s worker.\n", QUEUENAME(qIdx)));
-                int rc = SUPSemEventSignal(pThis->pSupDrvSession, pWorker->hEvtProcess);
+                int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
                 AssertRC(rc);
             }
@@ -1624 +1685 @@
         Log3Func(("Driver queued buffer(s) to %s\n", QUEUENAME(qIdx)));
         if (ASMAtomicXchgBool(&pThis->fEventsMissed, false))
-            virtioScsiR3ReportEventsMissed(pThis, 0);
+            virtioScsiR3ReportEventsMissed(pDevIns, pThis, 0);
     }
     else
@@ -1633 +1694 @@
  * @callback_method_impl{FNVIRTIOSTATUSCHANGED}
  */
-static DECLCALLBACK(void) virtioScsiR3StatusChanged(PVIRTIOSTATE pVirtio,  uint32_t fVirtioReady)
-{
-    PVIRTIOSCSI pThis = RT_FROM_MEMBER(pVirtio, VIRTIOSCSI, Virtio);
+static DECLCALLBACK(void) virtioScsiR3StatusChanged(PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, uint32_t fVirtioReady)
+{
+    PVIRTIOSCSI     pThis     = RT_FROM_MEMBER(pVirtio, VIRTIOSCSI, Virtio);
+    PVIRTIOSCSICC   pThisCC   = RT_FROM_MEMBER(pVirtioCC, VIRTIOSCSICC, Virtio);
 
     pThis->fVirtioReady = fVirtioReady;
@@ -1647 +1709 @@
         pThis->fHasInOutBufs = fFeatures & VIRTIO_SCSI_F_INOUT;
         pThis->fHasLunChange = fFeatures & VIRTIO_SCSI_F_CHANGE;
-        pThis->fQuiescing    = false;
         pThis->fResetting    = false;
-
-        for (int i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
+        pThisCC->fQuiescing  = false;
+
+        for (unsigned i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
             pThis->afQueueAttached[i] = true;
     }
@@ -1656 +1718 @@
     {
         LogFunc(("VirtIO is resetting\n"));
-        for (int i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
+        for (unsigned i = 0; i < VIRTIOSCSI_QUEUE_CNT; i++)
             pThis->afQueueAttached[i] = false;
     }
@@ -1720 +1782 @@
 static DECLCALLBACK(int) virtioScsiR3DeviceQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iTarget, PPDMLED *ppLed)
 {
-    PVIRTIOSCSI pThis = RT_FROM_MEMBER(pInterface, VIRTIOSCSI, ILeds);
+    PVIRTIOSCSICC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIOSCSICC, ILeds);
+    PVIRTIOSCSI   pThis   = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIOSCSI);
     if (iTarget < pThis->cTargets)
     {
-        *ppLed = &pThis->paTargetInstances[iTarget].led;
+        *ppLed = &pThisCC->paTargetInstances[iTarget].led;
         Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
         return VINF_SUCCESS;
@@ -1742 +1805 @@
 {
     PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaPort);
-    PPDMDEVINS pDevIns = pTarget->pVirtioScsi->CTX_SUFF(pDevIns);
+    PPDMDEVINS        pDevIns = pTarget->pDevIns;
 
     AssertPtrReturn(ppcszController, VERR_INVALID_POINTER);
@@ -1887 +1950 @@
 static DECLCALLBACK(void *) virtioScsiR3DeviceQueryInterface(PPDMIBASE pInterface, const char *pszIID)
 {
-    PVIRTIOSCSI pThis = RT_FROM_MEMBER(pInterface, VIRTIOSCSI, IBase);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE,         &pThis->IBase);
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS,     &pThis->ILeds);
+    PVIRTIOSCSICC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIOSCSICC, IBase);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE,         &pThisCC->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS,     &pThisCC->ILeds);
 
     return NULL;
@@ -1927 +1990 @@
 static DECLCALLBACK(int) virtioScsiR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
     LogFunc(("LOAD EXEC!!\n"));
 
@@ -1953 +2017 @@
     SSMR3GetU32(pSSM, &pThis->fHasLunChange);
     SSMR3GetU32(pSSM, &pThis->fResetting);
-    int rc = SSMR3GetU32(pSSM, &pThis->fQuiescing);
+    int rc = SSMR3GetU32(pSSM, &pThisCC->fQuiescing);
     AssertRCReturn(rc, rc);
 
@@ -1967 +2031 @@
 static DECLCALLBACK(int) virtioScsiR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
     LogFunc(("SAVE EXEC!!\n"));
 
@@ -1992 +2057 @@
     SSMR3PutU32(pSSM, pThis->fHasLunChange);
     SSMR3PutU32(pSSM, pThis->fResetting);
-    SSMR3PutU32(pSSM, pThis->fQuiescing); /** @todo r=bird: This shall always be false, as the VM is suspended when saving, so no need to save this */
+    SSMR3PutU32(pSSM, pThisCC->fQuiescing); /** @todo r=bird: This shall always be false, as the VM is suspended when saving, so no need to save this */
 
     /*
@@ -2013 +2078 @@
 static DECLCALLBACK(void) virtioScsiR3Detach(PPDMDEVINS pDevIns, unsigned iTarget, uint32_t fFlags)
 {
-    PVIRTIOSCSI       pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    PVIRTIOSCSITARGET pTarget = &pThis->paTargetInstances[iTarget];
+    PVIRTIOSCSI       pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    AssertReturnVoid(iTarget < pThis->cTargets);
+    PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[iTarget];
 
     LogFunc((""));
@@ -2023 +2090 @@
 
     /*
-     * Zero some important members.
+     * Zero all important members.
      */
-    pTarget->fPresent    = false;
-    pTarget->pDrvBase    = NULL;
+    pTarget->fPresent       = false;
+    pTarget->pDrvBase       = NULL;
+    pTarget->pDrvMedia      = NULL;
+    pTarget->pDrvMediaEx    = NULL;
+    pTarget->pMediaNotify   = NULL;
 }
 
@@ -2037 +2107 @@
 {
     PVIRTIOSCSI       pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    PVIRTIOSCSITARGET pTarget = &pThis->paTargetInstances[iTarget];
-    int rc;
-
-    pThis->pDevInsR3    = pDevIns;
-    pThis->pDevInsR0    = PDMDEVINS_2_R0PTR(pDevIns);
-    pThis->pDevInsRC    = PDMDEVINS_2_RCPTR(pDevIns);
-
+    PVIRTIOSCSICC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    AssertReturn(iTarget < pThis->cTargets, VERR_PDM_LUN_NOT_FOUND);
+    PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[iTarget];
+
+    Assert(pTarget->pDevIns == pDevIns);
     AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
                     ("virtio-scsi: Device does not support hotplugging\n"),
@@ -2056 +2124 @@
      * required as well as optional.
      */
-    rc = PDMDevHlpDriverAttach(pDevIns, pTarget->iTarget, &pDevIns->IBase,
-                               &pTarget->pDrvBase, (const char *)&pTarget->pszTargetName);
+    int rc = PDMDevHlpDriverAttach(pDevIns, pTarget->iTarget, &pDevIns->IBase, &pTarget->pDrvBase, pTarget->pszTargetName);
     if (RT_SUCCESS(rc))
+    {
         pTarget->fPresent = true;
+        /** @todo r=bird: Shouldn't you resolve pDrvMedia, pDrvMediaEx and
+         *        pMediaNotify here?!? */
+    }
     else
         AssertMsgFailed(("Failed to attach %s. rc=%Rrc\n", pTarget->pszTargetName, rc));
@@ -2065 +2136 @@
     if (RT_FAILURE(rc))
     {
-        pTarget->fPresent = false;
-        pTarget->pDrvBase = NULL;
+        pTarget->fPresent      = false;
+        pTarget->pDrvBase       = NULL;
+        pTarget->pDrvMedia      = NULL;
+        pTarget->pDrvMediaEx    = NULL;
+        pTarget->pMediaNotify   = NULL;
     }
     return rc;
@@ -2076 +2150 @@
 static DECLCALLBACK(bool) virtioScsiR3DeviceQuiesced(PPDMDEVINS pDevIns)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    LogFunc(("Device I/O activity quiesced: enmQuiescingFor=%d\n", pThis->enmQuiescingFor));
-
-    if (pThis->enmQuiescingFor == kvirtIoScsiQuiescingForReset)
-        virtioR3PropagateResetNotification(&pThis->Virtio);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    LogFunc(("Device I/O activity quiesced: enmQuiescingFor=%d\n", pThisCC->enmQuiescingFor));
+
+    if (pThisCC->enmQuiescingFor == kvirtIoScsiQuiescingForReset)
+        virtioR3PropagateResetNotification(pDevIns, &pThis->Virtio);
     /** @todo r=bird: Do we need other notifications here for suspend and/or poweroff? */
 
-    pThis->enmQuiescingFor = kvirtIoScsiQuiescingForInvalid;
-    pThis->fQuiescing = false;
+    pThisCC->enmQuiescingFor = kvirtIoScsiQuiescingForInvalid;
+    pThisCC->fQuiescing = false;
     return true;
 }
@@ -2093 +2168 @@
 static void virtioScsiR3QuiesceDevice(PPDMDEVINS pDevIns, VIRTIOSCSIQUIESCINGFOR enmQuiscingFor)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
 
     /* Prevent worker threads from removing/processing elements from virtq's */
-    pThis->fQuiescing = true;
-    pThis->enmQuiescingFor = enmQuiscingFor;
+    pThisCC->fQuiescing = true;
+    pThisCC->enmQuiescingFor = enmQuiscingFor;
 
     PDMDevHlpSetAsyncNotification(pDevIns, virtioScsiR3DeviceQuiesced);
@@ -2111 +2187 @@
 static void virtioScsiR3SuspendOrPowerOff(PPDMDEVINS pDevIns, VIRTIOSCSIQUIESCINGFOR enmQuiscingFor)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
 
     virtioScsiR3QuiesceDevice(pDevIns, enmQuiscingFor);
@@ -2124 +2201 @@
     for (uint32_t i = 0; i < pThis->cTargets; i++)
     {
-        PVIRTIOSCSITARGET pTarget = &pThis->paTargetInstances[i];
-        if (pTarget->pDrvBase)
-            if (pTarget->pDrvMediaEx)
-                pTarget->pDrvMediaEx->pfnNotifySuspend(pTarget->pDrvMediaEx);
+        PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[i];
+        if (pTarget->pDrvMediaEx)
+            pTarget->pDrvMediaEx->pfnNotifySuspend(pTarget->pDrvMediaEx);
     }
 }
@@ -2154 +2230 @@
 static DECLCALLBACK(void) virtioScsiR3Resume(PPDMDEVINS pDevIns)
 {
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSI     pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
     LogFunc(("\n"));
 
-    pThis->fQuiescing = false;
+    pThisCC->fQuiescing = false;
 
     /* Wake worker threads flagged to skip pulling queue entries during quiesce
@@ -2165 +2242 @@
     for (uint16_t qIdx = 0; qIdx < VIRTIOSCSI_REQ_QUEUE_CNT; qIdx++)
     {
-        PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[qIdx];
-
-        if (ASMAtomicReadBool(&pWorker->fSleeping))
+        if (ASMAtomicReadBool(&pThisCC->aWorkers[qIdx].fSleeping))
         {
             Log6Func(("waking %s worker.\n", QUEUENAME(qIdx)));
-            int rc = SUPSemEventSignal(pThis->pSupDrvSession, pWorker->hEvtProcess);
+            int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[qIdx].hEvtProcess);
             AssertRC(rc);
         }
@@ -2176 +2251 @@
 
     /* Ensure guest is working the queues too. */
-    virtioR3PropagateResumeNotification(&pThis->Virtio);
+    virtioR3PropagateResumeNotification(pDevIns, &pThis->Virtio);
 }
 
@@ -2198 +2273 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
-    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-
-    RTMemFree(pThis->paTargetInstances);
-    pThis->paTargetInstances = NULL;
+    PVIRTIOSCSI   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+
+    RTMemFree(pThisCC->paTargetInstances);
+    pThisCC->paTargetInstances = NULL;
 
     for (unsigned qIdx = 0; qIdx < VIRTIOSCSI_QUEUE_CNT; qIdx++)
@@ -2208 +2284 @@
         if (pWorker->hEvtProcess != NIL_SUPSEMEVENT)
         {
-            SUPSemEventClose(pThis->pSupDrvSession, pWorker->hEvtProcess);
+            PDMDevHlpSUPSemEventClose(pDevIns, pWorker->hEvtProcess);
             pWorker->hEvtProcess = NIL_SUPSEMEVENT;
         }
     }
 
-    virtioR3Term(&pThis->Virtio, pDevIns);
+    virtioR3Term(pDevIns, &pThis->Virtio, &pThisCC->Virtio);
     return VINF_SUCCESS;
 }
@@ -2223 +2299 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
-    PVIRTIOSCSI   pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
-    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
+    PVIRTIOSCSI   pThis   = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
+    PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
+    PCPDMDEVHLPR3 pHlp    = pDevIns->pHlpR3;
 
     /*
      * Quick initialization of the state data, making sure that the destructor always works.
      */
-    pThis->pDevInsR3 = pDevIns;
-    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pThis->pSupDrvSession = PDMDevHlpGetSupDrvSession(pDevIns);
+    pThisCC->pDevIns = pDevIns;
 
     LogFunc(("PDM device instance: %d\n", iInstance));
     RTStrPrintf(pThis->szInstance, sizeof(pThis->szInstance), "VIRTIOSCSI%d", iInstance);
 
-    pThis->IBase.pfnQueryInterface = virtioScsiR3DeviceQueryInterface;
+    pThisCC->IBase.pfnQueryInterface = virtioScsiR3DeviceQueryInterface;
+    pThisCC->ILeds.pfnQueryStatusLed = virtioScsiR3DeviceQueryStatusLed;
 
     /*
@@ -2277 +2352 @@
 
     /* Initialize the generic Virtio core: */
-    pThis->Virtio.Callbacks.pfnStatusChanged  = virtioScsiR3StatusChanged;
-    pThis->Virtio.Callbacks.pfnQueueNotified  = virtioScsiR3Notified;
-    pThis->Virtio.Callbacks.pfnDevCapRead     = virtioScsiR3DevCapRead;
-    pThis->Virtio.Callbacks.pfnDevCapWrite    = virtioScsiR3DevCapWrite;
+    pThisCC->Virtio.Callbacks.pfnStatusChanged  = virtioScsiR3StatusChanged;
+    pThisCC->Virtio.Callbacks.pfnQueueNotified  = virtioScsiR3Notified;
+    pThisCC->Virtio.Callbacks.pfnDevCapRead     = virtioScsiR3DevCapRead;
+    pThisCC->Virtio.Callbacks.pfnDevCapWrite    = virtioScsiR3DevCapWrite;
 
     VIRTIOPCIPARAMS VirtioPciParams;
@@ -2293 +2368 @@
     VirtioPciParams.uInterruptPin       = 0x01;
 
-    rc = virtioR3Init(&pThis->Virtio, pDevIns, &VirtioPciParams, pThis->szInstance, VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED,
+    rc = virtioR3Init(pDevIns, &pThis->Virtio, &pThisCC->Virtio, &VirtioPciParams, pThis->szInstance,
+                      VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED,
                       &pThis->virtioScsiConfig /*pvDevSpecificCap*/, sizeof(pThis->virtioScsiConfig));
 
@@ -2318 +2394 @@
         if (qIdx == CONTROLQ_IDX || IS_REQ_QUEUE(qIdx))
         {
-            rc = PDMDevHlpThreadCreate(pDevIns, &pThis->aWorkers[qIdx].pThread,
+            rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[qIdx].pThread,
                                        (void *)(uintptr_t)qIdx, virtioScsiR3WorkerThread,
                                        virtioScsiR3WorkerWakeUp, 0, RTTHREADTYPE_IO, QUEUENAME(qIdx));
@@ -2327 +2403 @@
             }
 
-            rc = SUPSemEventCreate(pThis->pSupDrvSession, &pThis->aWorkers[qIdx].hEvtProcess);
+            rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->aWorkers[qIdx].hEvtProcess);
             if (RT_FAILURE(rc))
                 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
@@ -2340 +2416 @@
     Log2Func(("Probing %d targets ...\n", pThis->cTargets));
 
-    pThis->paTargetInstances = (PVIRTIOSCSITARGET)RTMemAllocZ(sizeof(VIRTIOSCSITARGET) * pThis->cTargets);
-    if (!pThis->paTargetInstances)
+    pThisCC->paTargetInstances = (PVIRTIOSCSITARGET)RTMemAllocZ(sizeof(VIRTIOSCSITARGET) * pThis->cTargets);
+    if (!pThisCC->paTargetInstances)
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to allocate memory for target states"));
 
-    for (RTUINT iTarget = 0; iTarget < pThis->cTargets; iTarget++)
-    {
-        PVIRTIOSCSITARGET pTarget = &pThis->paTargetInstances[iTarget];
+    for (uint32_t iTarget = 0; iTarget < pThis->cTargets; iTarget++)
+    {
+        PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[iTarget];
 
         if (RTStrAPrintf(&pTarget->pszTargetName, "VSCSI%u", iTarget) < 0)
@@ -2352 +2428 @@
 
         /* Initialize static parts of the device. */
+        pTarget->pDevIns = pDevIns;
         pTarget->iTarget = iTarget;
-        pTarget->pVirtioScsi = pThis;
         pTarget->led.u32Magic = PDMLED_MAGIC;
 
@@ -2372 +2448 @@
         pTarget->IBase.pfnQueryInterface                 = virtioScsiR3TargetQueryInterface;
         pTarget->ILed.pfnQueryStatusLed                  = virtioScsiR3TargetQueryStatusLed;
-        pThis->ILeds.pfnQueryStatusLed                   = virtioScsiR3DeviceQueryStatusLed;
         pTarget->led.u32Magic                            = PDMLED_MAGIC;
 
@@ -2400 +2475 @@
 
             pTarget->pMediaNotify = PDMIBASE_QUERY_INTERFACE(pTarget->pDrvBase, PDMIMEDIANOTIFY);
-            AssertMsgReturn(VALID_PTR(pTarget->pDrvMediaEx),
+            AssertMsgReturn(VALID_PTR(pTarget->pMediaNotify),
                             ("virtio-scsi configuration error: LUN#%u: Failed to get set Media notify obj!\n", iTarget),
                             VERR_PDM_MISSING_INTERFACE);
@@ -2424 +2499 @@
     PPDMIBASE pUpBase;
     AssertCompile(PDM_STATUS_LUN >= VIRTIOSCSI_MAX_TARGETS);
-    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pUpBase, "Status Port");
+    rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pUpBase, "Status Port");
     if (RT_FAILURE(rc) && rc != VERR_PDM_NO_ATTACHED_DRIVER)
         return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the status LUN"));

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

@@ -121 +121 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static void virtioNotifyGuestDriver(PVIRTIOSTATE pVirtio, uint16_t idxQueue, bool fForce);
-static int  virtioKick(PVIRTIOSTATE pVirtio, uint8_t uCause, uint16_t uVec, bool fForce);
+static void virtioNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, bool fForce);
+static int  virtioKick(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint8_t uCause, uint16_t uVec, bool fForce);
 
 /** @name Internal queue operations
@@ -137 +137 @@
  * Accessor for virtq descriptor
  */
-DECLINLINE(void) virtioReadDesc(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t uDescIdx, PVIRTQ_DESC_T pDesc)
+DECLINLINE(void) virtioReadDesc(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue,
+                                uint32_t idxDesc, PVIRTQ_DESC_T pDesc)
 {
     //Log(("%s virtioQueueReadDesc: ring=%p idx=%u\n", INSTANCE(pState), pVirtQ, idx));
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
-                      pVirtio->aGCPhysQueueDesc[idxQueue] + sizeof(VIRTQ_DESC_T) * (uDescIdx % pVirtio->uQueueSize[idxQueue]),
+    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    PDMDevHlpPhysRead(pDevIns, /** @todo r=bird: PDMDevHlpPhysRead or PDMDevHlpPCIPhysRead ?!? (ditto rest of file + writes) */
+                      pVirtio->aGCPhysQueueDesc[idxQueue] + sizeof(VIRTQ_DESC_T) * (idxDesc % cQueueItems),
                       pDesc, sizeof(VIRTQ_DESC_T));
 }
@@ -149 +151 @@
  * Accessors for virtq avail ring
  */
-DECLINLINE(uint16_t) virtioReadAvailDescIdx(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t availIdx)
+DECLINLINE(uint16_t) virtioReadAvailDescIdx(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t availIdx)
 {
     uint16_t uDescIdx;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    PDMDevHlpPhysRead(pDevIns,
                         pVirtio->aGCPhysQueueAvail[idxQueue]
-                      + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[availIdx % pVirtio->uQueueSize[idxQueue]]),
+                      + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[availIdx % cQueueItems]),
                       &uDescIdx, sizeof(uDescIdx));
     return uDescIdx;
 }
 
-DECLINLINE(uint16_t) virtioReadAvailRingIdx(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailRingIdx(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     uint16_t uIdx = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF(VIRTQ_AVAIL_T, uIdx),
                       &uIdx, sizeof(uIdx));
@@ -170 +173 @@
 }
 
-DECLINLINE(bool) virtqIsEmpty(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
-{
-    return virtioReadAvailRingIdx(pVirtio, idxQueue) == pVirtio->virtqState[idxQueue].uAvailIdx;
+DECLINLINE(bool) virtqIsEmpty(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+{
+    return virtioReadAvailRingIdx(pDevIns, pVirtio, idxQueue) == pVirtio->virtqState[idxQueue].uAvailIdx;
 }
 
 #if 0 /* unused */
-DECLINLINE(uint16_t) virtioReadAvailFlags(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailFlags(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     uint16_t fFlags;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF(VIRTQ_AVAIL_T, fFlags),
                       &fFlags, sizeof(fFlags));
@@ -187 +190 @@
 #endif
 
-DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadAvailUsedEvent(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     uint16_t uUsedEventIdx;
-    /** VirtIO 1.0 uUsedEventIdx (used_event) immediately follows ring */
+    /* VirtIO 1.0 uUsedEventIdx (used_event) immediately follows ring */
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueAvail[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_AVAIL_T, auRing[pVirtio->uQueueSize[idxQueue]]),
                       &uUsedEventIdx, sizeof(uUsedEventIdx));
@@ -202 +205 @@
  * @{
  */
-DECLINLINE(void) virtioWriteUsedElem(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t usedIdx, uint32_t uDescIdx, uint32_t uLen)
+DECLINLINE(void) virtioWriteUsedElem(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue,
+                                     uint32_t usedIdx, uint32_t uDescIdx, uint32_t uLen)
 {
     VIRTQ_USED_ELEM_T elem = { uDescIdx,  uLen };
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPCIPhysWrite(pVirtio->CTX_SUFF(pDevIns),
-                            pVirtio->aGCPhysQueueUsed[idxQueue]
-                          + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[usedIdx % pVirtio->uQueueSize[idxQueue]]),
+    uint16_t const cQueueItems = RT_MAX(pVirtio->uQueueSize[idxQueue], 1); /* Make sure to avoid div-by-zero. */
+    PDMDevHlpPCIPhysWrite(pDevIns,
+                          pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[usedIdx % cQueueItems]),
                           &elem, sizeof(elem));
 }
 
-DECLINLINE(void) virtioWriteUsedRingIdx(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint16_t uIdx)
+DECLINLINE(void) virtioWriteUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint16_t uIdx)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPCIPhysWrite(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPCIPhysWrite(pDevIns,
                           pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                           &uIdx, sizeof(uIdx));
@@ -221 +225 @@
 
 #ifdef LOG_ENABLED
-DECLINLINE(uint16_t) virtioReadUsedRingIdx(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
-{
-    uint16_t uIdx;
+DECLINLINE(uint16_t) virtioReadUsedRingIdx(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+{
+    uint16_t uIdx = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, uIdx),
                       &uIdx, sizeof(uIdx));
@@ -232 +236 @@
 #endif
 
-DECLINLINE(uint16_t) virtioReadUsedFlags(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
-{
-    uint16_t fFlags;
+DECLINLINE(uint16_t) virtioReadUsedFlags(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+{
+    uint16_t fFlags = 0;
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
                       &fFlags, sizeof(fFlags));
@@ -243 +247 @@
 
 #if 0 /* unused */
-DECLINLINE(void) virtioWriteUsedFlags(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t fFlags)
+DECLINLINE(void) virtioWriteUsedFlags(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t fFlags)
 {
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     RT_UNTRUSTED_VALIDATED_FENCE(); /* VirtIO 1.0, Section 3.2.1.4.1 */
-    PDMDevHlpPCIPhysWrite(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPCIPhysWrite(pDevIns,
                           pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
                           &fFlags, sizeof(fFlags));
@@ -254 +258 @@
 
 #if 0 /* unused */
-DECLINLINE(uint16_t) virtioReadUsedAvailEvent(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+DECLINLINE(uint16_t) virtioReadUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     uint16_t uAvailEventIdx;
@@ -260 +264 @@
     /** VirtIO 1.0 uAvailEventIdx (avail_event) immediately follows ring */
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPhysRead(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPhysRead(pDevIns,
                       pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[pVirtio->uQueueSize[idxQueue]]),
                       &uAvailEventIdx, sizeof(uAvailEventIdx));
@@ -268 +272 @@
 
 #if 0 /* unused */
-DECLINLINE(void) virtioWriteUsedAvailEvent(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t uAvailEventIdx)
+DECLINLINE(void) virtioWriteUsedAvailEvent(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint32_t uAvailEventIdx)
 {
     /** VirtIO 1.0 uAvailEventIdx (avail_event) immediately follows ring */
     AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
-    PDMDevHlpPCIPhysWrite(pVirtio->CTX_SUFF(pDevIns),
+    PDMDevHlpPCIPhysWrite(pDevIns,
                           pVirtio->aGCPhysQueueUsed[idxQueue] + RT_UOFFSETOF_DYN(VIRTQ_USED_T, aRing[pVirtio->uQueueSize[idxQueue]]),
                           &uAvailEventIdx, sizeof(uAvailEventIdx));
@@ -411 +415 @@
  * Allocate client context for client to work with VirtIO-provided with queue
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue number
  * @param   pcszName    Name to give queue
@@ -454 +458 @@
  * Check if the associated queue is empty
  *
- * @param hVirtio       Handle for VirtIO framework
- * @param idxQueue          Queue number
+ * @param   pDevIns     The device instance (for reading).
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   idxQueue    Queue number
  *
  * @retval true  Queue is empty or unavailable.
  * @retval false Queue is available and has entries
  */
-bool virtioQueueIsEmpty(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+bool virtioQueueIsEmpty(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     if (pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK)
-        return virtqIsEmpty(pVirtio, idxQueue);
+        return virtqIsEmpty(pDevIns, pVirtio, idxQueue);
     return true;
 }
@@ -478 +483 @@
  * at some point to return the data to the guest and complete the transaction.
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue number
  * @param   fRemove     flags whether to remove desc chain from queue (false = peek)
@@ -489 +495 @@
  * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
  */
-int virtioR3QueueGet(PVIRTIOSTATE pVirtio, uint16_t idxQueue, PPVIRTIO_DESC_CHAIN_T ppDescChain,  bool fRemove)
+int virtioR3QueueGet(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue,
+                     PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove)
 {
     AssertReturn(ppDescChain, VERR_INVALID_PARAMETER);
@@ -505 +512 @@
                     ("Guest driver not in ready state.\n"), VERR_INVALID_STATE);
 
-    if (virtqIsEmpty(pVirtio, idxQueue))
+    if (virtqIsEmpty(pDevIns, pVirtio, idxQueue))
         return VERR_NOT_AVAILABLE;
 
-    uint16_t uHeadIdx = virtioReadAvailDescIdx(pVirtio, idxQueue, pVirtq->uAvailIdx);
+    uint16_t uHeadIdx = virtioReadAvailDescIdx(pDevIns, pVirtio, idxQueue, pVirtq->uAvailIdx);
     uint16_t uDescIdx = uHeadIdx;
 
@@ -545 +552 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        virtioReadDesc(pVirtio, idxQueue, uDescIdx, &desc);
+        virtioReadDesc(pDevIns, pVirtio, idxQueue, uDescIdx, &desc);
 
         if (desc.fFlags & VIRTQ_DESC_F_WRITE)
@@ -604 +611 @@
  *
  *
- * @param   pVirtio         Pointer to the virtio state.
+ * @param   pDevIns         The device instance (for reading).
+ * @param   pVirtio         Pointer to the shared virtio state.
  * @param   idxQueue        Queue number
  *
@@ -621 +629 @@
  * @retval  VERR_NOT_AVAILABLE Queue is empty
  */
-int virtioR3QueuePut(PVIRTIOSTATE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
+int virtioR3QueuePut(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
                      PVIRTIO_DESC_CHAIN_T pDescChain, bool fFence)
 {
@@ -632 +640 @@
 
     Log3Func(("Copying client data to %s, desc chain (head desc_idx %d)\n",
-              QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pVirtio, idxQueue)));
+              QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue)));
 
     /*
@@ -650 +658 @@
         uint64_t dstSgCur   = (uint64_t)pSgPhysReturn->pvSegCur;
         cbCopy = RT_MIN((uint64_t)pSgVirtReturn->cbSegLeft, dstSgLen - (dstSgCur - dstSgStart));
-        PDMDevHlpPhysWrite(pVirtio->CTX_SUFF(pDevIns),
-                           (RTGCPHYS)pSgPhysReturn->pvSegCur, pSgVirtReturn->pvSegCur, cbCopy);
+        PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)pSgPhysReturn->pvSegCur, pSgVirtReturn->pvSegCur, cbCopy);
         RTSgBufAdvance(pSgVirtReturn, cbCopy);
         RTSgBufAdvance(pSgPhysReturn, cbCopy);
@@ -660 +667 @@
         RT_UNTRUSTED_NONVOLATILE_COPY_FENCE(); /* needed? */
 
-    /** If this write-ahead crosses threshold where the driver wants to get an event flag it */
+    /* If this write-ahead crosses threshold where the driver wants to get an event flag it */
     if (pVirtio->uDriverFeatures & VIRTIO_F_EVENT_IDX)
-        if (pVirtq->uUsedIdx == virtioReadAvailUsedEvent(pVirtio, idxQueue))
+        if (pVirtq->uUsedIdx == virtioReadAvailUsedEvent(pDevIns, pVirtio, idxQueue))
             pVirtq->fEventThresholdReached = true;
 
-    Assert(!(cbCopy & UINT64_C(0xffffffff00000000)));
+    Assert(!(cbCopy >> 32));
 
     /*
      * Place used buffer's descriptor in used ring but don't update used ring's slot index.
      * That will be done with a subsequent client call to virtioQueueSync() */
-    virtioWriteUsedElem(pVirtio, idxQueue, pVirtq->uUsedIdx++, pDescChain->uHeadIdx, (uint32_t)(cbCopy & UINT32_C(0xffffffff)));
-
-    Log2Func((".... Copied %lu bytes to %lu byte buffer, residual=%lu\n",
+    virtioWriteUsedElem(pDevIns, pVirtio, idxQueue, pVirtq->uUsedIdx++, pDescChain->uHeadIdx, (uint32_t)cbCopy);
+
+    Log2Func((".... Copied %zu bytes to %u byte buffer, residual=%zu\n",
               cbCopy, pDescChain->cbPhysReturn, pDescChain->cbPhysReturn - cbCopy));
 
-    Log6Func(("Write ahead used_idx=%d, %s used_idx=%d\n",
-              pVirtq->uUsedIdx, QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pVirtio, idxQueue)));
+    Log6Func(("Write ahead used_idx=%u, %s used_idx=%u\n",
+              pVirtq->uUsedIdx, QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue)));
 
     RTMemFree((void *)pDescChain->pSgPhysSend->paSegs);
@@ -699 +706 @@
  * specification, Section 2.4 "Virtqueues").
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue number
  *
@@ -706 +714 @@
  * @retval  VERR_INVALID_STATE VirtIO not in ready state
  */
-int virtioQueueSync(PVIRTIOSTATE pVirtio, uint16_t idxQueue)
+int virtioQueueSync(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue)
 {
     Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
@@ -715 +723 @@
 
     Log6Func(("Updating %s used_idx from %u to %u\n",
-              QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pVirtio, idxQueue), pVirtq->uUsedIdx));
-
-    virtioWriteUsedRingIdx(pVirtio, idxQueue, pVirtq->uUsedIdx);
-    virtioNotifyGuestDriver(pVirtio, idxQueue, false);
+              QUEUENAME(pVirtio, idxQueue), virtioReadUsedRingIdx(pDevIns, pVirtio, idxQueue), pVirtq->uUsedIdx));
+
+    virtioWriteUsedRingIdx(pDevIns, pVirtio, idxQueue, pVirtq->uUsedIdx);
+    virtioNotifyGuestDriver(pDevIns, pVirtio, idxQueue, false);
 
     return VINF_SUCCESS;
@@ -726 +734 @@
 /**
  */
-static void virtior3QueueNotified(PVIRTIOSTATE pVirtio, uint16_t idxQueue, uint16_t uNotifyIdx)
+static void virtioR3QueueNotified(PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, uint16_t idxQueue, uint16_t uNotifyIdx)
 {
     /* See VirtIO 1.0, section 4.1.5.2 It implies that idxQueue and uNotifyIdx should match.
@@ -742 +750 @@
 
     AssertReturnVoid(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
-    PVIRTQSTATE pVirtq = &pVirtio->virtqState[idxQueue];
-    Log6Func(("%s\n", pVirtq->szVirtqName));
-    RT_NOREF(pVirtq);
+    Log6Func(("%s\n", pVirtio->virtqState[idxQueue].szVirtqName));
 
     /* Inform client */
-    pVirtio->Callbacks.pfnQueueNotified(pVirtio, idxQueue);
+    pVirtioCC->Callbacks.pfnQueueNotified(pVirtio, pVirtioCC, idxQueue);
 }
 #endif /* IN_RING3 */
@@ -758 +764 @@
  * See VirtIO 1.0 specification (section 2.4.7).
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue to check for guest interrupt handling preference
  * @param   fForce      Overrides idxQueue, forcing notification regardless of driver's
@@ -766 +773 @@
  *                      as they only cause the guest driver to [re]scan queues for work to do.
  */
-static void virtioNotifyGuestDriver(PVIRTIOSTATE pVirtio, uint16_t idxQueue, bool fForce)
+static void virtioNotifyGuestDriver(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, bool fForce)
 {
     Assert(idxQueue < RT_ELEMENTS(pVirtio->virtqState));
@@ -776 +783 @@
         if (pVirtq->fEventThresholdReached)
         {
-            virtioKick(pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue], fForce);
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue], fForce);
             pVirtq->fEventThresholdReached = false;
             return;
@@ -785 +792 @@
     {
         /** If guest driver hasn't suppressed interrupts, interrupt  */
-        if (fForce || !(virtioReadUsedFlags(pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT))
+        if (fForce || !(virtioReadUsedFlags(pDevIns, pVirtio, idxQueue) & VIRTQ_AVAIL_F_NO_INTERRUPT))
         {
-            virtioKick(pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue], fForce);
+            virtioKick(pDevIns, pVirtio, VIRTIO_ISR_VIRTQ_INTERRUPT, pVirtio->uQueueMsixVector[idxQueue], fForce);
             return;
         }
@@ -797 +804 @@
  * Raise interrupt or MSI-X
  *
- * @param   pVirtio         The device state structure.
- * @param   uCause          Interrupt cause bit mask to set in PCI ISR port.
- * @param   uVec            MSI-X vector, if enabled
- * @param   uForce          True of out-of-band
- */
-static int virtioKick(PVIRTIOSTATE pVirtio, uint8_t uCause, uint16_t uMsixVector, bool fForce)
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   uCause      Interrupt cause bit mask to set in PCI ISR port.
+ * @param   uVec        MSI-X vector, if enabled
+ * @param   uForce      True of out-of-band
+ */
+static int virtioKick(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint8_t uCause, uint16_t uMsixVector, bool fForce)
 {
    if (fForce)
@@ -816 +824 @@
     {
         pVirtio->uISR |= uCause;
-        PDMDevHlpPCISetIrq(pVirtio->CTX_SUFF(pDevIns), 0, PDM_IRQ_LEVEL_HIGH);
+        PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
     }
     else if (uMsixVector != VIRTIO_MSI_NO_VECTOR)
     {
         Log6Func(("MSI-X enabled, calling PDMDevHlpPCISetIrq with vector: 0x%x\n", uMsixVector));
-        PDMDevHlpPCISetIrq(pVirtio->CTX_SUFF(pDevIns), uMsixVector, 1);
+        PDMDevHlpPCISetIrq(pDevIns, uMsixVector, 1);
     }
     return VINF_SUCCESS;
@@ -829 +837 @@
  * Lower interrupt. (Called when guest reads ISR)
  *
- * @param   pVirtio      The device state structure.
- */
-static void virtioLowerInterrupt(PVIRTIOSTATE pVirtio)
-{
-    PDMDevHlpPCISetIrq(pVirtio->CTX_SUFF(pDevIns), 0, PDM_IRQ_LEVEL_LOW);
+ * @param   pDevIns     The device instance.
+ */
+static void virtioLowerInterrupt(PPDMDEVINS pDevIns)
+{
+    PDMDevHlpPCISetIrq(pDevIns, 0, PDM_IRQ_LEVEL_LOW);
 }
 
@@ -851 +859 @@
 }
 
-static void virtioResetDevice(PVIRTIOSTATE pVirtio)
+static void virtioResetDevice(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio)
 {
     Log2Func(("\n"));
@@ -860 +868 @@
     pVirtio->uISR                   = 0;
 
-    virtioLowerInterrupt(pVirtio);
+    virtioLowerInterrupt(pDevIns);
 
     if (!pVirtio->fMsiSupport)  /* VirtIO 1.0, 4.1.4.3 and 4.1.5.1.2 */
@@ -874 +882 @@
  * Enable or disable queue
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   idxQueue    Queue number
  * @param   fEnabled    Flag indicating whether to enable queue or not
@@ -909 +917 @@
  * The driver itself will not  until the device has read the status change.
  */
-static void virtioGuestR3Resetted(PVIRTIOSTATE pVirtio)
+static void virtioGuestR3WasReset(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC)
 {
     LogFunc(("Guest reset the device\n"));
 
     /* Let the client know */
-    pVirtio->Callbacks.pfnStatusChanged(pVirtio, 0);
-    virtioResetDevice(pVirtio);
+    pVirtioCC->Callbacks.pfnStatusChanged(pVirtio, pVirtioCC, 0);
+    virtioResetDevice(pDevIns, pVirtio);
 }
 #endif /* IN_RING3 */
@@ -924 +932 @@
  * @returns VBox status code
  *
- * @param   pVirtio     Virtio instance state
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   pVirtioCC   Pointer to the current context virtio state.
  * @param   fWrite      Set if write access, clear if read access.
  * @param   offCfg      The common configuration capability offset.
@@ -930 +940 @@
  * @param   pv          Pointer to location to write to or read from
  */
-static int virtioCommonCfgAccessed(PVIRTIOSTATE pVirtio, int fWrite, off_t offCfg, unsigned cb, void *pv)
+static int virtioCommonCfgAccessed(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, int fWrite, off_t offCfg, unsigned cb, void *pv)
 {
 /**
@@ -1100 +1110 @@
         if (fWrite) /* Guest WRITE pCommonCfg->uDeviceStatus */
         {
-            pVirtio->uDeviceStatus = *(uint8_t *)pv;
-            Log6Func(("Guest wrote uDeviceStatus ................ ("));
-            virtioLogDeviceStatus(pVirtio->uDeviceStatus);
+            uint8_t const fNewStatus = *(uint8_t *)pv;
+            Log6Func(("Guest wrote uDeviceStatus (%#x, was %#x, change #%x) ................ (",
+                      fNewStatus, pVirtio->uDeviceStatus, fNewStatus ^ pVirtio->uDeviceStatus));
+            virtioLogDeviceStatus(fNewStatus);
             Log6((")\n"));
+
+            /* If the status changed or we were reset, we need to go to ring-3 as
+               it requires notifying the parent device. */
+            bool const fStatusChanged =    (fNewStatus & VIRTIO_STATUS_DRIVER_OK)
+                                        != (pVirtio->uPrevDeviceStatus & VIRTIO_STATUS_DRIVER_OK);
+#ifndef IN_RING3
+            if (fStatusChanged || fNewStatus == 0)
+            {
+                Log6Func(("=>ring3\n"));
+                return VINF_IOM_R3_MMIO_WRITE;
+            }
+#endif
+            pVirtio->uDeviceStatus = fNewStatus;
+
+#ifdef IN_RING3
+            /*
+             * Notify client only if status actually changed from last time and when we're reset.
+             */
             if (pVirtio->uDeviceStatus == 0)
-                virtioGuestR3Resetted(pVirtio);
+                virtioGuestR3WasReset(pDevIns, pVirtio, pVirtioCC);
+            if (fStatusChanged)
+                pVirtioCC->Callbacks.pfnStatusChanged(pVirtio, pVirtioCC, fNewStatus & VIRTIO_STATUS_DRIVER_OK);
+#endif
             /*
-             * Notify client only if status actually changed from last time.
+             * Save the current status for the next write so we can see what changed.
              */
-            uint32_t const fOkayNow = pVirtio->uDeviceStatus     & VIRTIO_STATUS_DRIVER_OK;
-            uint32_t const fWasOkay = pVirtio->uPrevDeviceStatus & VIRTIO_STATUS_DRIVER_OK;
-            if (fOkayNow != fWasOkay)
-                pVirtio->Callbacks.pfnStatusChanged(pVirtio, fOkayNow);
             pVirtio->uPrevDeviceStatus = pVirtio->uDeviceStatus;
         }
@@ -1182 +1210 @@
 static DECLCALLBACK(VBOXSTRICTRC) virtioMmioRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE   pVirtio   = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATECC pVirtioCC = PDMINS_2_DATA_CC(pDevIns, PVIRTIOSTATECC);
     Assert(pVirtio == (PVIRTIOSTATE)pvUser); RT_NOREF(pvUser);
 
@@ -1200 +1229 @@
          * Callback to client to manage device-specific configuration.
          */
-        VBOXSTRICTRC rcStrict = pVirtio->Callbacks.pfnDevCapRead(pDevIns, offIntra, pv, cb);
+        VBOXSTRICTRC rcStrict = pVirtioCC->Callbacks.pfnDevCapRead(pDevIns, offIntra, pv, cb);
 
         /*
@@ -1207 +1236 @@
          * order to maintain the config generation (see VirtIO 1.0 spec, section 4.1.4.3.1)
          */
-        bool fDevSpecificFieldChanged = !!memcmp((char *)pVirtio->pvDevSpecificCfg + offIntra,
-                                                 (char *)pVirtio->pvPrevDevSpecificCfg + offIntra,
-                                                 RT_MIN(cb, pVirtio->cbDevSpecificCfg - offIntra));
-
-        memcpy(pVirtio->pvPrevDevSpecificCfg, pVirtio->pvDevSpecificCfg, pVirtio->cbDevSpecificCfg);
+        bool fDevSpecificFieldChanged = !!memcmp(pVirtioCC->pbDevSpecificCfg + offIntra,
+                                                 pVirtioCC->pbPrevDevSpecificCfg + offIntra,
+                                                 RT_MIN(cb, pVirtioCC->cbDevSpecificCfg - offIntra));
+
+        memcpy(pVirtioCC->pbPrevDevSpecificCfg, pVirtioCC->pbDevSpecificCfg, pVirtioCC->cbDevSpecificCfg);
 
         if (pVirtio->fGenUpdatePending || fDevSpecificFieldChanged)
@@ -1229 +1258 @@
 
     if (MATCHES_VIRTIO_CAP_STRUCT(off, cb, offIntra, pVirtio->LocCommonCfgCap))
-        return virtioCommonCfgAccessed(pVirtio, false /* fWrite */, offIntra, cb, pv);
+        return virtioCommonCfgAccessed(pDevIns, pVirtio, pVirtioCC, false /* fWrite */, offIntra, cb, pv);
 
     if (MATCHES_VIRTIO_CAP_STRUCT(off, cb, offIntra, pVirtio->LocIsrCap) && cb == sizeof(uint8_t))
@@ -1236 +1265 @@
         Log6Func(("Read and clear ISR\n"));
         pVirtio->uISR = 0; /* VirtIO specification requires reads of ISR to clear it */
-        virtioLowerInterrupt(pVirtio);
+        virtioLowerInterrupt(pDevIns);
         return VINF_SUCCESS;
     }
@@ -1250 +1279 @@
 static DECLCALLBACK(VBOXSTRICTRC) virtioMmioWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE   pVirtio   = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATECC pVirtioCC = PDMINS_2_DATA_CC(pDevIns, PVIRTIOSTATECC);
     Assert(pVirtio == (PVIRTIOSTATE)pvUser); RT_NOREF(pvUser);
 
@@ -1268 +1298 @@
          * Pass this MMIO write access back to the client to handle
          */
-        return pVirtio->Callbacks.pfnDevCapWrite(pDevIns, offIntra, pv, cb);
+        return pVirtioCC->Callbacks.pfnDevCapWrite(pDevIns, offIntra, pv, cb);
 #else
         return VINF_IOM_R3_MMIO_WRITE;
@@ -1275 +1305 @@
 
     if (MATCHES_VIRTIO_CAP_STRUCT(off, cb, offIntra, pVirtio->LocCommonCfgCap))
-        return virtioCommonCfgAccessed(pVirtio, true /* fWrite */, offIntra, cb, (void *)pv);
+        return virtioCommonCfgAccessed(pDevIns, pVirtio, pVirtioCC, true /* fWrite */, offIntra, cb, (void *)pv);
 
     if (MATCHES_VIRTIO_CAP_STRUCT(off, cb, offIntra, pVirtio->LocIsrCap) && cb == sizeof(uint8_t))
@@ -1291 +1321 @@
     {
 #ifdef IN_RING3
-        virtior3QueueNotified(pVirtio, offIntra / VIRTIO_NOTIFY_OFFSET_MULTIPLIER, *(uint16_t *)pv);
+        virtioR3QueueNotified(pVirtio, pVirtioCC, offIntra / VIRTIO_NOTIFY_OFFSET_MULTIPLIER, *(uint16_t *)pv);
 #else
         return VINF_IOM_R3_MMIO_WRITE;
@@ -1309 +1339 @@
                                                         uint32_t uAddress, unsigned cb, uint32_t *pu32Value)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE   pVirtio   = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATECC pVirtioCC = PDMINS_2_DATA_CC(pDevIns, PVIRTIOSTATECC);
     RT_NOREF(pPciDev);
 
@@ -1321 +1352 @@
          * (the virtio_pci_cfg_cap capability), and access data items.
          */
-        uint32_t uLength = pVirtio->pPciCfgCap->pciCap.uLength;
-        uint32_t uOffset = pVirtio->pPciCfgCap->pciCap.uOffset;
-        uint8_t  uBar    = pVirtio->pPciCfgCap->pciCap.uBar;
+        uint32_t uLength = pVirtioCC->pPciCfgCap->pciCap.uLength;
+        uint32_t uOffset = pVirtioCC->pPciCfgCap->pciCap.uOffset;
+        uint8_t  uBar    = pVirtioCC->pPciCfgCap->pciCap.uBar;
 
         if (   (uLength != 1 && uLength != 2 && uLength != 4)
@@ -1348 +1379 @@
                                                          uint32_t uAddress, unsigned cb, uint32_t u32Value)
 {
-    PVIRTIOSTATE pVirtio = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATE   pVirtio   = PDMINS_2_DATA(pDevIns, PVIRTIOSTATE);
+    PVIRTIOSTATECC pVirtioCC = PDMINS_2_DATA_CC(pDevIns, PVIRTIOSTATECC);
     RT_NOREF(pPciDev);
 
@@ -1358 +1390 @@
          * (the virtio_pci_cfg_cap capability), and access data items. */
 
-        uint32_t uLength = pVirtio->pPciCfgCap->pciCap.uLength;
-        uint32_t uOffset = pVirtio->pPciCfgCap->pciCap.uOffset;
-        uint8_t  uBar    = pVirtio->pPciCfgCap->pciCap.uBar;
+        uint32_t uLength = pVirtioCC->pPciCfgCap->pciCap.uLength;
+        uint32_t uOffset = pVirtioCC->pPciCfgCap->pciCap.uOffset;
+        uint8_t  uBar    = pVirtioCC->pPciCfgCap->pciCap.uBar;
 
         if (   (uLength != 1 && uLength != 2 && uLength != 4)
@@ -1386 +1418 @@
  * Called from the FNSSMDEVSAVEEXEC function of the device.
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   pHlp        The ring-3 device helpers.
  * @param   pSSM        The saved state handle.
@@ -1429 +1461 @@
  * Called from the FNSSMDEVLOADEXEC function of the device.
  *
- * @param   pVirtio     Pointer to the virtio state.
+ * @param   pVirtio     Pointer to the shared virtio state.
  * @param   pHlp        The ring-3 device helpers.
  * @param   pSSM        The saved state handle.
@@ -1503 +1535 @@
  * This should be called from PDMDEVREGR3::pfnReset.
  *
- * @param   pVirtio     Pointer to the virtio state.
- */
-void virtioR3PropagateResetNotification(PVIRTIOSTATE pVirtio)
+ * @param   pDevIns     The device instance.
+ * @param   pVirtio     Pointer to the shared virtio state.
+ */
+void virtioR3PropagateResetNotification(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio)
 {
     /** @todo r=bird: You probably need to do something here.  See
      *        virtioScsiR3Reset. */
-    RT_NOREF(pVirtio);
+    RT_NOREF(pDevIns, pVirtio);
 }
 
@@ -1521 +1554 @@
  * from stalling after suspend.
  */
-void virtioR3PropagateResumeNotification(PVIRTIOSTATE pVirtio)
-{
-    virtioNotifyGuestDriver(pVirtio, (uint16_t)0 /* idxQueue */, true /* fForce */);
+void virtioR3PropagateResumeNotification(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio)
+{
+    virtioNotifyGuestDriver(pDevIns, pVirtio, 0 /* idxQueue */, true /* fForce */);
 }
 
@@ -1530 +1563 @@
  * This should be called from PDMDEVREGR3::pfnDestruct.
  *
- * @param   pVirtio     Pointer to the virtio state.
  * @param   pDevIns     The device instance.
- */
-void virtioR3Term(PVIRTIOSTATE pVirtio, PPDMDEVINS pDevIns)
-{
-    if (pVirtio->pvPrevDevSpecificCfg)
-    {
-        RTMemFree(pVirtio->pvPrevDevSpecificCfg);
-        pVirtio->pvPrevDevSpecificCfg = NULL;
-    }
-    RT_NOREF(pDevIns);
+ * @param   pVirtio     Pointer to the shared virtio state.
+ * @param   pVirtioCC   Pointer to the ring-3 virtio state.
+ */
+void virtioR3Term(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC)
+{
+    if (pVirtioCC->pbPrevDevSpecificCfg)
+    {
+        RTMemFree(pVirtioCC->pbPrevDevSpecificCfg);
+        pVirtioCC->pbPrevDevSpecificCfg = NULL;
+    }
+    RT_NOREF(pDevIns, pVirtio);
 }
 
@@ -1549 +1583 @@
  * This should be called from PDMDEVREGR3::pfnConstruct.
  *
- * @param   pVirtio                 Pointer to the virtio state.  This must be
- *                                  the first member in the shared device
- *                                  instance data!
  * @param   pDevIns                 The device instance.
+ * @param   pVirtio                 Pointer to the shared virtio state.  This
+ *                                  must be the first member in the shared
+ *                                  device instance data!
+ * @param   pVirtioCC               Pointer to the ring-3 virtio state.  This
+ *                                  must be the first member in the ring-3
+ *                                  device instance data!
  * @param   pPciParams              Values to populate industry standard PCI Configuration Space data structure
  * @param   pcszInstance            Device instance name (format-specifier)
@@ -1561 +1598 @@
  *                                  configuration struct.
  */
-int virtioR3Init(PVIRTIOSTATE pVirtio, PPDMDEVINS pDevIns, PVIRTIOPCIPARAMS pPciParams, const char *pcszInstance,
-                 uint64_t fDevSpecificFeatures, void *pvDevSpecificCfg, uint16_t cbDevSpecificCfg)
+int virtioR3Init(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, PVIRTIOPCIPARAMS pPciParams,
+                 const char *pcszInstance, uint64_t fDevSpecificFeatures, void *pvDevSpecificCfg, uint16_t cbDevSpecificCfg)
 {
     /*
@@ -1569 +1606 @@
      */
     AssertLogRelReturn(pVirtio == PDMINS_2_DATA(pDevIns, PVIRTIOSTATE), VERR_STATE_CHANGED);
+    AssertLogRelReturn(pVirtioCC == PDMINS_2_DATA_CC(pDevIns, PVIRTIOSTATECC), VERR_STATE_CHANGED);
 
 
@@ -1587 +1625 @@
     RTStrCopy(pVirtio->szInstance, sizeof(pVirtio->szInstance), pcszInstance);
 
-    pVirtio->pDevInsR3 = pDevIns;
     pVirtio->uDeviceStatus = 0;
-    pVirtio->cbDevSpecificCfg = cbDevSpecificCfg;
-    pVirtio->pvDevSpecificCfg = pvDevSpecificCfg;
-    pVirtio->pvPrevDevSpecificCfg = RTMemDup(pvDevSpecificCfg, cbDevSpecificCfg);
-    AssertLogRelReturn(pVirtio->pvPrevDevSpecificCfg, VERR_NO_MEMORY);
+    pVirtioCC->cbDevSpecificCfg = cbDevSpecificCfg;
+    pVirtioCC->pbDevSpecificCfg = (uint8_t *)pvDevSpecificCfg;
+    pVirtioCC->pbPrevDevSpecificCfg = (uint8_t *)RTMemDup(pvDevSpecificCfg, cbDevSpecificCfg);
+    AssertLogRelReturn(pVirtioCC->pbPrevDevSpecificCfg, VERR_NO_MEMORY);
 
     /* Set PCI config registers (assume 32-bit mode) */
@@ -1649 +1686 @@
     cbRegion += pCfg->uLength;
     SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocCommonCfgCap, 2);
-    pVirtio->pCommonCfgCap = pCfg;
+    pVirtioCC->pCommonCfgCap = pCfg;
 
     /*
@@ -1661 +1698 @@
     pCfg->uCapNext = CFG_ADDR_2_IDX(pCfg) + pCfg->uCapLen;
     pCfg->uBar     = VIRTIO_REGION_PCI_CAP;
-    pCfg->uOffset  = pVirtio->pCommonCfgCap->uOffset + pVirtio->pCommonCfgCap->uLength;
+    pCfg->uOffset  = pVirtioCC->pCommonCfgCap->uOffset + pVirtioCC->pCommonCfgCap->uLength;
     pCfg->uOffset  = RT_ALIGN_32(pCfg->uOffset, 2); /** @todo r=bird: Why is this word aligned rather than dword?  If there is a
                                                      * theoretical chance we won't allways be on a dword boundrary here, the
@@ -1668 +1705 @@
     cbRegion += pCfg->uLength;
     SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocNotifyCap, 1);
-    pVirtio->pNotifyCap = (PVIRTIO_PCI_NOTIFY_CAP_T)pCfg;
-    pVirtio->pNotifyCap->uNotifyOffMultiplier = VIRTIO_NOTIFY_OFFSET_MULTIPLIER;
+    pVirtioCC->pNotifyCap = (PVIRTIO_PCI_NOTIFY_CAP_T)pCfg;
+    pVirtioCC->pNotifyCap->uNotifyOffMultiplier = VIRTIO_NOTIFY_OFFSET_MULTIPLIER;
 
     /* ISR capability (VirtIO 1.0 spec, section 4.1.4.5)
@@ -1683 +1720 @@
     pCfg->uCapNext = CFG_ADDR_2_IDX(pCfg) + pCfg->uCapLen;
     pCfg->uBar     = VIRTIO_REGION_PCI_CAP;
-    pCfg->uOffset  = pVirtio->pNotifyCap->pciCap.uOffset + pVirtio->pNotifyCap->pciCap.uLength; /** @todo r=bird: This probably is _not_ dword aligned, given that the previous structure is 0x32 (50) bytes long. */
+    pCfg->uOffset  = pVirtioCC->pNotifyCap->pciCap.uOffset + pVirtioCC->pNotifyCap->pciCap.uLength; /** @todo r=bird: This probably is _not_ dword aligned, given that the previous structure is 0x32 (50) bytes long. */
     pCfg->uLength  = sizeof(uint8_t);
     cbRegion += pCfg->uLength;
     SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocIsrCap, 4);
-    pVirtio->pIsrCap = pCfg;
+    pVirtioCC->pIsrCap = pCfg;
 
     /*  PCI Cfg capability (VirtIO 1.0 spec, section 4.1.4.7)
@@ -1701 +1738 @@
     pCfg->uCapVndr = VIRTIO_PCI_CAP_ID_VENDOR;
     pCfg->uCapLen  = sizeof(VIRTIO_PCI_CFG_CAP_T);
-    pCfg->uCapNext = (pVirtio->fMsiSupport || pVirtio->pvDevSpecificCfg) ? CFG_ADDR_2_IDX(pCfg) + pCfg->uCapLen : 0;
+    pCfg->uCapNext = (pVirtio->fMsiSupport || pVirtioCC->pbDevSpecificCfg) ? CFG_ADDR_2_IDX(pCfg) + pCfg->uCapLen : 0;
     pCfg->uBar     = 0;
     pCfg->uOffset  = 0;
@@ -1707 +1744 @@
     cbRegion += pCfg->uLength;
     SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocPciCfgCap, 1);
-    pVirtio->pPciCfgCap = (PVIRTIO_PCI_CFG_CAP_T)pCfg;
-
-    if (pVirtio->pvDevSpecificCfg)
+    pVirtioCC->pPciCfgCap = (PVIRTIO_PCI_CFG_CAP_T)pCfg;
+
+    if (pVirtioCC->pbDevSpecificCfg)
     {
         /* Following capability (via VirtIO 1.0, section 4.1.4.6). Client defines the
@@ -1719 +1756 @@
         pCfg->uCapNext = pVirtio->fMsiSupport ? CFG_ADDR_2_IDX(pCfg) + pCfg->uCapLen : 0;
         pCfg->uBar     = VIRTIO_REGION_PCI_CAP;
-        pCfg->uOffset  = pVirtio->pIsrCap->uOffset + pVirtio->pIsrCap->uLength;
+        pCfg->uOffset  = pVirtioCC->pIsrCap->uOffset + pVirtioCC->pIsrCap->uLength;
         pCfg->uOffset  = RT_ALIGN_32(pCfg->uOffset, 4);
         pCfg->uLength  = cbDevSpecificCfg;
         cbRegion += pCfg->uLength;
         SET_PCI_CAP_LOC(pPciDev, pCfg, pVirtio->LocDeviceCap, 4);
-        //pVirtio->pDeviceCap = pCfg;
+        pVirtioCC->pDeviceCap = pCfg;
     }
     else
@@ -1774 +1811 @@
  *
  * @returns VBox status code.
- * @param   pVirtio     Pointer to the virtio state.  This must be the first
+ * @param   pVirtio     Pointer to the shared virtio state.  This must be the first
  *                      member in the shared device instance data!
  * @param   pDevIns     The device instance.

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

@@ -25 +25 @@
 #include <iprt/sg.h>
 
-/** Pointer to the virt i/o state. */
+/** Pointer to the shared VirtIO state. */
 typedef struct VIRTIOSTATE *PVIRTIOSTATE;
+/** Pointer to the ring-3 VirtIO state. */
+typedef struct VIRTIOSTATER3 *PVIRTIOSTATER3;
+/** Pointer to the ring-0 VirtIO state. */
+typedef struct VIRTIOSTATER0 *PVIRTIOSTATER0;
+/** Pointer to the raw-mode VirtIO state. */
+typedef struct VIRTIOSTATERC *PVIRTIOSTATERC;
+/** Pointer to the instance data for the current context. */
+typedef CTX_SUFF(PVIRTIOSTATE) PVIRTIOSTATECC;
+
 
 /**
@@ -101 +110 @@
       * changes.
       *
-      * @param   pVirtio    Pointer to virtio state.
+      * @param   pVirtio    Pointer to the shared virtio state.
+      * @param   pVirtioCC  Pointer to the ring-3 virtio state.
       * @param   fDriverOk  True if guest driver is okay (thus queues, etc... are
       *                     valid)
       */
-     DECLCALLBACKMEMBER(void, pfnStatusChanged)(PVIRTIOSTATE pVirtio, uint32_t fDriverOk);
+     DECLCALLBACKMEMBER(void, pfnStatusChanged)(PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, uint32_t fDriverOk);
 
      /**
@@ -111 +121 @@
       * that the avail queue has buffers, and this callback informs the client.
       *
-      * @param   pVirtio    Pointer to virtio state.
+      * @param   pVirtio    Pointer to the shared virtio state.
+      * @param   pVirtioCC  Pointer to the ring-3 virtio state.
       * @param   idxQueue   Index of the notified queue
       */
-     DECLCALLBACKMEMBER(void, pfnQueueNotified)(PVIRTIOSTATE pVirtio, uint16_t idxQueue);
+     DECLCALLBACKMEMBER(void, pfnQueueNotified)(PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, uint16_t idxQueue);
 
      /**
@@ -254 +265 @@
 
 /**
- * The core (/common) state of the VirtIO PCI device
+ * The core/common state of the VirtIO PCI devices, shared edition.
  */
 typedef struct VIRTIOSTATE
 {
     char                        szInstance[16];                     /**< Instance name, e.g. "VIRTIOSCSI0"         */
-    PPDMDEVINSR3                pDevInsR3;                          /**< Device instance - R3                      */
-
-#if 0
-    RTGCPHYS                    GCPhysPciCapBase;                   /**< Pointer to MMIO mapped capability data    */
-    RTGCPHYS                    GCPhysCommonCfg;                    /**< Pointer to MMIO mapped capability data    */
-    RTGCPHYS                    GCPhysNotifyCap;                    /**< Pointer to MMIO mapped capability data    */
-    RTGCPHYS                    GCPhysIsrCap;                       /**< Pointer to MMIO mapped capability data    */
-    RTGCPHYS                    GCPhysDeviceCap;                    /**< Pointer to MMIO mapped capability data    */
-#endif
 
     RTGCPHYS                    aGCPhysQueueDesc[VIRTQ_MAX_CNT];    /**< (MMIO) PhysAdr per-Q desc structs   GUEST */
@@ -293 +295 @@
 
     VIRTQSTATE                  virtqState[VIRTQ_MAX_CNT];          /**< Local impl-specific queue context         */
-    VIRTIOCALLBACKS             Callbacks;                          /**< Callback vectors to client                */
-
-    R3PTRTYPE(PVIRTIO_PCI_CFG_CAP_T)    pPciCfgCap;                         /**< Pointer to struct in the PCI configuration area. */
-    R3PTRTYPE(PVIRTIO_PCI_NOTIFY_CAP_T) pNotifyCap;                         /**< Pointer to struct in the PCI configuration area. */
-    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pCommonCfgCap;                      /**< Pointer to struct in the PCI configuration area. */
-    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pIsrCap;                            /**< Pointer to struct in the PCI configuration area. */
-    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pDeviceCap;                         /**< Pointer to struct in the PCI configuration area. */
 
     /** @name The locations of the capability structures in PCI config space and the BAR.
@@ -310 +305 @@
     /** @} */
 
-    uint32_t                    cbDevSpecificCfg;                   /**< Size of client's dev-specific config data */
-    void                       *pvDevSpecificCfg;                   /**< Pointer to client's struct                */
-    void                       *pvPrevDevSpecificCfg;               /**< Previous read dev-specific cfg of client  */
     bool                        fGenUpdatePending;                  /**< If set, update cfg gen after driver reads */
     uint8_t                     uPciCfgDataOff;
@@ -324 +316 @@
 
 
+/**
+ * The core/common state of the VirtIO PCI devices, ring-3 edition.
+ */
+typedef struct VIRTIOSTATER3
+{
+    VIRTIOCALLBACKS             Callbacks;                          /**< Callback vectors to client                */
+
+    R3PTRTYPE(PVIRTIO_PCI_CFG_CAP_T)    pPciCfgCap;                 /**< Pointer to struct in the PCI configuration area. */
+    R3PTRTYPE(PVIRTIO_PCI_NOTIFY_CAP_T) pNotifyCap;                 /**< Pointer to struct in the PCI configuration area. */
+    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pCommonCfgCap;              /**< Pointer to struct in the PCI configuration area. */
+    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pIsrCap;                    /**< Pointer to struct in the PCI configuration area. */
+    R3PTRTYPE(PVIRTIO_PCI_CAP_T)        pDeviceCap;                 /**< Pointer to struct in the PCI configuration area. */
+
+    uint32_t                    cbDevSpecificCfg;                   /**< Size of client's dev-specific config data */
+    R3PTRTYPE(uint8_t *)        pbDevSpecificCfg;                   /**< Pointer to client's struct                */
+    R3PTRTYPE(uint8_t *)        pbPrevDevSpecificCfg;               /**< Previous read dev-specific cfg of client  */
+    bool                        fGenUpdatePending;                  /**< If set, update cfg gen after driver reads */
+} VIRTIOSTATER3;
+
+
+/**
+ * The core/common state of the VirtIO PCI devices, ring-0 edition.
+ */
+typedef struct VIRTIOSTATER0
+{
+    uint64_t                    uUnusedAtTheMoment;
+} VIRTIOSTATER0;
+
+
+/**
+ * The core/common state of the VirtIO PCI devices, raw-mode edition.
+ */
+typedef struct VIRTIOSTATERC
+{
+    uint64_t                    uUnusedAtTheMoment;
+} VIRTIOSTATERC;
+
+
+/** @typedef VIRTIOSTATECC
+ * The instance data for the current context. */
+typedef CTX_SUFF(VIRTIOSTATE) VIRTIOSTATECC;
+
+
 /** virtq related flags */
 #define VIRTQ_DESC_F_NEXT                               1        /**< Indicates this descriptor chains to next  */
@@ -346 +381 @@
 int virtioQueueDetach(PVIRTIOSTATE pVirtio, uint16_t idxQueue);
 #endif
-int  virtioR3QueueGet(PVIRTIOSTATE pVirtio, uint16_t idxQueue, PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove);
-int  virtioR3QueuePut(PVIRTIOSTATE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
+int  virtioR3QueueGet(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue,
+                      PPVIRTIO_DESC_CHAIN_T ppDescChain, bool fRemove);
+int  virtioR3QueuePut(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue, PRTSGBUF pSgVirtReturn,
                       PVIRTIO_DESC_CHAIN_T pDescChain, bool fFence);
-
-int virtioQueueSync(PVIRTIOSTATE pVirtio, uint16_t idxQueue);
-bool virtioQueueIsEmpty(PVIRTIOSTATE pVirtio, uint16_t idxQueue);
-
+int  virtioQueueSync(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue);
+bool virtioQueueIsEmpty(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, uint16_t idxQueue);
 void virtioQueueEnable(PVIRTIOSTATE pVirtio, uint16_t idxQueue, bool fEnabled);
+
+#if 0 /** @todo unused */
 void virtioResetAll(PVIRTIOSTATE pVirtio);
+#endif
 
 /**
@@ -409 +446 @@
 int  virtioR3SaveExec(PVIRTIOSTATE pVirtio, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM);
 int  virtioR3LoadExec(PVIRTIOSTATE pVirtio, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM);
-void virtioR3PropagateResetNotification(PVIRTIOSTATE pVirtio);
-void virtioR3PropagateResumeNotification(PVIRTIOSTATE pVirtio);
-void virtioR3Term(PVIRTIOSTATE pVirtio, PPDMDEVINS pDevIns);
-int  virtioR3Init(PVIRTIOSTATE pVirtio, PPDMDEVINS pDevIns, PVIRTIOPCIPARAMS pPciParams, const char *pcszInstance,
-                  uint64_t fDevSpecificFeatures, void *pvDevSpecificCfg, uint16_t cbDevSpecificCfg);
+void virtioR3PropagateResetNotification(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio);
+void virtioR3PropagateResumeNotification(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio);
+void virtioR3Term(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC);
+int  virtioR3Init(PPDMDEVINS pDevIns, PVIRTIOSTATE pVirtio, PVIRTIOSTATECC pVirtioCC, PVIRTIOPCIPARAMS pPciParams,
+                  const char *pcszInstance, uint64_t fDevSpecificFeatures, void *pvDevSpecificCfg, uint16_t cbDevSpecificCfg);
 
 void virtioLogMappedIoValue(const char *pszFunc, const char *pszMember, uint32_t uMemberSize,