Changeset 64320 in vbox for trunk/src/VBox

Timestamp:

Oct 19, 2016 2:55:59 PM (8 years ago)

Author:

vboxsync

Message:

Devices/Storage/DrvHost*: Start working on implementing PDMIMEDIAEX and SCSI command passthrough (wip)

Location:

trunk/src/VBox/Devices/Storage

Files:

• DrvHostBase.cpp (modified) (11 diffs)
• DrvHostBase.h (modified) (4 diffs)
• DrvHostDVD.cpp (modified) (9 diffs)

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

@@ -68 +68 @@
         }
         else
-            Log(("%s-%d: drvHostBaseReadOs: drvHostBaseReadOs(%#llx, %p, %#x) -> %Rrc ('%s')\n",
+            Log(("%s-%d: drvHostBaseRead: drvHostBaseReadOs(%#llx, %p, %#x) -> %Rrc ('%s')\n",
                  pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance,
                  off, pvBuf, cbRead, rc, pThis->pszDevice));
@@ -217 +217 @@
     RTCritSectLeave(&pThis->CritSect);
     LogFlow(("%s-%d: %s: returns %Rrc CHS={%d,%d,%d}\n",
-             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, rc, pThis->PCHSGeometry.cCylinders, pThis->PCHSGeometry.cHeads, pThis->PCHSGeometry.cSectors));
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, rc,
+             pThis->PCHSGeometry.cCylinders, pThis->PCHSGeometry.cHeads, pThis->PCHSGeometry.cSectors));
     return rc;
 }
@@ -227 +228 @@
     PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: %s: cCylinders=%d cHeads=%d cSectors=%d\n",
-             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__,
+             pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
     RTCritSectEnter(&pThis->CritSect);
 
@@ -269 +271 @@
     RTCritSectLeave(&pThis->CritSect);
     LogFlow(("%s-%d: %s: returns %Rrc CHS={%d,%d,%d}\n",
-             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, rc, pThis->LCHSGeometry.cCylinders, pThis->LCHSGeometry.cHeads, pThis->LCHSGeometry.cSectors));
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, rc,
+             pThis->LCHSGeometry.cCylinders, pThis->LCHSGeometry.cHeads, pThis->LCHSGeometry.cSectors));
     return rc;
 }
@@ -279 +282 @@
     PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: %s: cCylinders=%d cHeads=%d cSectors=%d\n",
-             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, __FUNCTION__,
+             pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
     RTCritSectEnter(&pThis->CritSect);
 
@@ -303 +307 @@
     PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     return pThis->fBiosVisible;
+}
+
+
+
+/* -=-=-=-=- IMediaEx -=-=-=-=- */
+
+DECLHIDDEN(int) drvHostBaseBufferRetain(PDRVHOSTBASE pThis, PDRVHOSTBASEREQ pReq, size_t cbBuf, bool fWrite, void **ppvBuf)
+{
+    int rc = VINF_SUCCESS;
+
+    if (pThis->cbBuf < cbBuf)
+    {
+        RTMemFree(pThis->pvBuf);
+        pThis->cbBuf = 0;
+        pThis->pvBuf = RTMemAlloc(cbBuf);
+        if (pThis->pvBuf)
+            pThis->cbBuf = cbBuf;
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_SUCCESS(rc) && fWrite)
+    {
+        RTSGSEG Seg;
+        RTSGBUF SgBuf;
+
+        Seg.pvSeg = pThis->pvBuf;
+        Seg.cbSeg = cbBuf;
+        RTSgBufInit(&SgBuf, &Seg, 1);
+        rc = pThis->pDrvMediaExPort->pfnIoReqCopyToBuf(pThis->pDrvMediaExPort, (PDMMEDIAEXIOREQ)pReq,
+                                                       &pReq->abAlloc[0], 0, &SgBuf, cbBuf);
+    }
+
+    if (RT_SUCCESS(rc))
+        *ppvBuf = pThis->pvBuf;
+
+    return rc;
+}
+
+DECLHIDDEN(int) drvHostBaseBufferRelease(PDRVHOSTBASE pThis, PDRVHOSTBASEREQ pReq, size_t cbBuf, bool fWrite, void *pvBuf)
+{
+    int rc = VINF_SUCCESS;
+
+    if (!fWrite)
+    {
+        RTSGSEG Seg;
+        RTSGBUF SgBuf;
+
+        Seg.pvSeg = pvBuf;
+        Seg.cbSeg = cbBuf;
+        RTSgBufInit(&SgBuf, &Seg, 1);
+        rc = pThis->pDrvMediaExPort->pfnIoReqCopyFromBuf(pThis->pDrvMediaExPort, (PDMMEDIAEXIOREQ)pReq,
+                                                         &pReq->abAlloc[0], 0, &SgBuf, cbBuf);
+    }
+
+    return rc;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnQueryFeatures} */
+static DECLCALLBACK(int) drvHostBaseQueryFeatures(PPDMIMEDIAEX pInterface, uint32_t *pfFeatures)
+{
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+
+    *pfFeatures = pThis->IMediaEx.pfnIoReqSendScsiCmd ? PDMIMEDIAEX_FEATURE_F_RAWSCSICMD : 0;
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqAllocSizeSet} */
+static DECLCALLBACK(int) drvHostBaseIoReqAllocSizeSet(PPDMIMEDIAEX pInterface, size_t cbIoReqAlloc)
+{
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+
+    pThis->cbIoReqAlloc = RT_OFFSETOF(DRVHOSTBASEREQ, abAlloc[cbIoReqAlloc]);
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqAlloc} */
+static DECLCALLBACK(int) drvHostBaseIoReqAlloc(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc,
+                                               PDMMEDIAEXIOREQID uIoReqId, uint32_t fFlags)
+{
+    RT_NOREF2(uIoReqId, fFlags);
+
+    int rc = VINF_SUCCESS;
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+    PDRVHOSTBASEREQ pReq = (PDRVHOSTBASEREQ)RTMemAllocZ(pThis->cbIoReqAlloc);
+    if (RT_LIKELY(pReq))
+    {
+        *phIoReq = (PDMMEDIAEXIOREQ)pReq;
+        *ppvIoReqAlloc = &pReq->abAlloc[0];
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqFree} */
+static DECLCALLBACK(int) drvHostBaseIoReqFree(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
+{
+    RT_NOREF1(pInterface);
+    PDRVHOSTBASEREQ pReq = (PDRVHOSTBASEREQ)hIoReq;
+
+    RTMemFree(pReq);
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQueryResidual} */
+static DECLCALLBACK(int) drvHostBaseIoReqQueryResidual(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, size_t *pcbResidual)
+{
+    RT_NOREF2(pInterface, hIoReq);
+
+    *pcbResidual = 0; /** @todo: Implement. */
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancelAll} */
+static DECLCALLBACK(int) drvHostBaseIoReqCancelAll(PPDMIMEDIAEX pInterface)
+{
+    RT_NOREF1(pInterface);
+    return VINF_SUCCESS;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancel} */
+static DECLCALLBACK(int) drvHostBaseIoReqCancel(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQID uIoReqId)
+{
+    RT_NOREF2(pInterface, uIoReqId);
+    return VERR_PDM_MEDIAEX_IOREQID_NOT_FOUND;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqRead} */
+static DECLCALLBACK(int) drvHostBaseIoReqRead(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbRead)
+{
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+    PDRVHOSTBASEREQ pReq = (PDRVHOSTBASEREQ)hIoReq;
+    LogFlow(("%s-%d: drvHostBaseIoReqRead: off=%#llx cbRead=%#x (%s)\n",
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, cbRead, pThis->pszDevice));
+    RTCritSectEnter(&pThis->CritSect);
+
+    /*
+     * Check the state.
+     */
+    int rc;
+    if (pThis->fMediaPresent)
+    {
+        void *pvBuf;
+        rc = drvHostBaseBufferRetain(pThis, pReq, cbRead, false, &pvBuf);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Seek and read.
+             */
+            rc = drvHostBaseReadOs(pThis, off, pvBuf, cbRead);
+            if (RT_SUCCESS(rc))
+            {
+                Log2(("%s-%d: drvHostBaseReadOs: off=%#llx cbRead=%#x\n"
+                      "%16.*Rhxd\n",
+                      pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, cbRead, cbRead, pvBuf));
+            }
+            else
+                Log(("%s-%d: drvHostBaseIoReqRead: drvHostBaseReadOs(%#llx, %p, %#x) -> %Rrc ('%s')\n",
+                     pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance,
+                     off, pvBuf, cbRead, rc, pThis->pszDevice));
+
+            rc = drvHostBaseBufferRelease(pThis, pReq, cbRead, false, pvBuf);
+        }
+        else
+            Log(("%s-%d: drvHostBaseIoReqRead: drvHostBaseBufferRetain(%#llx, %p, %#x) -> %Rrc ('%s')\n",
+                 pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance,
+                 off, pvBuf, cbRead, rc, pThis->pszDevice));
+    }
+    else
+        rc = VERR_MEDIA_NOT_PRESENT;
+
+    RTCritSectLeave(&pThis->CritSect);
+    LogFlow(("%s-%d: drvHostBaseIoReqRead: returns %Rrc\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, rc));
+    return rc;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqWrite} */
+static DECLCALLBACK(int) drvHostBaseIoReqWrite(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbWrite)
+{
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+    PDRVHOSTBASEREQ pReq = (PDRVHOSTBASEREQ)hIoReq;
+    LogFlow(("%s-%d: drvHostBaseIoReqWrite: off=%#llx cbWrite=%#x (%s)\n",
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, cbWrite, pThis->pszDevice));
+    RTCritSectEnter(&pThis->CritSect);
+
+    /*
+     * Check the state.
+     */
+    int rc;
+    if (!pThis->fReadOnly)
+    {
+        if (pThis->fMediaPresent)
+        {
+            void *pvBuf;
+            rc = drvHostBaseBufferRetain(pThis, pReq, cbWrite, true, &pvBuf);
+            if (RT_SUCCESS(rc))
+            {
+                Log2(("%s-%d: drvHostBaseIoReqWrite: off=%#llx cbWrite=%#x\n"
+                      "%16.*Rhxd\n",
+                      pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, cbWrite, cbWrite, pvBuf));
+                /*
+                 * Seek and write.
+                 */
+                rc = drvHostBaseWriteOs(pThis, off, pvBuf, cbWrite);
+                if (RT_FAILURE(rc))
+                    Log(("%s-%d: drvHostBaseIoReqWrite: drvHostBaseWriteOs(%#llx, %p, %#x) -> %Rrc ('%s')\n",
+                         pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance,
+                         off, pvBuf, cbWrite, rc, pThis->pszDevice));
+
+                rc = drvHostBaseBufferRelease(pThis, pReq, cbWrite, true, pvBuf);
+            }
+        }
+        else
+            rc = VERR_MEDIA_NOT_PRESENT;
+    }
+    else
+        rc = VERR_WRITE_PROTECT;
+
+    RTCritSectLeave(&pThis->CritSect);
+    LogFlow(("%s-%d: drvHostBaseIoReqWrite: returns %Rrc\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, rc));
+    return rc;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqFlush} */
+static DECLCALLBACK(int) drvHostBaseIoReqFlush(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
+{
+    RT_NOREF1(hIoReq);
+
+    int rc;
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+    LogFlow(("%s-%d: drvHostBaseIoReqFlush: (%s)\n",
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDevice));
+    RTCritSectEnter(&pThis->CritSect);
+
+    if (pThis->fMediaPresent)
+        rc = drvHostBaseFlushOs(pThis);
+    else
+        rc = VERR_MEDIA_NOT_PRESENT;
+
+    RTCritSectLeave(&pThis->CritSect);
+    LogFlow(("%s-%d: drvHostBaseFlush: returns %Rrc\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, rc));
+    return rc;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqDiscard} */
+static DECLCALLBACK(int) drvHostBaseIoReqDiscard(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, unsigned cRangesMax)
+{
+    RT_NOREF3(pInterface, hIoReq, cRangesMax);
+    return VERR_NOT_SUPPORTED;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetActiveCount} */
+static DECLCALLBACK(uint32_t) drvHostBaseIoReqGetActiveCount(PPDMIMEDIAEX pInterface)
+{
+    RT_NOREF1(pInterface);
+    return 0;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetSuspendedCount} */
+static DECLCALLBACK(uint32_t) drvHostBaseIoReqGetSuspendedCount(PPDMIMEDIAEX pInterface)
+{
+    RT_NOREF1(pInterface);
+    return 0;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedStart} */
+static DECLCALLBACK(int) drvHostBaseIoReqQuerySuspendedStart(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc)
+{
+    RT_NOREF3(pInterface, phIoReq, ppvIoReqAlloc);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedNext} */
+static DECLCALLBACK(int) drvHostBaseIoReqQuerySuspendedNext(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
+                                                            PPDMMEDIAEXIOREQ phIoReqNext, void **ppvIoReqAllocNext)
+{
+    RT_NOREF4(pInterface, hIoReq, phIoReqNext, ppvIoReqAllocNext);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedSave} */
+static DECLCALLBACK(int) drvHostBaseIoReqSuspendedSave(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
+{
+    RT_NOREF3(pInterface, pSSM, hIoReq);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedLoad} */
+static DECLCALLBACK(int) drvHostBaseIoReqSuspendedLoad(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
+{
+    RT_NOREF3(pInterface, pSSM, hIoReq);
+    return VERR_NOT_IMPLEMENTED;
 }
 
@@ -442 +740 @@
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, &pThis->IMedia);
     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUNT, &pThis->IMount);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEX, pThis->pDrvMediaExPort ? &pThis->IMediaEx : NULL);
     return NULL;
 }
@@ -683 +982 @@
         RTStrFree(pThis->pszDeviceOpen);
         pThis->pszDeviceOpen = NULL;
+    }
+
+    if (pThis->pvBuf)
+    {
+        RTMemFree(pThis->pvBuf);
+        pThis->pvBuf = NULL;
+        pThis->cbBuf = 0;
     }
 
@@ -740 +1046 @@
     pThis->IMedia.pfnBiosIsVisible          = drvHostBaseIsVisible;
 
+    /* IMediaEx */
+    pThis->IMediaEx.pfnQueryFeatures            = drvHostBaseQueryFeatures;
+    pThis->IMediaEx.pfnIoReqAllocSizeSet        = drvHostBaseIoReqAllocSizeSet;
+    pThis->IMediaEx.pfnIoReqAlloc               = drvHostBaseIoReqAlloc;
+    pThis->IMediaEx.pfnIoReqFree                = drvHostBaseIoReqFree;
+    pThis->IMediaEx.pfnIoReqQueryResidual       = drvHostBaseIoReqQueryResidual;
+    pThis->IMediaEx.pfnIoReqCancelAll           = drvHostBaseIoReqCancelAll;
+    pThis->IMediaEx.pfnIoReqCancel              = drvHostBaseIoReqCancel;
+    pThis->IMediaEx.pfnIoReqRead                = drvHostBaseIoReqRead;
+    pThis->IMediaEx.pfnIoReqWrite               = drvHostBaseIoReqWrite;
+    pThis->IMediaEx.pfnIoReqFlush               = drvHostBaseIoReqFlush;
+    pThis->IMediaEx.pfnIoReqDiscard             = drvHostBaseIoReqDiscard;
+    pThis->IMediaEx.pfnIoReqGetActiveCount      = drvHostBaseIoReqGetActiveCount;
+    pThis->IMediaEx.pfnIoReqGetSuspendedCount   = drvHostBaseIoReqGetSuspendedCount;
+    pThis->IMediaEx.pfnIoReqQuerySuspendedStart = drvHostBaseIoReqQuerySuspendedStart;
+    pThis->IMediaEx.pfnIoReqQuerySuspendedNext  = drvHostBaseIoReqQuerySuspendedNext;
+    pThis->IMediaEx.pfnIoReqSuspendedSave       = drvHostBaseIoReqSuspendedSave;
+    pThis->IMediaEx.pfnIoReqSuspendedLoad       = drvHostBaseIoReqSuspendedLoad;
+
     /* IMount. */
     pThis->IMount.pfnUnmount                = drvHostBaseUnmount;
@@ -756 +1081 @@
 
     /*
-     * Get the IBlockPort & IMountNotify interfaces of the above driver/device.
+     * Get the IMediaPort & IMountNotify interfaces of the above driver/device.
      */
     pThis->pDrvMediaPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAPORT);
@@ -764 +1089 @@
         return VERR_PDM_MISSING_INTERFACE_ABOVE;
     }
+    pThis->pDrvMediaExPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAEXPORT);
     pThis->pDrvMountNotify = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMOUNTNOTIFY);
 

trunk/src/VBox/Devices/Storage/DrvHostBase.h

@@ -65 +65 @@
     RTUUID                  Uuid;
 
-    /** Pointer to the block port interface above us. */
+    /** Pointer to the media port interface above us. */
     PPDMIMEDIAPORT          pDrvMediaPort;
+    /** Pointer to the extended media port interface above us. */
+    PPDMIMEDIAEXPORT        pDrvMediaExPort;
     /** Pointer to the mount notify interface above us. */
     PPDMIMOUNTNOTIFY        pDrvMountNotify;
     /** Our media interface. */
     PDMIMEDIA               IMedia;
+    /** Our extended media interface. */
+    PDMIMEDIAEX             IMediaEx;
     /** Our mountable interface. */
     PDMIMOUNT               IMount;
@@ -96 +100 @@
     PDMMEDIAGEOMETRY        LCHSGeometry;
 
+    /** Pointer to the current buffer holding data. */
+    void                    *pvBuf;
+    /** Size of the buffer. */
+    size_t                  cbBuf;
+    /** Size of the I/O request to allocate. */
+    size_t                  cbIoReqAlloc;
+
     /**
      * Performs the locking / unlocking of the device.
@@ -116 +127 @@
 } DRVHOSTBASE;
 
+
+/**
+ * Request structure fo a request.
+ */
+typedef struct DRVHOSTBASEREQ
+{
+    /** Start of the request data for the device above us. */
+    uint8_t                  abAlloc[1];
+} DRVHOSTBASEREQ;
+/** Pointer to a request structure. */
+typedef DRVHOSTBASEREQ *PDRVHOSTBASEREQ;
 
 DECLHIDDEN(int) DRVHostBaseInit(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, const char *pszCfgValid, PDMMEDIATYPE enmType);
@@ -138 +160 @@
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis);
 
+DECLHIDDEN(int) drvHostBaseBufferRetain(PDRVHOSTBASE pThis, PDRVHOSTBASEREQ pReq, size_t cbBuf, bool fWrite, void **ppvBuf);
+DECLHIDDEN(int) drvHostBaseBufferRelease(PDRVHOSTBASE pThis, PDRVHOSTBASEREQ pReq, size_t cbBuf, bool fWrite, void *pvBuf);
+
 RT_C_DECLS_END
 

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

@@ -21 +21 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_HOST_DVD
-#if defined(RT_OS_DARWIN) || defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
-# define USE_MEDIA_POLLING
-#endif
-
-#if defined(RT_OS_SOLARIS) && defined(VBOX_WITH_SUID_WRAPPER)
-# include <auth_attr.h>
-#endif
-
 #include <iprt/asm.h>
 #include <VBox/vmm/pdmdrv.h>
@@ -42 +34 @@
 #include "VBoxDD.h"
 #include "DrvHostBase.h"
-
+#include "ATAPIPassthrough.h"
+
+/**
+ * Host DVD driver instance data.
+ */
+typedef struct DRVHOSTDVD
+{
+    /** Base drivr data. */
+    DRVHOSTBASE             Core;
+    /** The current tracklist of the loaded medium if passthrough is used. */
+    PTRACKLIST              pTrackList;
+} DRVHOSTDVD;
+/** Pointer to the host DVD driver instance data. */
+typedef DRVHOSTDVD *PDRVHOSTDVD;
 
 /*********************************************************************************************************************************
@@ -48 +53 @@
 *********************************************************************************************************************************/
 
+
+static PDMMEDIATXDIR drvHostDvdGetTxDirFromCmd(uint8_t bCdb)
+{
+    PDMMEDIATXDIR enmTxDir = PDMMEDIATXDIR_NONE;
+
+    switch (bCdb)
+    {
+        case SCSI_BLANK:
+        case SCSI_CLOSE_TRACK_SESSION:
+        case SCSI_LOAD_UNLOAD_MEDIUM:
+        case SCSI_PAUSE_RESUME:
+        case SCSI_PLAY_AUDIO_10:
+        case SCSI_PLAY_AUDIO_12:
+        case SCSI_PLAY_AUDIO_MSF:
+        case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
+        case SCSI_RESERVE_TRACK:
+        case SCSI_SCAN:
+        case SCSI_SEEK_10:
+        case SCSI_REPAIR_TRACK:
+        case SCSI_SET_CD_SPEED:
+        case SCSI_SET_READ_AHEAD:
+        case SCSI_START_STOP_UNIT:
+        case SCSI_STOP_PLAY_SCAN:
+        case SCSI_SYNCHRONIZE_CACHE:
+        case SCSI_TEST_UNIT_READY:
+        case SCSI_VERIFY_10:
+            enmTxDir = PDMMEDIATXDIR_NONE;
+            break;
+        case SCSI_SET_STREAMING:
+        case SCSI_ERASE_10:
+        case SCSI_FORMAT_UNIT:
+        case SCSI_MODE_SELECT_10:
+        case SCSI_SEND_CUE_SHEET:
+        case SCSI_SEND_DVD_STRUCTURE:
+        case SCSI_SEND_EVENT:
+        case SCSI_SEND_KEY:
+        case SCSI_SEND_OPC_INFORMATION:
+        case SCSI_WRITE_10:
+        case SCSI_WRITE_AND_VERIFY_10:
+        case SCSI_WRITE_12:
+            enmTxDir = PDMMEDIATXDIR_TO_DEVICE;
+            break;
+        case SCSI_GET_CONFIGURATION:
+        case SCSI_GET_EVENT_STATUS_NOTIFICATION:
+        case SCSI_GET_PERFORMANCE:
+        case SCSI_INQUIRY:
+        case SCSI_MECHANISM_STATUS:
+        case SCSI_MODE_SENSE_10:
+        case SCSI_READ_10:
+        case SCSI_READ_12:
+        case SCSI_READ_BUFFER:
+        case SCSI_READ_BUFFER_CAPACITY:
+        case SCSI_READ_CAPACITY:
+        case SCSI_READ_CD:
+        case SCSI_READ_CD_MSF:
+        case SCSI_READ_DISC_INFORMATION:
+        case SCSI_READ_DVD_STRUCTURE:
+        case SCSI_READ_FORMAT_CAPACITIES:
+        case SCSI_READ_SUBCHANNEL:
+        case SCSI_READ_TOC_PMA_ATIP:
+        case SCSI_READ_TRACK_INFORMATION:
+        case SCSI_REPORT_KEY:
+        case SCSI_REQUEST_SENSE:
+        case SCSI_REPORT_LUNS: /* Not part of MMC-3, but used by Windows. */
+            enmTxDir = PDMMEDIATXDIR_FROM_DEVICE;
+            break;
+
+        case SCSI_WRITE_BUFFER:
+#if 0
+            switch (pbPacket[1] & 0x1f)
+            {
+                case 0x04: /* download microcode */
+                case 0x05: /* download microcode and save */
+                case 0x06: /* download microcode with offsets */
+                case 0x07: /* download microcode with offsets and save */
+                case 0x0e: /* download microcode with offsets and defer activation */
+                case 0x0f: /* activate deferred microcode */
+                    LogRel(("PIIX3 ATA: LUN#%d: CD-ROM passthrough command attempted to update firmware, blocked\n", s->iLUN));
+                    atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
+                    break;
+                default:
+                    enmTxDir = PDMMEDIATXDIR_TO_DEVICE;
+                    break;
+            }
+#endif
+            break;
+        case SCSI_REZERO_UNIT:
+            /* Obsolete command used by cdrecord. What else would one expect?
+             * This command is not sent to the drive, it is handled internally,
+             * as the Linux kernel doesn't like it (message "scsi: unknown
+             * opcode 0x01" in syslog) and replies with a sense code of 0,
+             * which sends cdrecord to an endless loop. */
+            //atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
+            break;
+        default:
+            LogRel(("HostDVD: passthrough unimplemented for command %#x\n", bCdb));
+            //atapiR3CmdErrorSimple(s, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
+            break;
+    }
+
+    return enmTxDir;
+}
 
 /**
@@ -74 +181 @@
     LogFlow(("%s: cmd[0]=%#04x txdir=%d pcbBuf=%d timeout=%d\n", __FUNCTION__, pbCmd[0], enmTxDir, *pcbBuf, cTimeoutMillies));
 
+    RTCritSectEnter(&pThis->CritSect);
     /*
      * Pass the request on to the internal scsi command interface.
@@ -92 +200 @@
             Log2(("  event %#02x %#02x %#02x %#02x\n", pbBuf[4], pbBuf[5], pbBuf[6], pbBuf[7]));
     }
+    RTCritSectLeave(&pThis->CritSect);
 
     LogFlow(("%s: rc=%Rrc\n", __FUNCTION__, rc));
@@ -98 +207 @@
 
 
+/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd} */
+static DECLCALLBACK(int) drvHostDvdIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
+                                                    const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
+                                                    size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
+                                                    uint32_t cTimeoutMillies)
+{
+    RT_NOREF2(uLun, cTimeoutMillies);
+
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMediaEx);
+    PDRVHOSTBASEREQ pReq = (PDRVHOSTBASEREQ)hIoReq;
+    int rc = VINF_SUCCESS;
+    void *pvBuf = NULL;
+
+    LogFlow(("%s: pbCdb[0]=%#04x enmTxDir=%d cbBuf=%zu timeout=%u\n", __FUNCTION__, pbCdb[0], enmTxDir, cbBuf, cTimeoutMillies));
+
+    RTCritSectEnter(&pThis->CritSect);
+    if (cbBuf)
+    {
+        bool fWrite = (enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN || enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE);
+        rc = drvHostBaseBufferRetain(pThis, pReq, cbBuf, fWrite, &pvBuf);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        uint32_t cbBufTmp = (uint32_t)cbBuf;
+        PDMMEDIATXDIR enmMediaTxDir = PDMMEDIATXDIR_NONE;
+        /*
+         * Pass the request on to the internal scsi command interface.
+         * The command seems to be 12 bytes long, the docs a bit copy&pasty on the command length point...
+         */
+        if (enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN || enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE)
+            memset(pvBuf, '\0', cbBuf); /* we got read size, but zero it anyway. */
+
+        if (cbBuf)
+        {
+            switch (enmTxDir)
+            {
+                case PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE:
+                    enmMediaTxDir = PDMMEDIATXDIR_FROM_DEVICE;
+                    break;
+                case PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE:
+                    enmMediaTxDir = PDMMEDIATXDIR_TO_DEVICE;
+                    break;
+                case PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN:
+                    enmMediaTxDir = drvHostDvdGetTxDirFromCmd(pbCdb[0]);
+                    break;
+                case PDMMEDIAEXIOREQSCSITXDIR_NONE:
+                default:
+                    enmMediaTxDir = PDMMEDIATXDIR_NONE;
+                    break;
+            }
+        }
+
+        rc = drvHostBaseScsiCmdOs(pThis, pbCdb, cbCdb, enmMediaTxDir, pvBuf, &cbBufTmp, pabSense, cbSense, cTimeoutMillies);
+        if (rc == VERR_UNRESOLVED_ERROR)
+        {
+            /* sense information set */
+            rc = VERR_DEV_IO_ERROR;
+            *pu8ScsiSts = SCSI_STATUS_CHECK_CONDITION;
+        }
+
+        if (pbCdb[0] == SCSI_GET_EVENT_STATUS_NOTIFICATION)
+        {
+            uint8_t *pbBuf = (uint8_t*)pvBuf;
+            Log2(("Event Status Notification class=%#02x supported classes=%#02x\n", pbBuf[2], pbBuf[3]));
+            if (RT_BE2H_U16(*(uint16_t*)pbBuf) >= 6)
+                Log2(("  event %#02x %#02x %#02x %#02x\n", pbBuf[4], pbBuf[5], pbBuf[6], pbBuf[7]));
+        }
+
+        if (cbBuf)
+        {
+            bool fWrite = (enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN || enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE);
+            rc = drvHostBaseBufferRelease(pThis, pReq, cbBuf, fWrite, pvBuf);
+        }
+    }
+    RTCritSectLeave(&pThis->CritSect);
+
+    LogFlow(("%s: rc=%Rrc\n", __FUNCTION__, rc));
+    return rc;
+}
+
+
 /* -=-=-=-=- driver interface -=-=-=-=- */
 
+
+/** @interface_method_impl{PDMDRVREG,pfnDestruct} */
+static DECLCALLBACK(void) drvHostDvdDestruct(PPDMDRVINS pDrvIns)
+{
+    PDRVHOSTDVD pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDVD);
+
+    if (pThis->pTrackList)
+    {
+        ATAPIPassthroughTrackListDestroy(pThis->pTrackList);
+        pThis->pTrackList = NULL;
+    }
+
+    DRVHostBaseDestruct(pDrvIns);
+}
 
 /**
@@ -109 +314 @@
 {
     RT_NOREF(fFlags);
-    PDRVHOSTBASE pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTBASE);
+    PDRVHOSTDVD pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDVD);
     LogFlow(("drvHostDvdConstruct: iInstance=%d\n", pDrvIns->iInstance));
 
@@ -116 +321 @@
     if (RT_SUCCESS(rc) && fPassthrough)
     {
-        pThis->IMedia.pfnSendCmd = drvHostDvdSendCmd;
+        pThis->Core.IMedia.pfnSendCmd            = drvHostDvdSendCmd;
+        pThis->Core.IMediaEx.pfnIoReqSendScsiCmd = drvHostDvdIoReqSendScsiCmd;
         /* Passthrough requires opening the device in R/W mode. */
-        pThis->fReadOnlyConfig = false;
-    }
-
-    pThis->pfnDoLock = drvHostDvdDoLock;
+        pThis->Core.fReadOnlyConfig = false;
+    }
+
+    pThis->Core.pfnDoLock = drvHostDvdDoLock;
 
     /*
@@ -155 +361 @@
     ~0U,
     /* cbInstance */
-    sizeof(DRVHOSTBASE),
+    sizeof(DRVHOSTDVD),
     /* pfnConstruct */
     drvHostDvdConstruct,
     /* pfnDestruct */
-    DRVHostBaseDestruct,
+    drvHostDvdDestruct,
     /* pfnRelocate */
     NULL,