Changeset 64316 in vbox for trunk/src

Timestamp:

Oct 19, 2016 11:59:42 AM (8 years ago)

Author:

vboxsync

Message:

Devices/Storage/DrvHost*: Move host dependent members of DRVHOSTBASE into a private struct for each host to keep including host dependent headers in one file for each host

Location:

trunk/src/VBox/Devices/Storage

Files:

• DrvHostBase-darwin.cpp (modified) (10 diffs)
• DrvHostBase-freebsd.cpp (modified) (7 diffs)
• DrvHostBase-linux.cpp (modified) (17 diffs)
• DrvHostBase-solaris.cpp (modified) (12 diffs)
• DrvHostBase-win.cpp (modified) (13 diffs)
• DrvHostBase.cpp (modified) (44 diffs)
• DrvHostBase.h (modified) (5 diffs)
• DrvHostDVD.cpp (modified) (7 diffs)
• DrvHostFloppy.cpp (modified) (5 diffs)

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

@@ -27 +27 @@
 #include <VBox/scsi.h>
 
+/**
+ * Host backend specific data.
+ */
+typedef struct DRVHOSTBASEOS
+{
+    /** The master port. */
+    mach_port_t             MasterPort;
+    /** The MMC-2 Device Interface. (This is only used to get the scsi task interface.) */
+    MMCDeviceInterface      **ppMMCDI;
+    /** The SCSI Task Device Interface. */
+    SCSITaskDeviceInterface **ppScsiTaskDI;
+    /** The block size. Set when querying the media size. */
+    uint32_t                cbBlock;
+    /** The disk arbitration session reference. NULL if we didn't have to claim & unmount the device. */
+    DASessionRef            pDASession;
+    /** The disk arbitration disk reference. NULL if we didn't have to claim & unmount the device. */
+    DADiskRef               pDADisk;
+    /** The number of errors that could go into the release log. (flood gate) */
+    uint32_t                cLogRelErrors;
+} DRVHOSTBASEOS;
+/** Pointer to the host backend specific data. */
+typedef DRVHOSTBASEOS *PDRVHOSBASEOS;
+AssertCompile(sizeof(DRVHOSTBASEOS) <= 64);
+
+#define DRVHOSTBASE_OS_INT_DECLARED
 #include "DrvHostBase.h"
+
+/** The runloop input source name for the disk arbitration events. */
+# define MY_RUN_LOOP_MODE    CFSTR("drvHostBaseDA") /** @todo r=bird: Check if this will cause trouble in the same way that the one in the USB code did. */
+
+/**
+ * Gets the BSD Name (/dev/disc[0-9]+) for the service.
+ *
+ * This is done by recursing down the I/O registry until we hit upon an entry
+ * with a BSD Name. Usually we find it two levels down. (Further down under
+ * the IOCDPartitionScheme, the volume (slices) BSD Name is found. We don't
+ * seem to have to go this far fortunately.)
+ *
+ * @return  VINF_SUCCESS if found, VERR_FILE_NOT_FOUND otherwise.
+ * @param   Entry       The current I/O registry entry reference.
+ * @param   pszName     Where to store the name. 128 bytes.
+ * @param   cRecursions Number of recursions. This is used as an precaution
+ *                      just to limit the depth and avoid blowing the stack
+ *                      should we hit a bug or something.
+ */
+static int drvHostBaseGetBSDName(io_registry_entry_t Entry, char *pszName, unsigned cRecursions)
+{
+    int rc = VERR_FILE_NOT_FOUND;
+    io_iterator_t Children = 0;
+    kern_return_t krc = IORegistryEntryGetChildIterator(Entry, kIOServicePlane, &Children);
+    if (krc == KERN_SUCCESS)
+    {
+        io_object_t Child;
+        while (     rc == VERR_FILE_NOT_FOUND
+               &&   (Child = IOIteratorNext(Children)) != 0)
+        {
+            CFStringRef BSDNameStrRef = (CFStringRef)IORegistryEntryCreateCFProperty(Child, CFSTR(kIOBSDNameKey), kCFAllocatorDefault, 0);
+            if (BSDNameStrRef)
+            {
+                if (CFStringGetCString(BSDNameStrRef, pszName, 128, kCFStringEncodingUTF8))
+                    rc = VINF_SUCCESS;
+                else
+                    AssertFailed();
+                CFRelease(BSDNameStrRef);
+            }
+            if (rc == VERR_FILE_NOT_FOUND && cRecursions < 10)
+                rc = drvHostBaseGetBSDName(Child, pszName, cRecursions + 1);
+            IOObjectRelease(Child);
+        }
+        IOObjectRelease(Children);
+    }
+    return rc;
+}
+
+
+/**
+ * Callback notifying us that the async DADiskClaim()/DADiskUnmount call has completed.
+ *
+ * @param   DiskRef         The disk that was attempted claimed / unmounted.
+ * @param   DissenterRef    NULL on success, contains details on failure.
+ * @param   pvContext       Pointer to the return code variable.
+ */
+static void drvHostBaseDADoneCallback(DADiskRef DiskRef, DADissenterRef DissenterRef, void *pvContext)
+{
+    RT_NOREF(DiskRef);
+    int *prc = (int *)pvContext;
+    if (!DissenterRef)
+        *prc = 0;
+    else
+        *prc = DADissenterGetStatus(DissenterRef) ? DADissenterGetStatus(DissenterRef) : -1;
+    CFRunLoopStop(CFRunLoopGetCurrent());
+}
+
+
+/**
+ * Obtain exclusive access to the DVD device, umount it if necessary.
+ *
+ * @return  VBox status code.
+ * @param   pThis       The driver instance.
+ * @param   DVDService  The DVD service object.
+ */
+static int drvHostBaseObtainExclusiveAccess(PDRVHOSTBASE pThis, io_object_t DVDService)
+{
+    PPDMDRVINS pDrvIns = pThis->pDrvIns; NOREF(pDrvIns);
+
+    for (unsigned iTry = 0;; iTry++)
+    {
+        IOReturn irc = (*pThis->Os.ppScsiTaskDI)->ObtainExclusiveAccess(pThis->Os.ppScsiTaskDI);
+        if (irc == kIOReturnSuccess)
+        {
+            /*
+             * This is a bit weird, but if we unmounted the DVD drive we also need to
+             * unlock it afterwards or the guest won't be able to eject it later on.
+             */
+            if (pThis->Os.pDADisk)
+            {
+                uint8_t abCmd[16] =
+                {
+                    SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, false, 0,
+                    0,0,0,0,0,0,0,0,0,0
+                };
+                drvHostBaseScsiCmdOs(pThis, abCmd, 6, PDMMEDIATXDIR_NONE, NULL, NULL, NULL, 0, 0);
+            }
+            return VINF_SUCCESS;
+        }
+        if (irc == kIOReturnExclusiveAccess)
+            return VERR_SHARING_VIOLATION;      /* already used exclusivly. */
+        if (irc != kIOReturnBusy)
+            return VERR_GENERAL_FAILURE;        /* not mounted */
+
+        /*
+         * Attempt to the unmount all volumes of the device.
+         * It seems we can can do this all in one go without having to enumerate the
+         * volumes (sessions) and deal with them one by one. This is very fortuitous
+         * as the disk arbitration API is a bit cumbersome to deal with.
+         */
+        if (iTry > 2)
+            return VERR_DRIVE_LOCKED;
+        char szName[128];
+        int rc = drvHostBaseGetBSDName(DVDService, &szName[0], 0);
+        if (RT_SUCCESS(rc))
+        {
+            pThis->Os.pDASession = DASessionCreate(kCFAllocatorDefault);
+            if (pThis->Os.pDASession)
+            {
+                DASessionScheduleWithRunLoop(pThis->Os.pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
+                pThis->Os.pDADisk = DADiskCreateFromBSDName(kCFAllocatorDefault, pThis->Os.pDASession, szName);
+                if (pThis->Os.pDADisk)
+                {
+                    /*
+                     * Try claim the device.
+                     */
+                    Log(("%s-%d: calling DADiskClaim on '%s'.\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
+                    int rcDA = -2;
+                    DADiskClaim(pThis->Os.pDADisk, kDADiskClaimOptionDefault, NULL, NULL, drvHostBaseDADoneCallback, &rcDA);
+                    SInt32 rc32 = CFRunLoopRunInMode(MY_RUN_LOOP_MODE, 120.0, FALSE);
+                    AssertMsg(rc32 == kCFRunLoopRunStopped, ("rc32=%RI32 (%RX32)\n", rc32, rc32));
+                    if (    rc32 == kCFRunLoopRunStopped
+                        &&  !rcDA)
+                    {
+                        /*
+                         * Try unmount the device.
+                         */
+                        Log(("%s-%d: calling DADiskUnmount on '%s'.\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
+                        rcDA = -2;
+                        DADiskUnmount(pThis->Os.pDADisk, kDADiskUnmountOptionWhole, drvHostBaseDADoneCallback, &rcDA);
+                        rc32 = CFRunLoopRunInMode(MY_RUN_LOOP_MODE, 120.0, FALSE);
+                        AssertMsg(rc32 == kCFRunLoopRunStopped, ("rc32=%RI32 (%RX32)\n", rc32, rc32));
+                        if (    rc32 == kCFRunLoopRunStopped
+                            &&  !rcDA)
+                        {
+                            iTry = 99;
+                            DASessionUnscheduleFromRunLoop(pThis->Os.pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
+                            Log(("%s-%d: unmount succeed - retrying.\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
+                            continue;
+                        }
+                        Log(("%s-%d: umount => rc32=%d & rcDA=%#x\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc32, rcDA));
+
+                        /* failed - cleanup */
+                        DADiskUnclaim(pThis->Os.pDADisk);
+                    }
+                    else
+                        Log(("%s-%d: claim => rc32=%d & rcDA=%#x\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc32, rcDA));
+
+                    CFRelease(pThis->Os.pDADisk);
+                    pThis->Os.pDADisk = NULL;
+                }
+                else
+                    Log(("%s-%d: failed to open disk '%s'!\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
+
+                DASessionUnscheduleFromRunLoop(pThis->Os.pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
+                CFRelease(pThis->Os.pDASession);
+                pThis->Os.pDASession = NULL;
+            }
+            else
+                Log(("%s-%d: failed to create DA session!\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
+        }
+        RTThreadSleep(10);
+    }
+}
 
 DECLHIDDEN(int) drvHostBaseScsiCmdOs(PDRVHOSTBASE pThis, const uint8_t *pbCmd, size_t cbCmd, PDMMEDIATXDIR enmTxDir,
@@ -45 +244 @@
         *pcbBuf = 0;
 
-    Assert(pThis->ppScsiTaskDI);
+    Assert(pThis->Os.ppScsiTaskDI);
 
     int rc = VERR_GENERAL_FAILURE;
-    SCSITaskInterface **ppScsiTaskI = (*pThis->ppScsiTaskDI)->CreateSCSITask(pThis->ppScsiTaskDI);
+    SCSITaskInterface **ppScsiTaskI = (*pThis->Os.ppScsiTaskDI)->CreateSCSITask(pThis->Os.ppScsiTaskDI);
     if (!ppScsiTaskI)
         return VERR_NO_MEMORY;
@@ -110 +309 @@
                ? VERR_READ_ERROR
                : VERR_WRITE_ERROR;
-            if (pThis->cLogRelErrors++ < 10)
+            if (pThis->Os.cLogRelErrors++ < 10)
                 LogRel(("DVD scsi error: cmd={%.*Rhxs} TaskStatus=%#x key=%#x ASC=%#x ASCQ=%#x (%Rrc)\n",
                         cbCmd, pbCmd, TaskStatus, SenseData.SENSE_KEY, SenseData.ADDITIONAL_SENSE_CODE,
@@ -147 +346 @@
         //if (Buf.cbBlock > 2048) /* everyone else is doing this... check if it needed/right.*/
         //    Buf.cbBlock = 2048;
-        pThis->cbBlock = Buf.cbBlock;
+        pThis->Os.cbBlock = Buf.cbBlock;
 
         *pcb = (uint64_t)Buf.cBlocks * Buf.cbBlock;
@@ -159 +358 @@
     int rc = VINF_SUCCESS;
 
-    if (    pThis->ppScsiTaskDI
-        &&  pThis->cbBlock)
+    if (    pThis->Os.ppScsiTaskDI
+        &&  pThis->Os.cbBlock)
     {
         /*
@@ -167 +366 @@
         do
         {
-            const uint32_t  LBA       = off / pThis->cbBlock;
-            AssertReturn(!(off % pThis->cbBlock), VERR_INVALID_PARAMETER);
+            const uint32_t  LBA       = off / pThis->Os.cbBlock;
+            AssertReturn(!(off % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
             uint32_t        cbRead32  =   cbRead > SCSI_MAX_BUFFER_SIZE
                                         ? SCSI_MAX_BUFFER_SIZE
                                         : (uint32_t)cbRead;
-            const uint32_t  cBlocks   = cbRead32 / pThis->cbBlock;
-            AssertReturn(!(cbRead % pThis->cbBlock), VERR_INVALID_PARAMETER);
+            const uint32_t  cBlocks   = cbRead32 / pThis->Os.cbBlock;
+            AssertReturn(!(cbRead % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
             uint8_t         abCmd[16] =
             {
@@ -233 +432 @@
 DECLHIDDEN(int) drvHostBaseQueryMediaStatusOs(PDRVHOSTBASE pThis, bool *pfMediaChanged, bool *pfMediaPresent)
 {
-    AssertReturn(pThis->ppScsiTaskDI, VERR_INTERNAL_ERROR);
+    AssertReturn(pThis->Os.ppScsiTaskDI, VERR_INTERNAL_ERROR);
 
     /*
@@ -266 +465 @@
 
 
-DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis)
-{
-    return RTSemEventSignal(pThis->EventPoller);
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis)
+{
+    pThis->Os.MasterPort   = IO_OBJECT_NULL;
+    pThis->Os.ppMMCDI      = NULL;
+    pThis->Os.ppScsiTaskDI = NULL;
+    pThis->Os.cbBlock      = 0;
+    pThis->Os.pDADisk      = NULL;
+    pThis->Os.pDASession   = NULL;
+}
+
+
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly)
+{
+    RT_NOREF(fReadOnly);
+
+    /* Darwin is kind of special... */
+    Assert(!pThis->Os.cbBlock);
+    Assert(pThis->Os.MasterPort == IO_OBJECT_NULL);
+    Assert(!pThis->Os.ppMMCDI);
+    Assert(!pThis->Os.ppScsiTaskDI);
+
+    /*
+     * Open the master port on the first invocation.
+     */
+    kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &pThis->Os.MasterPort);
+    AssertReturn(krc == KERN_SUCCESS, VERR_GENERAL_FAILURE);
+
+    /*
+     * Create a matching dictionary for searching for CD, DVD and BlueRay services in the IOKit.
+     *
+     * The idea is to find all the devices which are of class IOCDBlockStorageDevice.
+     * CD devices are represented by IOCDBlockStorageDevice class itself, while DVD and BlueRay ones
+     * have it as a parent class.
+     */
+    CFMutableDictionaryRef RefMatchingDict = IOServiceMatching("IOCDBlockStorageDevice");
+    AssertReturn(RefMatchingDict, VERR_NOT_FOUND);
+
+    /*
+     * do the search and get a collection of keyboards.
+     */
+    io_iterator_t DVDServices = IO_OBJECT_NULL;
+    IOReturn irc = IOServiceGetMatchingServices(pThis->Os.MasterPort, RefMatchingDict, &DVDServices);
+    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), VERR_NOT_FOUND);
+    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
+
+    /*
+     * Enumerate the matching drives (services).
+     * (This enumeration must be identical to the one performed in Main/src-server/darwin/iokit.cpp.)
+     */
+    int rc = VERR_FILE_NOT_FOUND;
+    unsigned i = 0;
+    io_object_t DVDService;
+    while ((DVDService = IOIteratorNext(DVDServices)) != 0)
+    {
+        /*
+         * Get the properties we use to identify the DVD drive.
+         *
+         * While there is a (weird 12 byte) GUID, it isn't persistent
+         * across boots. So, we have to use a combination of the
+         * vendor name and product name properties with an optional
+         * sequence number for identification.
+         */
+        CFMutableDictionaryRef PropsRef = 0;
+        krc = IORegistryEntryCreateCFProperties(DVDService, &PropsRef, kCFAllocatorDefault, kNilOptions);
+        if (krc == KERN_SUCCESS)
+        {
+            /* Get the Device Characteristics dictionary. */
+            CFDictionaryRef DevCharRef = (CFDictionaryRef)CFDictionaryGetValue(PropsRef, CFSTR(kIOPropertyDeviceCharacteristicsKey));
+            if (DevCharRef)
+            {
+                /* The vendor name. */
+                char szVendor[128];
+                char *pszVendor = &szVendor[0];
+                CFTypeRef ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyVendorNameKey));
+                if (    ValueRef
+                    &&  CFGetTypeID(ValueRef) == CFStringGetTypeID()
+                    &&  CFStringGetCString((CFStringRef)ValueRef, szVendor, sizeof(szVendor), kCFStringEncodingUTF8))
+                    pszVendor = RTStrStrip(szVendor);
+                else
+                    *pszVendor = '\0';
+
+                /* The product name. */
+                char szProduct[128];
+                char *pszProduct = &szProduct[0];
+                ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyProductNameKey));
+                if (    ValueRef
+                    &&  CFGetTypeID(ValueRef) == CFStringGetTypeID()
+                    &&  CFStringGetCString((CFStringRef)ValueRef, szProduct, sizeof(szProduct), kCFStringEncodingUTF8))
+                    pszProduct = RTStrStrip(szProduct);
+                else
+                    *pszProduct = '\0';
+
+                /* Construct the two names and compare thwm with the one we're searching for. */
+                char szName1[256 + 32];
+                char szName2[256 + 32];
+                if (*pszVendor || *pszProduct)
+                {
+                    if (*pszVendor && *pszProduct)
+                    {
+                        RTStrPrintf(szName1, sizeof(szName1), "%s %s", pszVendor, pszProduct);
+                        RTStrPrintf(szName2, sizeof(szName2), "%s %s (#%u)", pszVendor, pszProduct, i);
+                    }
+                    else
+                    {
+                        strcpy(szName1, *pszVendor ? pszVendor : pszProduct);
+                        RTStrPrintf(szName2, sizeof(szName2), "%s (#%u)", *pszVendor ? pszVendor : pszProduct, i);
+                    }
+                }
+                else
+                {
+                    RTStrPrintf(szName1, sizeof(szName1), "(#%u)", i);
+                    strcpy(szName2, szName1);
+                }
+
+                if (    !strcmp(szName1, pThis->pszDevice)
+                    ||  !strcmp(szName2, pThis->pszDevice))
+                {
+                    /*
+                     * Found it! Now, get the client interface and stuff.
+                     * Note that we could also query kIOSCSITaskDeviceUserClientTypeID here if the
+                     * MMC client plugin is missing. For now we assume this won't be necessary.
+                     */
+                    SInt32 Score = 0;
+                    IOCFPlugInInterface **ppPlugInInterface = NULL;
+                    krc = IOCreatePlugInInterfaceForService(DVDService, kIOMMCDeviceUserClientTypeID, kIOCFPlugInInterfaceID,
+                                                            &ppPlugInInterface, &Score);
+                    if (krc == KERN_SUCCESS)
+                    {
+                        HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
+                                                                           CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),
+                                                                           (LPVOID *)&pThis->Os.ppMMCDI);
+                        (*ppPlugInInterface)->Release(ppPlugInInterface);
+                        ppPlugInInterface = NULL;
+                        if (hrc == S_OK)
+                        {
+                            pThis->Os.ppScsiTaskDI = (*pThis->Os.ppMMCDI)->GetSCSITaskDeviceInterface(pThis->Os.ppMMCDI);
+                            if (pThis->Os.ppScsiTaskDI)
+                                rc = VINF_SUCCESS;
+                            else
+                            {
+                                LogRel(("GetSCSITaskDeviceInterface failed on '%s'\n", pThis->pszDevice));
+                                rc = VERR_NOT_SUPPORTED;
+                                (*pThis->Os.ppMMCDI)->Release(pThis->Os.ppMMCDI);
+                            }
+                        }
+                        else
+                        {
+                            rc = VERR_GENERAL_FAILURE;//RTErrConvertFromDarwinCOM(krc);
+                            pThis->Os.ppMMCDI = NULL;
+                        }
+                    }
+                    else /* Check for kIOSCSITaskDeviceUserClientTypeID? */
+                        rc = VERR_GENERAL_FAILURE;//RTErrConvertFromDarwinKern(krc);
+
+                    /* Obtain exclusive access to the device so we can send SCSI commands. */
+                    if (RT_SUCCESS(rc))
+                        rc = drvHostBaseObtainExclusiveAccess(pThis, DVDService);
+
+                    /* Cleanup on failure. */
+                    if (RT_FAILURE(rc))
+                    {
+                        if (pThis->Os.ppScsiTaskDI)
+                        {
+                            (*pThis->Os.ppScsiTaskDI)->Release(pThis->Os.ppScsiTaskDI);
+                            pThis->Os.ppScsiTaskDI = NULL;
+                        }
+                        if (pThis->Os.ppMMCDI)
+                        {
+                            (*pThis->Os.ppMMCDI)->Release(pThis->Os.ppMMCDI);
+                            pThis->Os.ppMMCDI = NULL;
+                        }
+                    }
+
+                    IOObjectRelease(DVDService);
+                    break;
+                }
+            }
+            CFRelease(PropsRef);
+        }
+        else
+            AssertMsgFailed(("krc=%#x\n", krc));
+
+        IOObjectRelease(DVDService);
+        i++;
+    }
+
+    IOObjectRelease(DVDServices);
+    return rc;
+
+}
+
+
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis)
+{
+    RT_NOREF(pThis);
+    return VINF_SUCCESS;
+}
+
+
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis)
+{
+    if (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
+        return true;
+
+    AssertMsgFailed(("Darwin supports only CD/DVD host drive access\n"));
+    return false;
 }
 
@@ -274 +676 @@
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->EventPoller != NULL)
-    {
-        RTSemEventDestroy(pThis->EventPoller);
-        pThis->EventPoller = NULL;
+    /*
+     * Unlock the drive if we've locked it or we're in passthru mode.
+     */
+    if (    (   pThis->fLocked
+             || pThis->IMedia.pfnSendCmd)
+        &&  pThis->Os.ppScsiTaskDI
+        &&  pThis->pfnDoLock)
+    {
+        int rc = pThis->pfnDoLock(pThis, false);
+        if (RT_SUCCESS(rc))
+            pThis->fLocked = false;
     }
 
@@ -290 +699 @@
      * and umount the DVD but somehow failed to gain exclusive scsi access...
      */
-    if (pThis->ppScsiTaskDI)
+    if (pThis->Os.ppScsiTaskDI)
     {
         LogFlow(("%s-%d: releasing exclusive scsi access!\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
-        (*pThis->ppScsiTaskDI)->ReleaseExclusiveAccess(pThis->ppScsiTaskDI);
-        (*pThis->ppScsiTaskDI)->Release(pThis->ppScsiTaskDI);
-        pThis->ppScsiTaskDI = NULL;
-    }
-    if (pThis->pDADisk)
+        (*pThis->Os.ppScsiTaskDI)->ReleaseExclusiveAccess(pThis->Os.ppScsiTaskDI);
+        (*pThis->Os.ppScsiTaskDI)->Release(pThis->Os.ppScsiTaskDI);
+        pThis->Os.ppScsiTaskDI = NULL;
+    }
+    if (pThis->Os.pDADisk)
     {
         LogFlow(("%s-%d: unclaiming the disk!\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
-        DADiskUnclaim(pThis->pDADisk);
-        CFRelease(pThis->pDADisk);
-        pThis->pDADisk = NULL;
-    }
-    if (pThis->ppMMCDI)
+        DADiskUnclaim(pThis->Os.pDADisk);
+        CFRelease(pThis->Os.pDADisk);
+        pThis->Os.pDADisk = NULL;
+    }
+    if (pThis->Os.ppMMCDI)
     {
         LogFlow(("%s-%d: releasing the MMC object!\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
-        (*pThis->ppMMCDI)->Release(pThis->ppMMCDI);
-        pThis->ppMMCDI = NULL;
-    }
-    if (pThis->MasterPort != IO_OBJECT_NULL)
-    {
-        mach_port_deallocate(mach_task_self(), pThis->MasterPort);
-        pThis->MasterPort = IO_OBJECT_NULL;
-    }
-    if (pThis->pDASession)
+        (*pThis->Os.ppMMCDI)->Release(pThis->Os.ppMMCDI);
+        pThis->Os.ppMMCDI = NULL;
+    }
+    if (pThis->Os.MasterPort != IO_OBJECT_NULL)
+    {
+        mach_port_deallocate(mach_task_self(), pThis->Os.MasterPort);
+        pThis->Os.MasterPort = IO_OBJECT_NULL;
+    }
+    if (pThis->Os.pDASession)
     {
         LogFlow(("%s-%d: releasing the DA session!\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
-        CFRelease(pThis->pDASession);
-        pThis->pDASession = NULL;
-    }
-}
-
+        CFRelease(pThis->Os.pDASession);
+        pThis->Os.pDASession = NULL;
+    }
+}
+

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

@@ -27 +27 @@
 #include <iprt/log.h>
 
+/**
+ * Host backend specific data.
+ */
+typedef struct DRVHOSTBASEOS
+{
+    /** The filehandle of the device. */
+    RTFILE                  hFileDevice;
+    /** The block size. Set when querying the media size. */
+    uint32_t                cbBlock;
+    /** SCSI bus number. */
+    path_id_t               ScsiBus;
+    /** target ID of the passthrough device. */
+    target_id_t             ScsiTargetID;
+    /** LUN of the passthrough device. */
+    lun_id_t                ScsiLunID;
+} DRVHOSTBASEOS;
+/** Pointer to the host backend specific data. */
+typedef DRVHOSTBASEOS *PDRVHOSBASEOS;
+AssertCompile(sizeof(DRVHOSTBASEOS) <= 64);
+
+#define DRVHOSTBASE_OS_INT_DECLARED
 #include "DrvHostBase.h"
 
@@ -46 +67 @@
         *pcbBuf = 0;
 
-    Assert(pThis->ppScsiTaskDI);
-
-    int rc = VERR_GENERAL_FAILURE;
-    SCSITaskInterface **ppScsiTaskI = (*pThis->ppScsiTaskDI)->CreateSCSITask(pThis->ppScsiTaskDI);
-    if (!ppScsiTaskI)
-        return VERR_NO_MEMORY;
-    do
-    {
-        /* Setup the scsi command. */
-        SCSICommandDescriptorBlock cdb = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
-        memcpy(&cdb[0], pbCmd, cbCmd);
-        IOReturn irc = (*ppScsiTaskI)->SetCommandDescriptorBlock(ppScsiTaskI, cdb, cbCmd);
-        AssertBreak(irc == kIOReturnSuccess);
-
-        /* Setup the buffer. */
+    int rc = VINF_SUCCESS;
+    int rcBSD = 0;
+    union ccb DeviceCCB;
+    union ccb *pDeviceCCB = &DeviceCCB;
+    u_int32_t fFlags;
+
+    memset(pDeviceCCB, 0, sizeof(DeviceCCB));
+    pDeviceCCB->ccb_h.path_id   = pThis->Os.ScsiBus;
+    pDeviceCCB->ccb_h.target_id = pThis->Os.ScsiTargetID;
+    pDeviceCCB->ccb_h.target_lun = pThis->Os.ScsiLunID;
+
+    /* The SCSI INQUIRY command can't be passed through directly. */
+    if (pbCmd[0] == SCSI_INQUIRY)
+    {
+        pDeviceCCB->ccb_h.func_code = XPT_GDEV_TYPE;
+
+        rcBSD = ioctl(RTFileToNative(pThis->Os.hFileDevice), CAMIOCOMMAND, pDeviceCCB);
+        if (!rcBSD)
+        {
+            uint32_t cbCopy =   cbBuf < sizeof(struct scsi_inquiry_data)
+                              ? cbBuf
+                              : sizeof(struct scsi_inquiry_data);;
+            memcpy(pvBuf, &pDeviceCCB->cgd.inq_data, cbCopy);
+            memset(pbSense, 0, cbSense);
+
+            if (pcbBuf)
+                *pcbBuf = cbCopy;
+        }
+        else
+            rc = RTErrConvertFromErrno(errno);
+    }
+    else
+    {
+        /* Copy the CDB. */
+        memcpy(&pDeviceCCB->csio.cdb_io.cdb_bytes, pbCmd, cbCmd);
+
+        /* Set direction. */
         if (enmTxDir == PDMMEDIATXDIR_NONE)
-            irc = (*ppScsiTaskI)->SetScatterGatherEntries(ppScsiTaskI, NULL, 0, 0, kSCSIDataTransfer_NoDataTransfer);
+            fFlags = CAM_DIR_NONE;
+        else if (enmTxDir == PDMMEDIATXDIR_FROM_DEVICE)
+            fFlags = CAM_DIR_IN;
         else
+            fFlags = CAM_DIR_OUT;
+
+        fFlags |= CAM_DEV_QFRZDIS;
+
+        cam_fill_csio(&pDeviceCCB->csio, 1, NULL, fFlags, MSG_SIMPLE_Q_TAG,
+                      (u_int8_t *)pvBuf, cbBuf, cbSense, cbCmd,
+                      cTimeoutMillies ? cTimeoutMillies : 30000/* timeout */);
+
+        /* Send command */
+        rcBSD = ioctl(RTFileToNative(pThis->Os.hFileDevice), CAMIOCOMMAND, pDeviceCCB);
+        if (!rcBSD)
         {
-            IOVirtualRange Range = { (IOVirtualAddress)pvBuf, cbBuf };
-            irc = (*ppScsiTaskI)->SetScatterGatherEntries(ppScsiTaskI, &Range, 1, cbBuf,
-                                                          enmTxDir == PDMMEDIATXDIR_FROM_DEVICE
-                                                          ? kSCSIDataTransfer_FromTargetToInitiator
-                                                          : kSCSIDataTransfer_FromInitiatorToTarget);
+            switch (pDeviceCCB->ccb_h.status & CAM_STATUS_MASK)
+            {
+                case CAM_REQ_CMP:
+                    rc = VINF_SUCCESS;
+                    break;
+                case CAM_SEL_TIMEOUT:
+                    rc = VERR_DEV_IO_ERROR;
+                    break;
+                case CAM_CMD_TIMEOUT:
+                    rc = VERR_TIMEOUT;
+                    break;
+                default:
+                    rc = VERR_DEV_IO_ERROR;
+            }
+
+            if (pcbBuf)
+                *pcbBuf = cbBuf - pDeviceCCB->csio.resid;
+
+            if (pbSense)
+                memcpy(pbSense, &pDeviceCCB->csio.sense_data,
+                       cbSense - pDeviceCCB->csio.sense_resid);
         }
-        AssertBreak(irc == kIOReturnSuccess);
-
-        /* Set the timeout. */
-        irc = (*ppScsiTaskI)->SetTimeoutDuration(ppScsiTaskI, cTimeoutMillies ? cTimeoutMillies : 30000 /*ms*/);
-        AssertBreak(irc == kIOReturnSuccess);
-
-        /* Execute the command and get the response. */
-        SCSI_Sense_Data SenseData = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
-        SCSIServiceResponse     ServiceResponse = kSCSIServiceResponse_Request_In_Process;
-        SCSITaskStatus TaskStatus = kSCSITaskStatus_GOOD;
-        UInt64 cbReturned = 0;
-        irc = (*ppScsiTaskI)->ExecuteTaskSync(ppScsiTaskI, &SenseData, &TaskStatus, &cbReturned);
-        AssertBreak(irc == kIOReturnSuccess);
-        if (pcbBuf)
-            *pcbBuf = (int32_t)cbReturned;
-
-        irc = (*ppScsiTaskI)->GetSCSIServiceResponse(ppScsiTaskI, &ServiceResponse);
-        AssertBreak(irc == kIOReturnSuccess);
-        AssertBreak(ServiceResponse == kSCSIServiceResponse_TASK_COMPLETE);
-
-        if (TaskStatus == kSCSITaskStatus_GOOD)
-            rc = VINF_SUCCESS;
-        else if (   TaskStatus == kSCSITaskStatus_CHECK_CONDITION
-                 && pbSense)
-        {
-            memset(pbSense, 0, cbSense); /* lazy */
-            memcpy(pbSense, &SenseData, RT_MIN(sizeof(SenseData), cbSense));
-            rc = VERR_UNRESOLVED_ERROR;
-        }
-        /** @todo convert sense codes when caller doesn't wish to do this himself. */
-        /*else if (   TaskStatus == kSCSITaskStatus_CHECK_CONDITION
-                 && SenseData.ADDITIONAL_SENSE_CODE == 0x3A)
-            rc = VERR_MEDIA_NOT_PRESENT; */
         else
-        {
-            rc = enmTxDir == PDMMEDIATXDIR_NONE
-               ? VERR_DEV_IO_ERROR
-               : enmTxDir == PDMMEDIATXDIR_FROM_DEVICE
-               ? VERR_READ_ERROR
-               : VERR_WRITE_ERROR;
-            if (pThis->cLogRelErrors++ < 10)
-                LogRel(("DVD scsi error: cmd={%.*Rhxs} TaskStatus=%#x key=%#x ASC=%#x ASCQ=%#x (%Rrc)\n",
-                        cbCmd, pbCmd, TaskStatus, SenseData.SENSE_KEY, SenseData.ADDITIONAL_SENSE_CODE,
-                        SenseData.ADDITIONAL_SENSE_CODE_QUALIFIER, rc));
-        }
-    } while (0);
-
-    (*ppScsiTaskI)->Release(ppScsiTaskI);
-
-    return rc;
+            rc = RTErrConvertFromErrno(errno);
+    }
 }
 
@@ -148 +173 @@
         //if (Buf.cbBlock > 2048) /* everyone else is doing this... check if it needed/right.*/
         //    Buf.cbBlock = 2048;
-        pThis->cbBlock = Buf.cbBlock;
+        pThis->Os.cbBlock = Buf.cbBlock;
 
         *pcb = (uint64_t)Buf.cBlocks * Buf.cbBlock;
@@ -160 +185 @@
     int rc = VINF_SUCCESS;
 
-    if (pThis->cbBlock)
+    if (pThis->Os.cbBlock)
     {
         /*
@@ -167 +192 @@
         do
         {
-            const uint32_t  LBA       = off / pThis->cbBlock;
-            AssertReturn(!(off % pThis->cbBlock), VERR_INVALID_PARAMETER);
+            const uint32_t  LBA       = off / pThis->Os.cbBlock;
+            AssertReturn(!(off % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
             uint32_t        cbRead32  =   cbRead > SCSI_MAX_BUFFER_SIZE
                                         ? SCSI_MAX_BUFFER_SIZE
                                         : (uint32_t)cbRead;
-            const uint32_t  cBlocks   = cbRead32 / pThis->cbBlock;
-            AssertReturn(!(cbRead % pThis->cbBlock), VERR_INVALID_PARAMETER);
+            const uint32_t  cBlocks   = cbRead32 / pThis->Os.cbBlock;
+            AssertReturn(!(cbRead % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
             uint8_t         abCmd[16] =
             {
@@ -264 +289 @@
 
 
-DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis)
-{
-    return RTSemEventSignal(pThis->EventPoller);
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis)
+{
+    pThis->Os.hFileDevice = NIL_RTFILE;
+}
+
+
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly)
+{
+    RT_NOREF(fReadOnly);
+    RTFILE hFileDevice;
+    int rc = RTFileOpen(&hFileDevice, pThis->pszDevice, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * The current device handle can't passthrough SCSI commands.
+     * We have to get he passthrough device path and open this.
+     */
+    union ccb DeviceCCB;
+    memset(&DeviceCCB, 0, sizeof(DeviceCCB));
+
+    DeviceCCB.ccb_h.func_code = XPT_GDEVLIST;
+    int rcBSD = ioctl(RTFileToNative(hFileDevice), CAMGETPASSTHRU, &DeviceCCB);
+    if (!rcBSD)
+    {
+        char *pszPassthroughDevice = NULL;
+        rc = RTStrAPrintf(&pszPassthroughDevice, "/dev/%s%u",
+                          DeviceCCB.cgdl.periph_name, DeviceCCB.cgdl.unit_number);
+        if (rc >= 0)
+        {
+            RTFILE hPassthroughDevice;
+            rc = RTFileOpen(&hPassthroughDevice, pszPassthroughDevice, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+            RTStrFree(pszPassthroughDevice);
+            if (RT_SUCCESS(rc))
+            {
+                /* Get needed device parameters. */
+
+                /*
+                 * The device path, target id and lun id. Those are
+                 * needed for the SCSI passthrough ioctl.
+                 */
+                memset(&DeviceCCB, 0, sizeof(DeviceCCB));
+                DeviceCCB.ccb_h.func_code = XPT_GDEVLIST;
+
+                rcBSD = ioctl(RTFileToNative(hPassthroughDevice), CAMGETPASSTHRU, &DeviceCCB);
+                if (!rcBSD)
+                {
+                    if (DeviceCCB.cgdl.status != CAM_GDEVLIST_ERROR)
+                    {
+                        pThis->Os.ScsiBus      = DeviceCCB.ccb_h.path_id;
+                        pThis->Os.ScsiTargetID = DeviceCCB.ccb_h.target_id;
+                        pThis->Os.ScsiLunID    = DeviceCCB.ccb_h.target_lun;
+                        pThis->Os.hFileDevice  = hPassthroughDevice;
+                    }
+                    else
+                    {
+                        /* The passthrough device wasn't found. */
+                        rc = VERR_NOT_FOUND;
+                    }
+                }
+                else
+                    rc = RTErrConvertFromErrno(errno);
+
+                if (RT_FAILURE(rc))
+                    RTFileClose(hPassthroughDevice);
+            }
+        }
+        else
+            rc = VERR_NO_STR_MEMORY;
+    }
+    else
+        rc = RTErrConvertFromErrno(errno);
+
+    RTFileClose(hFileDevice);
+    return rc;
+}
+
+
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis)
+{
+    RT_NOREF(pThis);
+    return VINF_SUCCESS;
+}
+
+
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis)
+{
+    if (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
+        return true;
+
+    AssertMsgFailed(("FreeBSD supports only CD/DVD host drive access\n"));
+    return false;
 }
 
@@ -272 +386 @@
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->EventPoller != NULL)
-    {
-        RTSemEventDestroy(pThis->EventPoller);
-        pThis->EventPoller = NULL;
-    }
-
-    if (pThis->hFileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pThis->hFileDevice);
+    /*
+     * Unlock the drive if we've locked it or we're in passthru mode.
+     */
+    if (    pThis->fLocked
+        &&  pThis->Os.hFileDevice != NIL_RTFILE
+        &&  pThis->pfnDoLock)
+    {
+        int rc = pThis->pfnDoLock(pThis, false);
+        if (RT_SUCCESS(rc))
+            pThis->fLocked = false;
+    }
+
+    if (pThis->Os.hFileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->Os.hFileDevice);
         AssertRC(rc);
-        pThis->hFileDevice = NIL_RTFILE;
-    }
-}
-
+        pThis->Os.hFileDevice = NIL_RTFILE;
+    }
+}
+

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

@@ -39 +39 @@
 #include <VBox/scsi.h>
 
+/**
+ * Host backend specific data.
+ */
+typedef struct DRVHOSTBASEOS
+{
+    /** The filehandle of the device. */
+    RTFILE                  hFileDevice;
+    /** Double buffer required for ioctl with the Linux kernel as long as we use
+     * remap_pfn_range() instead of vm_insert_page(). */
+    uint8_t                *pbDoubleBuffer;
+    /** Previous disk inserted indicator for the media polling on floppy drives. */
+    bool                   fPrevDiskIn;
+} DRVHOSTBASEOS;
+/** Pointer to the host backend specific data. */
+typedef DRVHOSTBASEOS *PDRVHOSBASEOS;
+AssertCompile(sizeof(DRVHOSTBASEOS) <= 64);
+
+#define DRVHOSTBASE_OS_INT_DECLARED
 #include "DrvHostBase.h"
 
@@ -53 +71 @@
     AssertPtr(pbCmd);
     Assert(cbCmd <= 16 && cbCmd >= 1);
+
+    /* Allocate the temporary buffer lazily. */
+    if(RT_UNLIKELY(!pThis->Os.pbDoubleBuffer))
+    {
+        pThis->Os.pbDoubleBuffer = (uint8_t *)RTMemAlloc(SCSI_MAX_BUFFER_SIZE);
+        if (!pThis->Os.pbDoubleBuffer)
+            return VERR_NO_MEMORY;
+    }
 
     int rc = VERR_GENERAL_FAILURE;
@@ -74 +100 @@
              * security problems inside the guest OS, if users can issue
              * commands to the CDROM device. */
-            memset(pThis->pbDoubleBuffer, '\0', *pcbBuf);
+            memset(pThis->Os.pbDoubleBuffer, '\0', *pcbBuf);
             direction = CGC_DATA_READ;
             break;
@@ -80 +106 @@
             Assert(*pcbBuf != 0);
             Assert(*pcbBuf <= SCSI_MAX_BUFFER_SIZE);
-            memcpy(pThis->pbDoubleBuffer, pvBuf, *pcbBuf);
+            memcpy(pThis->Os.pbDoubleBuffer, pvBuf, *pcbBuf);
             direction = CGC_DATA_WRITE;
             break;
@@ -89 +115 @@
     memset(&cgc, '\0', sizeof(cgc));
     memcpy(cgc.cmd, pbCmd, RT_MIN(CDROM_PACKET_SIZE, cbCmd));
-    cgc.buffer = (unsigned char *)pThis->pbDoubleBuffer;
+    cgc.buffer = (unsigned char *)pThis->Os.pbDoubleBuffer;
     cgc.buflen = *pcbBuf;
     cgc.stat = 0;
@@ -97 +123 @@
     cgc.quiet = false;
     cgc.timeout = cTimeoutMillies;
-    rc = ioctl(RTFileToNative(pThis->hFileDevice), CDROM_SEND_PACKET, &cgc);
+    rc = ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROM_SEND_PACKET, &cgc);
     if (rc < 0)
     {
@@ -115 +141 @@
     {
         case PDMMEDIATXDIR_FROM_DEVICE:
-            memcpy(pvBuf, pThis->pbDoubleBuffer, *pcbBuf);
+            memcpy(pvBuf, pThis->Os.pbDoubleBuffer, *pcbBuf);
             break;
         default:
@@ -134 +160 @@
     if (PDMMEDIATYPE_IS_FLOPPY(pThis->enmType))
     {
-        rc = ioctl(RTFileToNative(pThis->hFileDevice), FDFLUSH);
+        rc = ioctl(RTFileToNative(pThis->Os.hFileDevice), FDFLUSH);
         if (rc)
         {
@@ -143 +169 @@
 
         floppy_drive_struct DrvStat;
-        rc = ioctl(RTFileToNative(pThis->hFileDevice), FDGETDRVSTAT, &DrvStat);
+        rc = ioctl(RTFileToNative(pThis->Os.hFileDevice), FDGETDRVSTAT, &DrvStat);
         if (rc)
         {
@@ -151 +177 @@
         }
         pThis->fReadOnly = !(DrvStat.flags & FD_DISK_WRITABLE);
-        rc = RTFileSeek(pThis->hFileDevice, 0, RTFILE_SEEK_END, pcb);
+        rc = RTFileSeek(pThis->Os.hFileDevice, 0, RTFILE_SEEK_END, pcb);
     }
     else if (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
     {
         /* Clear the media-changed-since-last-call-thingy just to be on the safe side. */
-        ioctl(RTFileToNative(pThis->hFileDevice), CDROM_MEDIA_CHANGED, CDSL_CURRENT);
-        rc = RTFileSeek(pThis->hFileDevice, 0, RTFILE_SEEK_END, pcb);
+        ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROM_MEDIA_CHANGED, CDSL_CURRENT);
+        rc = RTFileSeek(pThis->Os.hFileDevice, 0, RTFILE_SEEK_END, pcb);
     }
 
@@ -166 +192 @@
 DECLHIDDEN(int) drvHostBaseReadOs(PDRVHOSTBASE pThis, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    return RTFileReadAt(pThis->hFileDevice, off, pvBuf, cbRead, NULL);
+    return RTFileReadAt(pThis->Os.hFileDevice, off, pvBuf, cbRead, NULL);
 }
 
@@ -172 +198 @@
 DECLHIDDEN(int) drvHostBaseWriteOs(PDRVHOSTBASE pThis, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    return RTFileWriteAt(pThis->hFileDevice, off, pvBuf, cbWrite, NULL);
+    return RTFileWriteAt(pThis->Os.hFileDevice, off, pvBuf, cbWrite, NULL);
 }
 
@@ -178 +204 @@
 DECLHIDDEN(int) drvHostBaseFlushOs(PDRVHOSTBASE pThis)
 {
-    return RTFileFlush(pThis->hFileDevice);
+    return RTFileFlush(pThis->Os.hFileDevice);
 }
 
@@ -184 +210 @@
 DECLHIDDEN(int) drvHostBaseDoLockOs(PDRVHOSTBASE pThis, bool fLock)
 {
-    int rc = ioctl(RTFileToNative(pThis->hFileDevice), CDROM_LOCKDOOR, (int)fLock);
+    int rc = ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROM_LOCKDOOR, (int)fLock);
     if (rc < 0)
     {
@@ -201 +227 @@
 DECLHIDDEN(int) drvHostBaseEjectOs(PDRVHOSTBASE pThis)
 {
-    int rc = ioctl(RTFileToNative(pThis->hFileDevice), CDROMEJECT, 0);
+    int rc = ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROMEJECT, 0);
     if (rc < 0)
     {
@@ -218 +244 @@
 DECLHIDDEN(int) drvHostBaseQueryMediaStatusOs(PDRVHOSTBASE pThis, bool *pfMediaChanged, bool *pfMediaPresent)
 {
-    *pfMediaPresent = ioctl(RTFileToNative(pThis->hFileDevice), CDROM_DRIVE_STATUS, CDSL_CURRENT) == CDS_DISC_OK;
-    *pfMediaChanged = false;
-    if (pThis->fMediaPresent != *pfMediaPresent)
-        *pfMediaChanged = ioctl(RTFileToNative(pThis->hFileDevice), CDROM_MEDIA_CHANGED, CDSL_CURRENT) == 1;
-
-    return VINF_SUCCESS;
-}
-
-
-DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis)
-{
-    return RTSemEventSignal(pThis->EventPoller);
+    int rc = VINF_SUCCESS;
+
+    if (PDMMEDIATYPE_IS_FLOPPY(pThis->enmType))
+    {
+        floppy_drive_struct DrvStat;
+        int rcLnx = ioctl(RTFileToNative(pThis->Os.hFileDevice), FDPOLLDRVSTAT, &DrvStat);
+        if (!rcLnx)
+        {
+            bool fDiskIn = !(DrvStat.flags & (FD_VERIFY | FD_DISK_NEWCHANGE));
+            *pfMediaPresent = fDiskIn;
+
+            if (fDiskIn != pThis->Os.fPrevDiskIn)
+                *pfMediaChanged = true;
+
+            pThis->Os.fPrevDiskIn = fDiskIn;
+        }
+        else
+            rc = RTErrConvertFromErrno(errno);
+    }
+    else
+    {
+        *pfMediaPresent = ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROM_DRIVE_STATUS, CDSL_CURRENT) == CDS_DISC_OK;
+        *pfMediaChanged = false;
+        if (pThis->fMediaPresent != *pfMediaPresent)
+            *pfMediaChanged = ioctl(RTFileToNative(pThis->Os.hFileDevice), CDROM_MEDIA_CHANGED, CDSL_CURRENT) == 1;
+    }
+
+    return rc;
+}
+
+
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis)
+{
+    pThis->Os.hFileDevice    = NIL_RTFILE;
+    pThis->Os.pbDoubleBuffer = NULL;
+    pThis->Os.fPrevDiskIn    = false;
+}
+
+
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly)
+{
+    uint32_t fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE) | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK;
+    return RTFileOpen(&pThis->Os.hFileDevice, pThis->pszDevice, fFlags);
+}
+
+
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis)
+{
+    /*
+     * Need to re-open the device because it will kill off any cached data
+     * that Linux for some peculiar reason thinks should survive a media change.
+     */
+    if (pThis->Os.hFileDevice != NIL_RTFILE)
+    {
+        RTFileClose(pThis->Os.hFileDevice);
+        pThis->Os.hFileDevice = NIL_RTFILE;
+    }
+    int rc = drvHostBaseOpenOs(pThis, pThis->fReadOnlyConfig);
+    if (RT_FAILURE(rc))
+    {
+        if (!pThis->fReadOnlyConfig)
+        {
+            LogFlow(("%s-%d: drvHostBaseMediaRefreshOs: '%s' - retry readonly (%Rrc)\n",
+                     pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDevice, rc));
+            rc = drvHostBaseOpenOs(pThis, true);
+        }
+        if (RT_FAILURE(rc))
+        {
+            LogFlow(("%s-%d: failed to open device '%s', rc=%Rrc\n",
+                     pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDevice, rc));
+            return rc;
+        }
+        pThis->fReadOnly = true;
+    }
+    else
+        pThis->fReadOnly = pThis->fReadOnlyConfig;
+
+    return rc;
+}
+
+
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis)
+{
+    RT_NOREF(pThis);
+    return true; /* On Linux we always use media polling. */
 }
 
@@ -235 +334 @@
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->pbDoubleBuffer)
-    {
-        RTMemFree(pThis->pbDoubleBuffer);
-        pThis->pbDoubleBuffer = NULL;
-    }
-
-    if (pThis->EventPoller != NULL)
-    {
-        RTSemEventDestroy(pThis->EventPoller);
-        pThis->EventPoller = NULL;
-    }
-
-    if (pThis->hFileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pThis->hFileDevice);
+    /*
+     * Unlock the drive if we've locked it or we're in passthru mode.
+     */
+    if (    pThis->fLocked
+        &&  pThis->Os.hFileDevice != NIL_RTFILE
+        &&  pThis->pfnDoLock)
+    {
+        int rc = pThis->pfnDoLock(pThis, false);
+        if (RT_SUCCESS(rc))
+            pThis->fLocked = false;
+    }
+
+    if (pThis->Os.pbDoubleBuffer)
+    {
+        RTMemFree(pThis->Os.pbDoubleBuffer);
+        pThis->Os.pbDoubleBuffer = NULL;
+    }
+
+    if (pThis->Os.hFileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->Os.hFileDevice);
         AssertRC(rc);
-        pThis->hFileDevice = NIL_RTFILE;
-    }
-}
-
+        pThis->Os.hFileDevice = NIL_RTFILE;
+    }
+}
+

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

@@ -33 +33 @@
 
 #include <iprt/file.h>
+
+/**
+ * Host backend specific data.
+ */
+typedef struct DRVHOSTBASEOS
+{
+    /** The filehandle of the device. */
+    RTFILE                  hFileDevice;
+    /** The raw filehandle of the device. */
+    RTFILE                  hFileRawDevice;
+    /** Device name of raw device (RTStrFree). */
+    char                   *pszRawDeviceOpen;
+} DRVHOSTBASEOS;
+/** Pointer to the host backend specific data. */
+typedef DRVHOSTBASEOS *PDRVHOSBASEOS;
+AssertCompile(sizeof(DRVHOSTBASEOS) <= 64);
+
+#define DRVHOSTBASE_OS_INT_DECLARED
 #include "DrvHostBase.h"
 
@@ -40 +58 @@
  * return the value. BUT... this might be prohibitively slow.
  */
+
+/**
+ * Checks if the current user is authorized using Solaris' role-based access control.
+ * Made as a separate function with so that it need not be invoked each time we need
+ * to gain root access.
+ *
+ * @returns VBox error code.
+ */
+static int solarisCheckUserAuth()
+{
+    /* Uses Solaris' role-based access control (RBAC).*/
+    struct passwd *pPass = getpwuid(getuid());
+    if (pPass == NULL || chkauthattr("solaris.device.cdrw", pPass->pw_name) == 0)
+        return VERR_PERMISSION_DENIED;
+
+    return VINF_SUCCESS;
+}
 
 /**
@@ -148 +183 @@
     solarisEnterRootMode(&effUserID); /** @todo check return code when this really works. */
 #endif
-    rc = ioctl(RTFileToNative(pThis->hFileRawDevice), USCSICMD, &usc);
+    rc = ioctl(RTFileToNative(pThis->Os.hFileRawDevice), USCSICMD, &usc);
 #ifdef VBOX_WITH_SUID_WRAPPER
     solarisExitRootMode(&effUserID);
@@ -175 +210 @@
      */
     struct dk_minfo MediaInfo;
-    if (ioctl(RTFileToNative(pThis->hFileRawDevice), DKIOCGMEDIAINFO, &MediaInfo) == 0)
+    if (ioctl(RTFileToNative(pThis->Os.hFileRawDevice), DKIOCGMEDIAINFO, &MediaInfo) == 0)
     {
         *pcb = MediaInfo.dki_capacity * (uint64_t)MediaInfo.dki_lbsize;
         return VINF_SUCCESS;
     }
-    return RTFileSeek(pThis->hFileDevice, 0, RTFILE_SEEK_END, pcb);
+    return RTFileSeek(pThis->Os.hFileDevice, 0, RTFILE_SEEK_END, pcb);
 }
 
@@ -186 +221 @@
 DECLHIDDEN(int) drvHostBaseReadOs(PDRVHOSTBASE pThis, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    return RTFileReadAt(pThis->hFileDevice, off, pvBuf, cbRead, NULL);
+    return RTFileReadAt(pThis->Os.hFileDevice, off, pvBuf, cbRead, NULL);
 }
 
@@ -192 +227 @@
 DECLHIDDEN(int) drvHostBaseWriteOs(PDRVHOSTBASE pThis, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    return RTFileWriteAt(pThis->hFileDevice, off, pvBuf, cbWrite, NULL);
+    return RTFileWriteAt(pThis->Os.hFileDevice, off, pvBuf, cbWrite, NULL);
 }
 
@@ -198 +233 @@
 DECLHIDDEN(int) drvHostBaseFlushOs(PDRVHOSTBASE pThis)
 {
-    return RTFileFlush(pThis->hFileDevice);
+    return RTFileFlush(pThis->Os.hFileDevice);
 }
 
@@ -204 +239 @@
 DECLHIDDEN(int) drvHostBaseDoLockOs(PDRVHOSTBASE pThis, bool fLock)
 {
-    int rc = ioctl(RTFileToNative(pThis->hFileRawDevice), fLock ? DKIOCLOCK : DKIOCUNLOCK, 0);
+    int rc = ioctl(RTFileToNative(pThis->Os.hFileRawDevice), fLock ? DKIOCLOCK : DKIOCUNLOCK, 0);
     if (rc < 0)
     {
@@ -221 +256 @@
 DECLHIDDEN(int) drvHostBaseEjectOs(PDRVHOSTBASE pThis)
 {
-    int rc = ioctl(RTFileToNative(pThis->hFileRawDevice), DKIOCEJECT, 0);
+    int rc = ioctl(RTFileToNative(pThis->Os.hFileRawDevice), DKIOCEJECT, 0);
     if (rc < 0)
     {
@@ -246 +281 @@
     static dkio_state s_DeviceState = DKIO_NONE;
     dkio_state PreviousState = s_DeviceState;
-    int rc = ioctl(RTFileToNative(pThis->hFileRawDevice), DKIOCSTATE, &s_DeviceState);
+    int rc = ioctl(RTFileToNative(pThis->Os.hFileRawDevice), DKIOCSTATE, &s_DeviceState);
     if (rc == 0)
     {
@@ -258 +293 @@
 
 
-DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis)
-{
-    return RTSemEventSignal(pThis->EventPoller);
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis)
+{
+    pThis->Os.hFileDevice      = NIL_RTFILE;
+    pThis->Os.hFileRawDevice   = NIL_RTFILE;
+    pThis->Os.pszRawDeviceOpen = NULL;
+}
+
+
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly)
+{
+#ifdef VBOX_WITH_SUID_WRAPPER  /* Solaris setuid for Passthrough mode. */
+    if (   (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
+        && pThis->IMedia.pfnSendCmd)
+    {
+        rc = solarisCheckUserAuth();
+        if (RT_FAILURE(rc))
+        {
+            Log(("DVD: solarisCheckUserAuth failed. Permission denied!\n"));
+            return rc;
+        }
+    }
+#endif /* VBOX_WITH_SUID_WRAPPER */
+
+    char *pszBlockDevName = getfullblkname(pThis->pszDevice);
+    if (!pszBlockDevName)
+        return VERR_NO_MEMORY;
+    pThis->pszDeviceOpen = RTStrDup(pszBlockDevName);  /* for RTStrFree() */
+    free(pszBlockDevName);
+    pThis->Os.pszRawDeviceOpen = RTStrDup(pThis->pszDevice);
+    if (!pThis->pszDeviceOpen || !pThis->Os.pszRawDeviceOpen);
+        return VERR_NO_MEMORY;
+
+    unsigned fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE)
+                    | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK;
+    int rc = RTFileOpen(&pThis->Os.hFileDevice, pThis->pszDeviceOpen, fFlags);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTFileOpen(&pThis->Os.hFileRawDevice, pThis->Os.pszRawDeviceOpen, fFlags);
+        if (RT_SUCCESS(rc))
+            return rc;
+
+        LogRel(("DVD: failed to open device %s rc=%Rrc\n", pThis->Os.pszRawDeviceOpen, rc));
+        RTFileClose(pThis->Os.hFileDevice);
+    }
+    else
+        LogRel(("DVD: failed to open device %s rc=%Rrc\n", pThis->pszDeviceOpen, rc));
+    return rc;
+}
+
+
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis)
+{
+    RT_NOREF(pThis);
+    return VINF_SUCCESS;
+}
+
+
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis)
+{
+    if (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
+        return true;
+
+    AssertMsgFailed(("Solaris supports only CD/DVD host drive access\n"));
+    return false;
 }
 
@@ -266 +362 @@
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->EventPoller != NULL)
-    {
-        RTSemEventDestroy(pThis->EventPoller);
-        pThis->EventPoller = NULL;
-    }
-
-    if (pThis->hFileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pThis->hFileDevice);
+    /*
+     * Unlock the drive if we've locked it or we're in passthru mode.
+     */
+    if (    pThis->fLocked
+        &&  pThis->Os.hFileDevice != NIL_RTFILE
+        &&  pThis->pfnDoLock)
+    {
+        int rc = pThis->pfnDoLock(pThis, false);
+        if (RT_SUCCESS(rc))
+            pThis->fLocked = false;
+    }
+
+    if (pThis->Os.hFileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->Os.hFileDevice);
         AssertRC(rc);
-        pThis->hFileDevice = NIL_RTFILE;
-    }
-
-    if (pThis->hFileRawDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pThis->hFileRawDevice);
+        pThis->Os.hFileDevice = NIL_RTFILE;
+    }
+
+    if (pThis->Os.hFileRawDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->Os.hFileRawDevice);
         AssertRC(rc);
-        pThis->hFileRawDevice = NIL_RTFILE;
-    }
-
-    if (pThis->pszRawDeviceOpen)
-    {
-        RTStrFree(pThis->pszRawDeviceOpen);
-        pThis->pszRawDeviceOpen = NULL;
-    }
-}
-
+        pThis->Os.hFileRawDevice = NIL_RTFILE;
+    }
+
+    if (pThis->Os.pszRawDeviceOpen)
+    {
+        RTStrFree(pThis->Os.pszRawDeviceOpen);
+        pThis->Os.pszRawDeviceOpen = NULL;
+    }
+}
+

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

@@ -77 +77 @@
         /*IN*/ FS_INFORMATION_CLASS FileSystemInformationClass );
 
+#include <iprt/ctype.h>
 #include <iprt/file.h>
 #include <VBox/scsi.h>
 
+/**
+ * Host backend specific data.
+ */
+typedef struct DRVHOSTBASEOS
+{
+    /** The filehandle of the device. */
+    RTFILE                  hFileDevice;
+    /** Handle to the window we use to catch the device change broadcast messages. */
+    volatile HWND           hwndDeviceChange;
+    /** The unit mask. */
+    DWORD                   fUnitMask;
+    /** Handle of the poller thread. */
+    RTTHREAD                hThrdMediaChange;
+} DRVHOSTBASEOS;
+/** Pointer to the host backend specific data. */
+typedef DRVHOSTBASEOS *PDRVHOSBASEOS;
+AssertCompile(sizeof(DRVHOSTBASEOS) <= 64);
+
+#define DRVHOSTBASE_OS_INT_DECLARED
 #include "DrvHostBase.h"
+
+
+/**
+ * Window procedure for the invisible window used to catch the WM_DEVICECHANGE broadcasts.
+ */
+static LRESULT CALLBACK DeviceChangeWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    Log2(("DeviceChangeWindowProc: hwnd=%08x uMsg=%08x\n", hwnd, uMsg));
+    if (uMsg == WM_DESTROY)
+    {
+        PDRVHOSTBASE pThis = (PDRVHOSTBASE)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+        if (pThis)
+            ASMAtomicXchgSize(&pThis->Os.hwndDeviceChange, NULL);
+        PostQuitMessage(0);
+    }
+
+    if (uMsg != WM_DEVICECHANGE)
+        return DefWindowProc(hwnd, uMsg, wParam, lParam);
+
+    PDEV_BROADCAST_HDR  lpdb = (PDEV_BROADCAST_HDR)lParam;
+    PDRVHOSTBASE        pThis = (PDRVHOSTBASE)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+    Assert(pThis);
+    if (pThis == NULL)
+        return 0;
+
+    switch (wParam)
+    {
+        case DBT_DEVICEARRIVAL:
+        case DBT_DEVICEREMOVECOMPLETE:
+            // Check whether a CD or DVD was inserted into or removed from a drive.
+            if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
+            {
+                PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;
+                if (    (lpdbv->dbcv_flags & DBTF_MEDIA)
+                    &&  (pThis->Os.fUnitMask & lpdbv->dbcv_unitmask))
+                {
+                    RTCritSectEnter(&pThis->CritSect);
+                    if (wParam == DBT_DEVICEARRIVAL)
+                    {
+                        int cRetries = 10;
+                        int rc = DRVHostBaseMediaPresent(pThis);
+                        while (RT_FAILURE(rc) && cRetries-- > 0)
+                        {
+                            RTThreadSleep(50);
+                            rc = DRVHostBaseMediaPresent(pThis);
+                        }
+                    }
+                    else
+                        DRVHostBaseMediaNotPresent(pThis);
+                    RTCritSectLeave(&pThis->CritSect);
+                }
+            }
+            break;
+    }
+    return TRUE;
+}
+
+
+/**
+ * This thread will wait for changed media notificatons.
+ *
+ * @returns Ignored.
+ * @param   ThreadSelf  Handle of this thread. Ignored.
+ * @param   pvUser      Pointer to the driver instance structure.
+ */
+static DECLCALLBACK(int) drvHostBaseMediaThreadWin(RTTHREAD ThreadSelf, void *pvUser)
+{
+    PDRVHOSTBASE pThis = (PDRVHOSTBASE)pvUser;
+    LogFlow(("%s-%d: drvHostBaseMediaThreadWin: ThreadSelf=%p pvUser=%p\n",
+             pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, ThreadSelf, pvUser));
+    static WNDCLASS s_classDeviceChange = {0};
+    static ATOM     s_hAtomDeviceChange = 0;
+
+    /*
+     * Register custom window class.
+     */
+    if (s_hAtomDeviceChange == 0)
+    {
+        memset(&s_classDeviceChange, 0, sizeof(s_classDeviceChange));
+        s_classDeviceChange.lpfnWndProc   = DeviceChangeWindowProc;
+        s_classDeviceChange.lpszClassName = "VBOX_DeviceChangeClass";
+        s_classDeviceChange.hInstance     = GetModuleHandle("VBoxDD.dll");
+        Assert(s_classDeviceChange.hInstance);
+        s_hAtomDeviceChange = RegisterClassA(&s_classDeviceChange);
+        Assert(s_hAtomDeviceChange);
+    }
+
+    /*
+     * Create Window w/ the pThis as user data.
+     */
+    HWND hwnd = CreateWindow((LPCTSTR)s_hAtomDeviceChange, "", WS_POPUP, 0, 0, 0, 0, 0, 0, s_classDeviceChange.hInstance, 0);
+    AssertMsg(hwnd, ("CreateWindow failed with %d\n", GetLastError()));
+    SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
+
+    /*
+     * Signal the waiting EMT thread that everything went fine.
+     */
+    ASMAtomicXchgPtr((void * volatile *)&pThis->Os.hwndDeviceChange, hwnd);
+    RTThreadUserSignal(ThreadSelf);
+    if (!hwnd)
+    {
+        LogFlow(("%s-%d: drvHostBaseMediaThreadWin: returns VERR_GENERAL_FAILURE\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
+        return VERR_GENERAL_FAILURE;
+    }
+    LogFlow(("%s-%d: drvHostBaseMediaThreadWin: Created hwndDeviceChange=%p\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, hwnd));
+
+    /*
+     * Message pump.
+     */
+    MSG         Msg;
+    BOOL        fRet;
+    while ((fRet = GetMessage(&Msg, NULL, 0, 0)) != FALSE)
+    {
+        if (fRet != -1)
+        {
+            TranslateMessage(&Msg);
+            DispatchMessage(&Msg);
+        }
+        //else: handle the error and possibly exit
+    }
+    Assert(!pThis->Os.hwndDeviceChange);
+    /* (Don't clear the thread handle here, the destructor thread is using it to wait.) */
+    LogFlow(("%s-%d: drvHostBaseMediaThreadWin: returns VINF_SUCCESS\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
+    return VINF_SUCCESS;
+}
+
 
 DECLHIDDEN(int) drvHostBaseScsiCmdOs(PDRVHOSTBASE pThis, const uint8_t *pbCmd, size_t cbCmd, PDMMEDIATXDIR enmTxDir,
@@ -139 +285 @@
     Req.spt.SenseInfoLength = (UCHAR)RT_MIN(sizeof(Req.aSense), cbSense);
     Req.spt.SenseInfoOffset = RT_OFFSETOF(struct _REQ, aSense);
-    if (DeviceIoControl((HANDLE)RTFileToNative(pThis->hFileDevice), IOCTL_SCSI_PASS_THROUGH_DIRECT,
+    if (DeviceIoControl((HANDLE)RTFileToNative(pThis->Os.hFileDevice), IOCTL_SCSI_PASS_THROUGH_DIRECT,
                         &Req, sizeof(Req), &Req, sizeof(Req), &cbReturned, NULL))
     {
@@ -171 +317 @@
 
         memset(&geom, 0, sizeof(geom));
-        rc = DeviceIoControl((HANDLE)RTFileToNative(pThis->hFileDevice), IOCTL_DISK_GET_DRIVE_GEOMETRY,
+        rc = DeviceIoControl((HANDLE)RTFileToNative(pThis->Os.hFileDevice), IOCTL_DISK_GET_DRIVE_GEOMETRY,
                              NULL, 0, &geom, sizeof(geom), &cbBytesReturned,  NULL);
         if (rc) {
@@ -194 +340 @@
         IO_STATUS_BLOCK             IoStatusBlock = {0};
         FILE_FS_SIZE_INFORMATION    FsSize= {0};
-        NTSTATUS rcNt = NtQueryVolumeInformationFile((HANDLE)RTFileToNative(pThis->hFileDevice),  &IoStatusBlock,
+        NTSTATUS rcNt = NtQueryVolumeInformationFile((HANDLE)RTFileToNative(pThis->Os.hFileDevice),  &IoStatusBlock,
                                                      &FsSize, sizeof(FsSize), FileFsSizeInformation);
         int cRetries = 5;
@@ -200 +346 @@
         {
             RTThreadSleep(10);
-            rcNt = NtQueryVolumeInformationFile((HANDLE)RTFileToNative(pThis->hFileDevice),  &IoStatusBlock,
+            rcNt = NtQueryVolumeInformationFile((HANDLE)RTFileToNative(pThis->Os.hFileDevice),  &IoStatusBlock,
                                                 &FsSize, sizeof(FsSize), FileFsSizeInformation);
         }
@@ -224 +370 @@
 DECLHIDDEN(int) drvHostBaseReadOs(PDRVHOSTBASE pThis, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    return RTFileReadAt(pThis->hFileDevice, off, pvBuf, cbRead, NULL);
+    return RTFileReadAt(pThis->Os.hFileDevice, off, pvBuf, cbRead, NULL);
 }
 
@@ -230 +376 @@
 DECLHIDDEN(int) drvHostBaseWriteOs(PDRVHOSTBASE pThis, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    return RTFileWriteAt(pThis->hFileDevice, off, pvBuf, cbWrite, NULL);
+    return RTFileWriteAt(pThis->Os.hFileDevice, off, pvBuf, cbWrite, NULL);
 }
 
@@ -236 +382 @@
 DECLHIDDEN(int) drvHostBaseFlushOs(PDRVHOSTBASE pThis)
 {
-    return RTFileFlush(pThis->hFileDevice);
+    return RTFileFlush(pThis->Os.hFileDevice);
 }
 
@@ -245 +391 @@
     DWORD cbReturned;
     int rc;
-    if (DeviceIoControl((HANDLE)RTFileToNative(pThis->hFileDevice), IOCTL_STORAGE_MEDIA_REMOVAL,
+    if (DeviceIoControl((HANDLE)RTFileToNative(pThis->Os.hFileDevice), IOCTL_STORAGE_MEDIA_REMOVAL,
                         &PreventMediaRemoval, sizeof(PreventMediaRemoval),
                         NULL, 0, &cbReturned,
@@ -261 +407 @@
 {
     int rc = VINF_SUCCESS;
-    RTFILE hFileDevice = pThis->hFileDevice;
+    RTFILE hFileDevice = pThis->Os.hFileDevice;
     if (hFileDevice == NIL_RTFILE) /* obsolete crap */
         rc = RTFileOpen(&hFileDevice, pThis->pszDeviceOpen, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
@@ -277 +423 @@
 
         /* clean up handle */
-        if (hFileDevice != pThis->hFileDevice)
+        if (hFileDevice != pThis->Os.hFileDevice)
             RTFileClose(hFileDevice);
     }
@@ -287 +433 @@
 
 
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis)
+{
+    pThis->Os.hFileDevice      = NIL_RTFILE;
+    pThis->Os.hwndDeviceChange = NULL;
+    pThis->Os.hThrdMediaChange = NIL_RTTHREAD;
+}
+
+
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly)
+{
+    UINT uDriveType = GetDriveType(pThis->pszDevice);
+    switch (pThis->enmType)
+    {
+        case PDMMEDIATYPE_FLOPPY_360:
+        case PDMMEDIATYPE_FLOPPY_720:
+        case PDMMEDIATYPE_FLOPPY_1_20:
+        case PDMMEDIATYPE_FLOPPY_1_44:
+        case PDMMEDIATYPE_FLOPPY_2_88:
+        case PDMMEDIATYPE_FLOPPY_FAKE_15_6:
+        case PDMMEDIATYPE_FLOPPY_FAKE_63_5:
+            if (uDriveType != DRIVE_REMOVABLE)
+            {
+                AssertMsgFailed(("Configuration error: '%s' is not a floppy (type=%d)\n",
+                                 pThis->pszDevice, uDriveType));
+                return VERR_INVALID_PARAMETER;
+            }
+            break;
+        case PDMMEDIATYPE_CDROM:
+        case PDMMEDIATYPE_DVD:
+            if (uDriveType != DRIVE_CDROM)
+            {
+                AssertMsgFailed(("Configuration error: '%s' is not a cdrom (type=%d)\n",
+                                 pThis->pszDevice, uDriveType));
+                return VERR_INVALID_PARAMETER;
+            }
+            break;
+        case PDMMEDIATYPE_HARD_DISK:
+        default:
+            AssertMsgFailed(("enmType=%d\n", pThis->enmType));
+            return VERR_INVALID_PARAMETER;
+    }
+
+    int iBit = RT_C_TO_UPPER(pThis->pszDevice[0]) - 'A';
+    if (    iBit > 'Z' - 'A'
+        ||  pThis->pszDevice[1] != ':'
+        ||  pThis->pszDevice[2])
+    {
+        AssertMsgFailed(("Configuration error: Invalid drive specification: '%s'\n", pThis->pszDevice));
+        return VERR_INVALID_PARAMETER;
+    }
+    pThis->Os.fUnitMask = 1 << iBit;
+    RTStrAPrintf(&pThis->pszDeviceOpen, "\\\\.\\%s", pThis->pszDevice);
+    if (!pThis->pszDeviceOpen)
+        return VERR_NO_MEMORY;
+
+    uint32_t fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE) | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
+    int rc = RTFileOpen(&pThis->Os.hFileDevice, pThis->pszDeviceOpen, fFlags);
+
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Start the thread which will wait for the media change events.
+         */
+        rc = RTThreadCreate(&pThis->Os.hThrdMediaChange, drvHostBaseMediaThreadWin, pThis, 0,
+                            RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "DVDMEDIA");
+        if (RT_FAILURE(rc))
+        {
+            AssertMsgFailed(("Failed to create poller thread. rc=%Rrc\n", rc));
+            return rc;
+        }
+
+        /*
+         * Wait for the thread to start up (!w32:) and do one detection loop.
+         */
+        rc = RTThreadUserWait(pThis->Os.hThrdMediaChange, 10000);
+        AssertRC(rc);
+
+        if (!pThis->Os.hwndDeviceChange)
+            return VERR_GENERAL_FAILURE;
+
+        DRVHostBaseMediaPresent(pThis);
+    }
+
+    return rc;
+}
+
+
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis)
+{
+    RT_NOREF(pThis);
+    return VINF_SUCCESS;
+}
+
+
 DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->hwndDeviceChange)
-        PostMessage(pThis->hwndDeviceChange, WM_CLOSE, 0, 0); /* default win proc will destroy the window */
+    if (pThis->Os.hwndDeviceChange)
+        PostMessage(pThis->Os.hwndDeviceChange, WM_CLOSE, 0, 0); /* default win proc will destroy the window */
 
     return VINF_SUCCESS;
@@ -296 +536 @@
 
 
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis)
+{
+    /* For Windows we alwys use an internal approach. */
+    RT_NOREF(pThis);
+    return false;
+}
+
+
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis)
 {
-    if (pThis->hwndDeviceChange)
-    {
-        if (SetWindowLongPtr(pThis->hwndDeviceChange, GWLP_USERDATA, 0) == (LONG_PTR)pThis)
-            PostMessage(pThis->hwndDeviceChange, WM_CLOSE, 0, 0); /* default win proc will destroy the window */
-        pThis->hwndDeviceChange = NULL;
-    }
-
-    if (pThis->hFileDevice != NIL_RTFILE)
-    {
-        int rc = RTFileClose(pThis->hFileDevice);
+    /*
+     * Unlock the drive if we've locked it or we're in passthru mode.
+     */
+    if (    pThis->fLocked
+        &&  pThis->Os.hFileDevice != NIL_RTFILE
+        &&  pThis->pfnDoLock)
+    {
+        int rc = pThis->pfnDoLock(pThis, false);
+        if (RT_SUCCESS(rc))
+            pThis->fLocked = false;
+    }
+
+    if (pThis->Os.hwndDeviceChange)
+    {
+        if (SetWindowLongPtr(pThis->Os.hwndDeviceChange, GWLP_USERDATA, 0) == (LONG_PTR)pThis)
+            PostMessage(pThis->Os.hwndDeviceChange, WM_CLOSE, 0, 0); /* default win proc will destroy the window */
+        pThis->Os.hwndDeviceChange = NULL;
+    }
+
+    if (pThis->Os.hFileDevice != NIL_RTFILE)
+    {
+        int rc = RTFileClose(pThis->Os.hFileDevice);
         AssertRC(rc);
-        pThis->hFileDevice = NIL_RTFILE;
-    }
-}
-
+        pThis->Os.hFileDevice = NIL_RTFILE;
+    }
+}
+

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

@@ -21 +21 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_HOST_BASE
-#ifdef RT_OS_DARWIN
-# include <mach/mach.h>
-# include <Carbon/Carbon.h>
-# include <IOKit/IOKitLib.h>
-# include <IOKit/storage/IOStorageDeviceCharacteristics.h>
-# include <IOKit/scsi/SCSITaskLib.h>
-# include <IOKit/scsi/SCSICommandOperationCodes.h>
-# include <IOKit/IOBSD.h>
-# include <DiskArbitration/DiskArbitration.h>
-# include <mach/mach_error.h>
-# include <VBox/scsi.h>
-
-#elif defined(RT_OS_L4)
-  /* Nothing special requires... yeah, right. */
-
-#elif defined(RT_OS_LINUX)
-# include <sys/ioctl.h>
-# include <sys/fcntl.h>
-# include <errno.h>
-
-#elif defined(RT_OS_SOLARIS)
-# include <fcntl.h>
-# include <errno.h>
-# include <stropts.h>
-# include <malloc.h>
-# include <sys/dkio.h>
-extern "C" char *getfullblkname(char *);
-
-#elif defined(RT_OS_WINDOWS)
-# define WIN32_NO_STATUS
-# include <iprt/win/windows.h>
-# include <dbt.h>
-# undef WIN32_NO_STATUS
-# include <ntstatus.h>
-
-/* from ntdef.h */
-typedef LONG NTSTATUS;
-
-/* from ntddk.h */
-typedef struct _IO_STATUS_BLOCK {
-    union {
-        NTSTATUS Status;
-        PVOID Pointer;
-    };
-    ULONG_PTR Information;
-} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
-
-
-/* from ntinternals.com */
-typedef enum _FS_INFORMATION_CLASS {
-    FileFsVolumeInformation=1,
-    FileFsLabelInformation,
-    FileFsSizeInformation,
-    FileFsDeviceInformation,
-    FileFsAttributeInformation,
-    FileFsControlInformation,
-    FileFsFullSizeInformation,
-    FileFsObjectIdInformation,
-    FileFsMaximumInformation
-} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
-
-typedef struct _FILE_FS_SIZE_INFORMATION {
-    LARGE_INTEGER   TotalAllocationUnits;
-    LARGE_INTEGER   AvailableAllocationUnits;
-    ULONG           SectorsPerAllocationUnit;
-    ULONG           BytesPerSector;
-} FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
-
-extern "C"
-NTSTATUS __stdcall NtQueryVolumeInformationFile(
-        /*IN*/ HANDLE               FileHandle,
-        /*OUT*/ PIO_STATUS_BLOCK    IoStatusBlock,
-        /*OUT*/ PVOID               FileSystemInformation,
-        /*IN*/ ULONG                Length,
-        /*IN*/ FS_INFORMATION_CLASS FileSystemInformationClass );
-
-#elif defined(RT_OS_FREEBSD)
-# include <sys/cdefs.h>
-# include <sys/param.h>
-# include <errno.h>
-# include <stdio.h>
-# include <cam/cam.h>
-# include <cam/cam_ccb.h>
-# include <cam/scsi/scsi_message.h>
-# include <cam/scsi/scsi_pass.h>
-# include <VBox/scsi.h>
-# include <iprt/log.h>
-#else
-# error "Unsupported Platform."
-#endif
 
 #include <VBox/vmm/pdmdrv.h>
@@ -136 +46 @@
 static DECLCALLBACK(int) drvHostBaseRead(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead)
 {
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: drvHostBaseRead: off=%#llx pvBuf=%p cbRead=%#x (%s)\n",
              pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, pvBuf, cbRead, pThis->pszDevice));
@@ -174 +84 @@
 static DECLCALLBACK(int) drvHostBaseWrite(PPDMIMEDIA pInterface, uint64_t off, const void *pvBuf, size_t cbWrite)
 {
-    RT_NOREF(off, pvBuf, cbWrite);
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: drvHostBaseWrite: off=%#llx pvBuf=%p cbWrite=%#x (%s)\n",
              pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, off, pvBuf, cbWrite, pThis->pszDevice));
@@ -216 +125 @@
 {
     int rc;
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: drvHostBaseFlush: (%s)\n",
              pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDevice));
@@ -235 +144 @@
 static DECLCALLBACK(bool) drvHostBaseIsReadOnly(PPDMIMEDIA pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     return pThis->fReadOnly;
 }
@@ -251 +160 @@
 static DECLCALLBACK(uint64_t) drvHostBaseGetSize(PPDMIMEDIA pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -267 +176 @@
 static DECLCALLBACK(PDMMEDIATYPE) drvHostBaseGetType(PPDMIMEDIA pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     LogFlow(("%s-%d: drvHostBaseGetType: returns %d\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->enmType));
     return pThis->enmType;
@@ -276 +185 @@
 static DECLCALLBACK(int) drvHostBaseGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
 {
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
 
     *pUuid = pThis->Uuid;
@@ -288 +197 @@
 static DECLCALLBACK(int) drvHostBaseGetPCHSGeometry(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry)
 {
-    PDRVHOSTBASE pThis =  PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -316 +225 @@
 static DECLCALLBACK(int) drvHostBaseSetPCHSGeometry(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry)
 {
-    PDRVHOSTBASE pThis =  PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    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));
@@ -340 +249 @@
 static DECLCALLBACK(int) drvHostBaseGetLCHSGeometry(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry)
 {
-    PDRVHOSTBASE pThis =  PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -368 +277 @@
 static DECLCALLBACK(int) drvHostBaseSetLCHSGeometry(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry)
 {
-    PDRVHOSTBASE pThis =  PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    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));
@@ -392 +301 @@
 static DECLCALLBACK(bool) drvHostBaseIsVisible(PPDMIMEDIA pInterface)
 {
-    PDRVHOSTBASE pThis =  PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     return pThis->fBiosVisible;
 }
@@ -405 +314 @@
     RT_NOREF(fEject);
     /* While we're not mountable (see drvHostBaseMount), we're unmountable. */
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMount);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -423 +332 @@
         }
 
+        if (fEject)
+        {
+            /*
+             * Eject the disc.
+             */
+            rc = drvHostBaseEjectOs(pThis);
+        }
+
         /*
          * Media is no longer present.
@@ -430 +347 @@
     else
     {
-        Log(("drvHostiBaseUnmount: Locked\n"));
+        Log(("drvHostBaseUnmount: Locked\n"));
         rc = VERR_PDM_MEDIA_LOCKED;
     }
@@ -443 +360 @@
 static DECLCALLBACK(bool) drvHostBaseIsMounted(PPDMIMOUNT pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMount);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -456 +373 @@
 static DECLCALLBACK(int) drvHostBaseLock(PPDMIMOUNT pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMount);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -479 +396 @@
 static DECLCALLBACK(int) drvHostBaseUnlock(PPDMIMOUNT pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMount);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -502 +419 @@
 static DECLCALLBACK(bool) drvHostBaseIsLocked(PPDMIMOUNT pInterface)
 {
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMount);
     RTCritSectEnter(&pThis->CritSect);
 
@@ -530 +447 @@
 
 /* -=-=-=-=- poller thread -=-=-=-=- */
-
-#ifdef RT_OS_DARWIN
-/** The runloop input source name for the disk arbitration events. */
-# define MY_RUN_LOOP_MODE    CFSTR("drvHostBaseDA") /** @todo r=bird: Check if this will cause trouble in the same way that the one in the USB code did. */
-
-/**
- * Gets the BSD Name (/dev/disc[0-9]+) for the service.
- *
- * This is done by recursing down the I/O registry until we hit upon an entry
- * with a BSD Name. Usually we find it two levels down. (Further down under
- * the IOCDPartitionScheme, the volume (slices) BSD Name is found. We don't
- * seem to have to go this far fortunately.)
- *
- * @return  VINF_SUCCESS if found, VERR_FILE_NOT_FOUND otherwise.
- * @param   Entry       The current I/O registry entry reference.
- * @param   pszName     Where to store the name. 128 bytes.
- * @param   cRecursions Number of recursions. This is used as an precaution
- *                      just to limit the depth and avoid blowing the stack
- *                      should we hit a bug or something.
- */
-static int drvHostBaseGetBSDName(io_registry_entry_t Entry, char *pszName, unsigned cRecursions)
-{
-    int rc = VERR_FILE_NOT_FOUND;
-    io_iterator_t Children = 0;
-    kern_return_t krc = IORegistryEntryGetChildIterator(Entry, kIOServicePlane, &Children);
-    if (krc == KERN_SUCCESS)
-    {
-        io_object_t Child;
-        while (     rc == VERR_FILE_NOT_FOUND
-               &&   (Child = IOIteratorNext(Children)) != 0)
-        {
-            CFStringRef BSDNameStrRef = (CFStringRef)IORegistryEntryCreateCFProperty(Child, CFSTR(kIOBSDNameKey), kCFAllocatorDefault, 0);
-            if (BSDNameStrRef)
-            {
-                if (CFStringGetCString(BSDNameStrRef, pszName, 128, kCFStringEncodingUTF8))
-                    rc = VINF_SUCCESS;
-                else
-                    AssertFailed();
-                CFRelease(BSDNameStrRef);
-            }
-            if (rc == VERR_FILE_NOT_FOUND && cRecursions < 10)
-                rc = drvHostBaseGetBSDName(Child, pszName, cRecursions + 1);
-            IOObjectRelease(Child);
-        }
-        IOObjectRelease(Children);
-    }
-    return rc;
-}
-
-
-/**
- * Callback notifying us that the async DADiskClaim()/DADiskUnmount call has completed.
- *
- * @param   DiskRef         The disk that was attempted claimed / unmounted.
- * @param   DissenterRef    NULL on success, contains details on failure.
- * @param   pvContext       Pointer to the return code variable.
- */
-static void drvHostBaseDADoneCallback(DADiskRef DiskRef, DADissenterRef DissenterRef, void *pvContext)
-{
-    RT_NOREF(DiskRef);
-    int *prc = (int *)pvContext;
-    if (!DissenterRef)
-        *prc = 0;
-    else
-        *prc = DADissenterGetStatus(DissenterRef) ? DADissenterGetStatus(DissenterRef) : -1;
-    CFRunLoopStop(CFRunLoopGetCurrent());
-}
-
-
-/**
- * Obtain exclusive access to the DVD device, umount it if necessary.
- *
- * @return  VBox status code.
- * @param   pThis       The driver instance.
- * @param   DVDService  The DVD service object.
- */
-static int drvHostBaseObtainExclusiveAccess(PDRVHOSTBASE pThis, io_object_t DVDService)
-{
-    PPDMDRVINS pDrvIns = pThis->pDrvIns; NOREF(pDrvIns);
-
-    for (unsigned iTry = 0;; iTry++)
-    {
-        IOReturn irc = (*pThis->ppScsiTaskDI)->ObtainExclusiveAccess(pThis->ppScsiTaskDI);
-        if (irc == kIOReturnSuccess)
-        {
-            /*
-             * This is a bit weird, but if we unmounted the DVD drive we also need to
-             * unlock it afterwards or the guest won't be able to eject it later on.
-             */
-            if (pThis->pDADisk)
-            {
-                uint8_t abCmd[16] =
-                {
-                    SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, 0, 0, 0, false, 0,
-                    0,0,0,0,0,0,0,0,0,0
-                };
-                drvHostBaseScsiCmdOs(pThis, abCmd, 6, PDMMEDIATXDIR_NONE, NULL, NULL, NULL, 0, 0);
-            }
-            return VINF_SUCCESS;
-        }
-        if (irc == kIOReturnExclusiveAccess)
-            return VERR_SHARING_VIOLATION;      /* already used exclusivly. */
-        if (irc != kIOReturnBusy)
-            return VERR_GENERAL_FAILURE;        /* not mounted */
-
-        /*
-         * Attempt to the unmount all volumes of the device.
-         * It seems we can can do this all in one go without having to enumerate the
-         * volumes (sessions) and deal with them one by one. This is very fortuitous
-         * as the disk arbitration API is a bit cumbersome to deal with.
-         */
-        if (iTry > 2)
-            return VERR_DRIVE_LOCKED;
-        char szName[128];
-        int rc = drvHostBaseGetBSDName(DVDService, &szName[0], 0);
-        if (RT_SUCCESS(rc))
-        {
-            pThis->pDASession = DASessionCreate(kCFAllocatorDefault);
-            if (pThis->pDASession)
-            {
-                DASessionScheduleWithRunLoop(pThis->pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
-                pThis->pDADisk = DADiskCreateFromBSDName(kCFAllocatorDefault, pThis->pDASession, szName);
-                if (pThis->pDADisk)
-                {
-                    /*
-                     * Try claim the device.
-                     */
-                    Log(("%s-%d: calling DADiskClaim on '%s'.\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
-                    int rcDA = -2;
-                    DADiskClaim(pThis->pDADisk, kDADiskClaimOptionDefault, NULL, NULL, drvHostBaseDADoneCallback, &rcDA);
-                    SInt32 rc32 = CFRunLoopRunInMode(MY_RUN_LOOP_MODE, 120.0, FALSE);
-                    AssertMsg(rc32 == kCFRunLoopRunStopped, ("rc32=%RI32 (%RX32)\n", rc32, rc32));
-                    if (    rc32 == kCFRunLoopRunStopped
-                        &&  !rcDA)
-                    {
-                        /*
-                         * Try unmount the device.
-                         */
-                        Log(("%s-%d: calling DADiskUnmount on '%s'.\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
-                        rcDA = -2;
-                        DADiskUnmount(pThis->pDADisk, kDADiskUnmountOptionWhole, drvHostBaseDADoneCallback, &rcDA);
-                        rc32 = CFRunLoopRunInMode(MY_RUN_LOOP_MODE, 120.0, FALSE);
-                        AssertMsg(rc32 == kCFRunLoopRunStopped, ("rc32=%RI32 (%RX32)\n", rc32, rc32));
-                        if (    rc32 == kCFRunLoopRunStopped
-                            &&  !rcDA)
-                        {
-                            iTry = 99;
-                            DASessionUnscheduleFromRunLoop(pThis->pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
-                            Log(("%s-%d: unmount succeed - retrying.\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
-                            continue;
-                        }
-                        Log(("%s-%d: umount => rc32=%d & rcDA=%#x\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc32, rcDA));
-
-                        /* failed - cleanup */
-                        DADiskUnclaim(pThis->pDADisk);
-                    }
-                    else
-                        Log(("%s-%d: claim => rc32=%d & rcDA=%#x\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc32, rcDA));
-
-                    CFRelease(pThis->pDADisk);
-                    pThis->pDADisk = NULL;
-                }
-                else
-                    Log(("%s-%d: failed to open disk '%s'!\n", pDrvIns->pReg->szName, pDrvIns->iInstance, szName));
-
-                DASessionUnscheduleFromRunLoop(pThis->pDASession, CFRunLoopGetCurrent(), MY_RUN_LOOP_MODE);
-                CFRelease(pThis->pDASession);
-                pThis->pDASession = NULL;
-            }
-            else
-                Log(("%s-%d: failed to create DA session!\n", pDrvIns->pReg->szName, pDrvIns->iInstance));
-        }
-        RTThreadSleep(10);
-    }
-}
-#endif /* RT_OS_DARWIN */
-
-
-#ifndef RT_OS_SOLARIS
-/**
- * Wrapper for open / RTFileOpen / IOKit.
- *
- * @remark  The Darwin code must correspond exactly to the enumeration
- *          done in Main/darwin/iokit.c.
- */
-static int drvHostBaseOpen(PDRVHOSTBASE pThis, PRTFILE pFileDevice, bool fReadOnly)
-{
-# ifdef RT_OS_DARWIN
-    RT_NOREF(fReadOnly);
-
-    /* Darwin is kind of special... */
-    Assert(!pFileDevice); NOREF(pFileDevice);
-    Assert(!pThis->cbBlock);
-    Assert(pThis->MasterPort == IO_OBJECT_NULL);
-    Assert(!pThis->ppMMCDI);
-    Assert(!pThis->ppScsiTaskDI);
-
-    /*
-     * Open the master port on the first invocation.
-     */
-    kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &pThis->MasterPort);
-    AssertReturn(krc == KERN_SUCCESS, VERR_GENERAL_FAILURE);
-
-    /*
-     * Create a matching dictionary for searching for CD, DVD and BlueRay services in the IOKit.
-     *
-     * The idea is to find all the devices which are of class IOCDBlockStorageDevice.
-     * CD devices are represented by IOCDBlockStorageDevice class itself, while DVD and BlueRay ones
-     * have it as a parent class.
-     */
-    CFMutableDictionaryRef RefMatchingDict = IOServiceMatching("IOCDBlockStorageDevice");
-    AssertReturn(RefMatchingDict, VERR_NOT_FOUND);
-
-    /*
-     * do the search and get a collection of keyboards.
-     */
-    io_iterator_t DVDServices = IO_OBJECT_NULL;
-    IOReturn irc = IOServiceGetMatchingServices(pThis->MasterPort, RefMatchingDict, &DVDServices);
-    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%d\n", irc), VERR_NOT_FOUND);
-    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
-
-    /*
-     * Enumerate the matching drives (services).
-     * (This enumeration must be identical to the one performed in Main/src-server/darwin/iokit.cpp.)
-     */
-    int rc = VERR_FILE_NOT_FOUND;
-    unsigned i = 0;
-    io_object_t DVDService;
-    while ((DVDService = IOIteratorNext(DVDServices)) != 0)
-    {
-        /*
-         * Get the properties we use to identify the DVD drive.
-         *
-         * While there is a (weird 12 byte) GUID, it isn't persistent
-         * across boots. So, we have to use a combination of the
-         * vendor name and product name properties with an optional
-         * sequence number for identification.
-         */
-        CFMutableDictionaryRef PropsRef = 0;
-        krc = IORegistryEntryCreateCFProperties(DVDService, &PropsRef, kCFAllocatorDefault, kNilOptions);
-        if (krc == KERN_SUCCESS)
-        {
-            /* Get the Device Characteristics dictionary. */
-            CFDictionaryRef DevCharRef = (CFDictionaryRef)CFDictionaryGetValue(PropsRef, CFSTR(kIOPropertyDeviceCharacteristicsKey));
-            if (DevCharRef)
-            {
-                /* The vendor name. */
-                char szVendor[128];
-                char *pszVendor = &szVendor[0];
-                CFTypeRef ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyVendorNameKey));
-                if (    ValueRef
-                    &&  CFGetTypeID(ValueRef) == CFStringGetTypeID()
-                    &&  CFStringGetCString((CFStringRef)ValueRef, szVendor, sizeof(szVendor), kCFStringEncodingUTF8))
-                    pszVendor = RTStrStrip(szVendor);
-                else
-                    *pszVendor = '\0';
-
-                /* The product name. */
-                char szProduct[128];
-                char *pszProduct = &szProduct[0];
-                ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyProductNameKey));
-                if (    ValueRef
-                    &&  CFGetTypeID(ValueRef) == CFStringGetTypeID()
-                    &&  CFStringGetCString((CFStringRef)ValueRef, szProduct, sizeof(szProduct), kCFStringEncodingUTF8))
-                    pszProduct = RTStrStrip(szProduct);
-                else
-                    *pszProduct = '\0';
-
-                /* Construct the two names and compare thwm with the one we're searching for. */
-                char szName1[256 + 32];
-                char szName2[256 + 32];
-                if (*pszVendor || *pszProduct)
-                {
-                    if (*pszVendor && *pszProduct)
-                    {
-                        RTStrPrintf(szName1, sizeof(szName1), "%s %s", pszVendor, pszProduct);
-                        RTStrPrintf(szName2, sizeof(szName2), "%s %s (#%u)", pszVendor, pszProduct, i);
-                    }
-                    else
-                    {
-                        strcpy(szName1, *pszVendor ? pszVendor : pszProduct);
-                        RTStrPrintf(szName2, sizeof(szName2), "%s (#%u)", *pszVendor ? pszVendor : pszProduct, i);
-                    }
-                }
-                else
-                {
-                    RTStrPrintf(szName1, sizeof(szName1), "(#%u)", i);
-                    strcpy(szName2, szName1);
-                }
-
-                if (    !strcmp(szName1, pThis->pszDeviceOpen)
-                    ||  !strcmp(szName2, pThis->pszDeviceOpen))
-                {
-                    /*
-                     * Found it! Now, get the client interface and stuff.
-                     * Note that we could also query kIOSCSITaskDeviceUserClientTypeID here if the
-                     * MMC client plugin is missing. For now we assume this won't be necessary.
-                     */
-                    SInt32 Score = 0;
-                    IOCFPlugInInterface **ppPlugInInterface = NULL;
-                    krc = IOCreatePlugInInterfaceForService(DVDService, kIOMMCDeviceUserClientTypeID, kIOCFPlugInInterfaceID,
-                                                            &ppPlugInInterface, &Score);
-                    if (krc == KERN_SUCCESS)
-                    {
-                        HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
-                                                                           CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),
-                                                                           (LPVOID *)&pThis->ppMMCDI);
-                        (*ppPlugInInterface)->Release(ppPlugInInterface);
-                        ppPlugInInterface = NULL;
-                        if (hrc == S_OK)
-                        {
-                            pThis->ppScsiTaskDI = (*pThis->ppMMCDI)->GetSCSITaskDeviceInterface(pThis->ppMMCDI);
-                            if (pThis->ppScsiTaskDI)
-                                rc = VINF_SUCCESS;
-                            else
-                            {
-                                LogRel(("GetSCSITaskDeviceInterface failed on '%s'\n", pThis->pszDeviceOpen));
-                                rc = VERR_NOT_SUPPORTED;
-                                (*pThis->ppMMCDI)->Release(pThis->ppMMCDI);
-                            }
-                        }
-                        else
-                        {
-                            rc = VERR_GENERAL_FAILURE;//RTErrConvertFromDarwinCOM(krc);
-                            pThis->ppMMCDI = NULL;
-                        }
-                    }
-                    else /* Check for kIOSCSITaskDeviceUserClientTypeID? */
-                        rc = VERR_GENERAL_FAILURE;//RTErrConvertFromDarwinKern(krc);
-
-                    /* Obtain exclusive access to the device so we can send SCSI commands. */
-                    if (RT_SUCCESS(rc))
-                        rc = drvHostBaseObtainExclusiveAccess(pThis, DVDService);
-
-                    /* Cleanup on failure. */
-                    if (RT_FAILURE(rc))
-                    {
-                        if (pThis->ppScsiTaskDI)
-                        {
-                            (*pThis->ppScsiTaskDI)->Release(pThis->ppScsiTaskDI);
-                            pThis->ppScsiTaskDI = NULL;
-                        }
-                        if (pThis->ppMMCDI)
-                        {
-                            (*pThis->ppMMCDI)->Release(pThis->ppMMCDI);
-                            pThis->ppMMCDI = NULL;
-                        }
-                    }
-
-                    IOObjectRelease(DVDService);
-                    break;
-                }
-            }
-            CFRelease(PropsRef);
-        }
-        else
-            AssertMsgFailed(("krc=%#x\n", krc));
-
-        IOObjectRelease(DVDService);
-        i++;
-    }
-
-    IOObjectRelease(DVDServices);
-    return rc;
-
-#elif defined(RT_OS_FREEBSD)
-    RTFILE hFileDevice;
-    int rc = RTFileOpen(&hFileDevice, pThis->pszDeviceOpen, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /*
-     * The current device handle can't passthrough SCSI commands.
-     * We have to get he passthrough device path and open this.
-     */
-    union ccb DeviceCCB;
-    memset(&DeviceCCB, 0, sizeof(DeviceCCB));
-
-    DeviceCCB.ccb_h.func_code = XPT_GDEVLIST;
-    int rcBSD = ioctl(RTFileToNative(hFileDevice), CAMGETPASSTHRU, &DeviceCCB);
-    if (!rcBSD)
-    {
-        char *pszPassthroughDevice = NULL;
-        rc = RTStrAPrintf(&pszPassthroughDevice, "/dev/%s%u",
-                          DeviceCCB.cgdl.periph_name, DeviceCCB.cgdl.unit_number);
-        if (rc >= 0)
-        {
-            RTFILE hPassthroughDevice;
-            rc = RTFileOpen(&hPassthroughDevice, pszPassthroughDevice, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
-            RTStrFree(pszPassthroughDevice);
-            if (RT_SUCCESS(rc))
-            {
-                /* Get needed device parameters. */
-
-                /*
-                 * The device path, target id and lun id. Those are
-                 * needed for the SCSI passthrough ioctl.
-                 */
-                memset(&DeviceCCB, 0, sizeof(DeviceCCB));
-                DeviceCCB.ccb_h.func_code = XPT_GDEVLIST;
-
-                rcBSD = ioctl(RTFileToNative(hPassthroughDevice), CAMGETPASSTHRU, &DeviceCCB);
-                if (!rcBSD)
-                {
-                    if (DeviceCCB.cgdl.status != CAM_GDEVLIST_ERROR)
-                    {
-                        pThis->ScsiBus      = DeviceCCB.ccb_h.path_id;
-                        pThis->ScsiTargetID = DeviceCCB.ccb_h.target_id;
-                        pThis->ScsiLunID    = DeviceCCB.ccb_h.target_lun;
-                        *pFileDevice = hPassthroughDevice;
-                    }
-                    else
-                    {
-                        /* The passthrough device wasn't found. */
-                        rc = VERR_NOT_FOUND;
-                    }
-                }
-                else
-                    rc = RTErrConvertFromErrno(errno);
-
-                if (RT_FAILURE(rc))
-                    RTFileClose(hPassthroughDevice);
-            }
-        }
-        else
-            rc = VERR_NO_STR_MEMORY;
-    }
-    else
-        rc = RTErrConvertFromErrno(errno);
-
-    RTFileClose(hFileDevice);
-    return rc;
-
-#else
-    uint32_t fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE) | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;
-# ifdef RT_OS_LINUX
-    fFlags |= RTFILE_O_NON_BLOCK;
-# endif
-    return RTFileOpen(pFileDevice, pThis->pszDeviceOpen, fFlags);
-#endif
-}
-
-#else   /* RT_OS_SOLARIS */
-
-/**
- * Solaris wrapper for RTFileOpen.
- *
- * Solaris has to deal with two filehandles, a block and a raw one. Rather than messing
- * with drvHostBaseOpen's function signature & body, having a separate one is better.
- *
- * @returns VBox status code.
- */
-static int drvHostBaseOpen(PDRVHOSTBASE pThis, PRTFILE pFileBlockDevice, PRTFILE pFileRawDevice, bool fReadOnly)
-{
-    unsigned fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE)
-                    | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK;
-    int rc = RTFileOpen(pFileBlockDevice, pThis->pszDeviceOpen, fFlags);
-    if (RT_SUCCESS(rc))
-    {
-        rc = RTFileOpen(pFileRawDevice, pThis->pszRawDeviceOpen, fFlags);
-        if (RT_SUCCESS(rc))
-            return rc;
-
-        LogRel(("DVD: failed to open device %s rc=%Rrc\n", pThis->pszRawDeviceOpen, rc));
-        RTFileClose(*pFileBlockDevice);
-    }
-    else
-        LogRel(("DVD: failed to open device %s rc=%Rrc\n", pThis->pszDeviceOpen, rc));
-    return rc;
-}
-#endif  /* RT_OS_SOLARIS */
-
-
-/**
- * (Re)opens the device.
- *
- * This is used to open the device during construction, but it's also used to re-open
- * the device when a media is inserted. This re-open will kill off any cached data
- * that Linux for some peculiar reason thinks should survive a media change...
- *
- * @returns VBOX status code.
- * @param   pThis       Instance data.
- */
-static int drvHostBaseReopen(PDRVHOSTBASE pThis)
-{
-#ifndef RT_OS_DARWIN /* Only *one* open for darwin. */
-    LogFlow(("%s-%d: drvHostBaseReopen: '%s'\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDeviceOpen));
-
-    RTFILE hFileDevice;
-#ifdef RT_OS_SOLARIS
-    if (pThis->hFileRawDevice != NIL_RTFILE)
-    {
-        RTFileClose(pThis->hFileRawDevice);
-        pThis->hFileRawDevice = NIL_RTFILE;
-    }
-    if (pThis->hFileDevice != NIL_RTFILE)
-    {
-        RTFileClose(pThis->hFileDevice);
-        pThis->hFileDevice = NIL_RTFILE;
-    }
-    RTFILE hFileRawDevice;
-    int rc = drvHostBaseOpen(pThis, &hFileDevice, &hFileRawDevice, pThis->fReadOnlyConfig);
-#else
-    int rc = drvHostBaseOpen(pThis, &hFileDevice, pThis->fReadOnlyConfig);
-#endif
-    if (RT_FAILURE(rc))
-    {
-        if (!pThis->fReadOnlyConfig)
-        {
-            LogFlow(("%s-%d: drvHostBaseReopen: '%s' - retry readonly (%Rrc)\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDeviceOpen, rc));
-#ifdef RT_OS_SOLARIS
-            rc = drvHostBaseOpen(pThis, &hFileDevice, &hFileRawDevice, false);
-#else
-            rc = drvHostBaseOpen(pThis, &hFileDevice, false);
-#endif
-        }
-        if (RT_FAILURE(rc))
-        {
-            LogFlow(("%s-%d: failed to open device '%s', rc=%Rrc\n",
-                     pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, pThis->pszDevice, rc));
-            return rc;
-        }
-        pThis->fReadOnly = true;
-    }
-    else
-        pThis->fReadOnly = pThis->fReadOnlyConfig;
-
-#ifdef RT_OS_SOLARIS
-    if (pThis->hFileRawDevice != NIL_RTFILE)
-        RTFileClose(pThis->hFileRawDevice);
-    pThis->hFileRawDevice = hFileRawDevice;
-#endif
-
-    if (pThis->hFileDevice != NIL_RTFILE)
-        RTFileClose(pThis->hFileDevice);
-    pThis->hFileDevice = hFileDevice;
-#else  /* RT_OS_DARWIN */
-    RT_NOREF(pThis);
-#endif /* RT_OS_DARWIN */
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Queries the media size.
- *
- * @returns VBox status code.
- * @param   pThis       Pointer to the instance data.
- * @param   pcb         Where to store the media size in bytes.
- */
-static DECLCALLBACK(int) drvHostBaseGetMediaSize(PDRVHOSTBASE pThis, uint64_t *pcb)
-{
-    return drvHostBaseGetMediaSizeOs(pThis, pcb);
-}
 
 
@@ -1092 +455 @@
  * @param   pThis   The instance data.
  */
-int DRVHostBaseMediaPresent(PDRVHOSTBASE pThis)
+DECLHIDDEN(int) DRVHostBaseMediaPresent(PDRVHOSTBASE pThis)
 {
     /*
      * Open the drive.
      */
-    int rc = drvHostBaseReopen(pThis);
+    int rc = drvHostBaseMediaRefreshOs(pThis);
     if (RT_FAILURE(rc))
         return rc;
@@ -1105 +468 @@
      */
     uint64_t cb;
-    rc = pThis->pfnGetMediaSize(pThis, &cb);
+    rc = drvHostBaseGetMediaSizeOs(pThis, &cb);
     if (RT_FAILURE(rc))
     {
@@ -1130 +493 @@
  * @param   pThis   The instance data.
  */
-void DRVHostBaseMediaNotPresent(PDRVHOSTBASE pThis)
+DECLHIDDEN(void) DRVHostBaseMediaNotPresent(PDRVHOSTBASE pThis)
 {
     pThis->fMediaPresent = false;
@@ -1145 +508 @@
 
 
-#ifdef RT_OS_WINDOWS
-
-/**
- * Window procedure for the invisible window used to catch the WM_DEVICECHANGE broadcasts.
- */
-static LRESULT CALLBACK DeviceChangeWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-{
-    Log2(("DeviceChangeWindowProc: hwnd=%08x uMsg=%08x\n", hwnd, uMsg));
-    if (uMsg == WM_DESTROY)
-    {
-        PDRVHOSTBASE pThis = (PDRVHOSTBASE)GetWindowLongPtr(hwnd, GWLP_USERDATA);
-        if (pThis)
-            ASMAtomicXchgSize(&pThis->hwndDeviceChange, NULL);
-        PostQuitMessage(0);
-    }
-
-    if (uMsg != WM_DEVICECHANGE)
-        return DefWindowProc(hwnd, uMsg, wParam, lParam);
-
-    PDEV_BROADCAST_HDR  lpdb = (PDEV_BROADCAST_HDR)lParam;
-    PDRVHOSTBASE        pThis = (PDRVHOSTBASE)GetWindowLongPtr(hwnd, GWLP_USERDATA);
-    Assert(pThis);
-    if (pThis == NULL)
-        return 0;
-
-    switch (wParam)
-    {
-        case DBT_DEVICEARRIVAL:
-        case DBT_DEVICEREMOVECOMPLETE:
-            // Check whether a CD or DVD was inserted into or removed from a drive.
-            if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
-            {
-                PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;
-                if (    (lpdbv->dbcv_flags & DBTF_MEDIA)
-                    &&  (pThis->fUnitMask & lpdbv->dbcv_unitmask))
-                {
-                    RTCritSectEnter(&pThis->CritSect);
-                    if (wParam == DBT_DEVICEARRIVAL)
-                    {
-                        int cRetries = 10;
-                        int rc = DRVHostBaseMediaPresent(pThis);
-                        while (RT_FAILURE(rc) && cRetries-- > 0)
-                        {
-                            RTThreadSleep(50);
-                            rc = DRVHostBaseMediaPresent(pThis);
-                        }
-                    }
-                    else
-                        DRVHostBaseMediaNotPresent(pThis);
-                    RTCritSectLeave(&pThis->CritSect);
-                }
-            }
-            break;
-    }
-    return TRUE;
-}
-
-#endif /* RT_OS_WINDOWS */
+static int drvHostBaseMediaPoll(PDRVHOSTBASE pThis)
+{
+    /*
+     * Poll for media change.
+     */
+    bool fMediaPresent = false;
+    bool fMediaChanged = false;
+    drvHostBaseQueryMediaStatusOs(pThis, &fMediaChanged, &fMediaPresent);
+
+    RTCritSectEnter(&pThis->CritSect);
+
+    int rc = VINF_SUCCESS;
+    if (pThis->fMediaPresent != fMediaPresent)
+    {
+        LogFlow(("drvHostDvdPoll: %d -> %d\n", pThis->fMediaPresent, fMediaPresent));
+        pThis->fMediaPresent = false;
+        if (fMediaPresent)
+            rc = DRVHostBaseMediaPresent(pThis);
+        else
+            DRVHostBaseMediaNotPresent(pThis);
+    }
+    else if (fMediaPresent)
+    {
+        /*
+         * Poll for media change.
+         */
+        if (fMediaChanged)
+        {
+            LogFlow(("drvHostDVDMediaThread: Media changed!\n"));
+            DRVHostBaseMediaNotPresent(pThis);
+            rc = DRVHostBaseMediaPresent(pThis);
+        }
+    }
+
+    RTCritSectLeave(&pThis->CritSect);
+    return rc;
+}
 
 
@@ -1217 +559 @@
     LogFlow(("%s-%d: drvHostBaseMediaThread: ThreadSelf=%p pvUser=%p\n",
              pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, ThreadSelf, pvUser));
-#ifdef RT_OS_WINDOWS
-    static WNDCLASS s_classDeviceChange = {0};
-    static ATOM     s_hAtomDeviceChange = 0;
-
-    /*
-     * Register custom window class.
-     */
-    if (s_hAtomDeviceChange == 0)
-    {
-        memset(&s_classDeviceChange, 0, sizeof(s_classDeviceChange));
-        s_classDeviceChange.lpfnWndProc   = DeviceChangeWindowProc;
-        s_classDeviceChange.lpszClassName = "VBOX_DeviceChangeClass";
-        s_classDeviceChange.hInstance     = GetModuleHandle("VBoxDD.dll");
-        Assert(s_classDeviceChange.hInstance);
-        s_hAtomDeviceChange = RegisterClassA(&s_classDeviceChange);
-        Assert(s_hAtomDeviceChange);
-    }
-
-    /*
-     * Create Window w/ the pThis as user data.
-     */
-    HWND hwnd = CreateWindow((LPCTSTR)s_hAtomDeviceChange, "", WS_POPUP, 0, 0, 0, 0, 0, 0, s_classDeviceChange.hInstance, 0);
-    AssertMsg(hwnd, ("CreateWindow failed with %d\n", GetLastError()));
-    SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
-
-    /*
-     * Signal the waiting EMT thread that everything went fine.
-     */
-    ASMAtomicXchgPtr((void * volatile *)&pThis->hwndDeviceChange, hwnd);
-    RTThreadUserSignal(ThreadSelf);
-    if (!hwnd)
-    {
-        LogFlow(("%s-%d: drvHostBaseMediaThread: returns VERR_GENERAL_FAILURE\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance));
-        return VERR_GENERAL_FAILURE;
-    }
-    LogFlow(("%s-%d: drvHostBaseMediaThread: Created hwndDeviceChange=%p\n", pThis->pDrvIns->pReg->szName, pThis->pDrvIns->iInstance, hwnd));
-
-    /*
-     * Message pump.
-     */
-    MSG         Msg;
-    BOOL        fRet;
-    while ((fRet = GetMessage(&Msg, NULL, 0, 0)) != FALSE)
-    {
-        if (fRet != -1)
-        {
-            TranslateMessage(&Msg);
-            DispatchMessage(&Msg);
-        }
-        //else: handle the error and possibly exit
-    }
-    Assert(!pThis->hwndDeviceChange);
-
-#else /* !RT_OS_WINDOWS */
     bool        fFirst = true;
     int         cRetries = 10;
@@ -1278 +566 @@
          * Perform the polling (unless we've run out of 50ms retries).
          */
-        if (    pThis->pfnPoll
-            &&  cRetries-- > 0)
-        {
-
-            int rc = pThis->pfnPoll(pThis);
+        if (cRetries-- > 0)
+        {
+
+            int rc = drvHostBaseMediaPoll(pThis);
             if (RT_FAILURE(rc))
             {
@@ -1313 +600 @@
         cRetries = 10;
     }
-
-#endif /* !RT_OS_WINDOWS */
 
     /* (Don't clear the thread handle here, the destructor thread is using it to wait.) */
@@ -1369 +654 @@
         do
         {
-            drvHostBasePollerWakeupOs(pThis);
+            RTSemEventSignal(pThis->EventPoller);
             rc = RTThreadWait(pThis->ThreadPoller, 100, NULL);
         } while (cTimes-- > 0 && rc == VERR_TIMEOUT);
@@ -1378 +663 @@
 
     /*
-     * Unlock the drive if we've locked it or we're in passthru mode.
-     */
-#ifdef RT_OS_DARWIN
-    if (    (   pThis->fLocked
-             || pThis->IMedia.pfnSendCmd)
-        &&  pThis->ppScsiTaskDI
-#else /** @todo Check if the other guys can mix pfnDoLock with scsi passthru.
-       * (We're currently not unlocking the device after use. See todo in DevATA.cpp.) */
-    if (    pThis->fLocked
-        &&  pThis->hFileDevice != NIL_RTFILE
-#endif
-        &&  pThis->pfnDoLock)
-    {
-        int rc = pThis->pfnDoLock(pThis, false);
-        if (RT_SUCCESS(rc))
-            pThis->fLocked = false;
-    }
-
-    /*
      * Cleanup the other resources.
      */
     drvHostBaseDestructOs(pThis);
+
+    if (pThis->EventPoller != NULL)
+    {
+        RTSemEventDestroy(pThis->EventPoller);
+        pThis->EventPoller = NULL;
+    }
 
     if (pThis->pszDevice)
@@ -1425 +697 @@
 
 /**
- * Initializes the instance data (init part 1).
- *
- * The driver which derives from this base driver will override function pointers after
- * calling this method, and complete the construction by calling DRVHostBaseInitFinish().
+ * Initializes the instance data .
  *
  * On failure call DRVHostBaseDestruct().
@@ -1434 +703 @@
  * @returns VBox status code.
  * @param   pDrvIns         Driver instance.
- * @param   pszCfgValid     Pointer to a string ofvalid CFGM options.
+ * @param   pszCfgValid     Pointer to a string of valid CFGM options.
  * @param   pCfg            Configuration handle.
  * @param   enmType         Device type.
  */
-int DRVHostBaseInitData(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, const char *pszCfgValid, PDMMEDIATYPE enmType)
-{
+DECLHIDDEN(int) DRVHostBaseInit(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, const char *pszCfgValid, PDMMEDIATYPE enmType)
+{
+    int src = VINF_SUCCESS;
     PDRVHOSTBASE pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTBASE);
-    LogFlow(("%s-%d: DRVHostBaseInitData: iInstance=%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance, pDrvIns->iInstance));
+    LogFlow(("%s-%d: DRVHostBaseInit: iInstance=%d\n", pDrvIns->pReg->szName, pDrvIns->iInstance, pDrvIns->iInstance));
 
     /*
@@ -1449 +719 @@
     pThis->fKeepInstance                    = false;
     pThis->ThreadPoller                     = NIL_RTTHREAD;
-#ifdef RT_OS_DARWIN
-    pThis->MasterPort                       = IO_OBJECT_NULL;
-    pThis->ppMMCDI                          = NULL;
-    pThis->ppScsiTaskDI                     = NULL;
-    pThis->cbBlock                          = 0;
-    pThis->pDADisk                          = NULL;
-    pThis->pDASession                       = NULL;
-#else
-    pThis->hFileDevice                      = NIL_RTFILE;
-#endif
-#ifdef RT_OS_SOLARIS
-    pThis->hFileRawDevice                   = NIL_RTFILE;
-#endif
     pThis->enmType                          = enmType;
-    //pThis->cErrors                          = 0;
     pThis->fAttachFailError                 = true; /* It's an error until we've read the config. */
-
-    pThis->pfnGetMediaSize                  = drvHostBaseGetMediaSize;
 
     /* IBase. */
@@ -1493 +747 @@
     pThis->IMount.pfnIsLocked               = drvHostBaseIsLocked;
 
+    drvHostBaseInitOs(pThis);
+
     if (!CFGMR3AreValuesValid(pCfg, pszCfgValid))
     {
@@ -1523 +779 @@
     /* Mountable */
     uint32_t u32;
-    rc = CFGMR3QueryU32(pCfg, "Interval", &u32);
+    rc = CFGMR3QueryU32Def(pCfg, "Interval", &u32, 1000);
     if (RT_SUCCESS(rc))
         pThis->cMilliesPoller = u32;
-    else if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pThis->cMilliesPoller = 1000;
-    else if (RT_FAILURE(rc))
+    else
     {
         AssertMsgFailed(("Configuration error: Query \"Mountable\" resulted in %Rrc.\n", rc));
@@ -1534 +788 @@
     }
 
-    /* ReadOnly */
-    rc = CFGMR3QueryBool(pCfg, "ReadOnly", &pThis->fReadOnlyConfig);
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pThis->fReadOnlyConfig = enmType == PDMMEDIATYPE_DVD || enmType == PDMMEDIATYPE_CDROM ? true : false;
-    else if (RT_FAILURE(rc))
-    {
-        AssertMsgFailed(("Configuration error: Query \"ReadOnly\" resulted in %Rrc.\n", rc));
-        return rc;
+    /* ReadOnly - passthrough mode requires read/write access in any case. */
+    if (   (pThis->enmType == PDMMEDIATYPE_CDROM || pThis->enmType == PDMMEDIATYPE_DVD)
+        && pThis->IMedia.pfnSendCmd)
+            pThis->fReadOnlyConfig = false;
+    else
+    {
+        rc = CFGMR3QueryBoolDef(pCfg, "ReadOnly", &pThis->fReadOnlyConfig,
+                                  enmType == PDMMEDIATYPE_DVD || enmType == PDMMEDIATYPE_CDROM
+                                ? true
+                                : false);
+        if (RT_FAILURE(rc))
+        {
+            AssertMsgFailed(("Configuration error: Query \"ReadOnly\" resulted in %Rrc.\n", rc));
+            return rc;
+        }
     }
 
     /* Locked */
-    rc = CFGMR3QueryBool(pCfg, "Locked", &pThis->fLocked);
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pThis->fLocked = false;
-    else if (RT_FAILURE(rc))
+    rc = CFGMR3QueryBoolDef(pCfg, "Locked", &pThis->fLocked, false);
+    if (RT_FAILURE(rc))
     {
         AssertMsgFailed(("Configuration error: Query \"Locked\" resulted in %Rrc.\n", rc));
@@ -1555 +814 @@
 
     /* BIOS visible */
-    rc = CFGMR3QueryBool(pCfg, "BIOSVisible", &pThis->fBiosVisible);
-    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
-        pThis->fBiosVisible = true;
-    else if (RT_FAILURE(rc))
+    rc = CFGMR3QueryBoolDef(pCfg, "BIOSVisible", &pThis->fBiosVisible, true);
+    if (RT_FAILURE(rc))
     {
         AssertMsgFailed(("Configuration error: Query \"BIOSVisible\" resulted in %Rrc.\n", rc));
@@ -1587 +844 @@
 
     /* Define whether attach failure is an error (default) or not. */
-    bool fAttachFailError;
-    rc = CFGMR3QueryBool(pCfg, "AttachFailError", &fAttachFailError);
-    if (RT_FAILURE(rc))
-        fAttachFailError = true;
+    bool fAttachFailError = true;
+    rc = CFGMR3QueryBoolDef(pCfg, "AttachFailError", &fAttachFailError, true);
     pThis->fAttachFailError = fAttachFailError;
-
-    /* name to open & watch for */
-#ifdef RT_OS_WINDOWS
-    int iBit = RT_C_TO_UPPER(pThis->pszDevice[0]) - 'A';
-    if (    iBit > 'Z' - 'A'
-        ||  pThis->pszDevice[1] != ':'
-        ||  pThis->pszDevice[2])
-    {
-        AssertMsgFailed(("Configuration error: Invalid drive specification: '%s'\n", pThis->pszDevice));
-        return VERR_INVALID_PARAMETER;
-    }
-    pThis->fUnitMask = 1 << iBit;
-    RTStrAPrintf(&pThis->pszDeviceOpen, "\\\\.\\%s", pThis->pszDevice);
-
-#elif defined(RT_OS_SOLARIS)
-    char *pszBlockDevName = getfullblkname(pThis->pszDevice);
-    if (!pszBlockDevName)
-        return VERR_NO_MEMORY;
-    pThis->pszDeviceOpen = RTStrDup(pszBlockDevName);  /* for RTStrFree() */
-    free(pszBlockDevName);
-    pThis->pszRawDeviceOpen = RTStrDup(pThis->pszDevice);
-
-#else
-    pThis->pszDeviceOpen = RTStrDup(pThis->pszDevice);
-#endif
-
-    if (!pThis->pszDeviceOpen)
-        return VERR_NO_MEMORY;
-
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Do the 2nd part of the init after the derived driver has overridden the defaults.
- *
- * On failure call DRVHostBaseDestruct().
- *
- * @returns VBox status code.
- * @param   pThis       Pointer to the instance data.
- */
-int DRVHostBaseInitFinish(PDRVHOSTBASE pThis)
-{
-    int src = VINF_SUCCESS;
-    PPDMDRVINS pDrvIns = pThis->pDrvIns;
 
     /* log config summary */
@@ -1653 +863 @@
      * Register saved state.
      */
-    int rc = PDMDrvHlpSSMRegisterLoadDone(pDrvIns, drvHostBaseLoadDone);
+    rc = PDMDrvHlpSSMRegisterLoadDone(pDrvIns, drvHostBaseLoadDone);
     if (RT_FAILURE(rc))
         return rc;
 
     /*
-     * Verify type.
-     */
-#ifdef RT_OS_WINDOWS
-    UINT uDriveType = GetDriveType(pThis->pszDevice);
-    switch (pThis->enmType)
-    {
-        case PDMMEDIATYPE_FLOPPY_360:
-        case PDMMEDIATYPE_FLOPPY_720:
-        case PDMMEDIATYPE_FLOPPY_1_20:
-        case PDMMEDIATYPE_FLOPPY_1_44:
-        case PDMMEDIATYPE_FLOPPY_2_88:
-        case PDMMEDIATYPE_FLOPPY_FAKE_15_6:
-        case PDMMEDIATYPE_FLOPPY_FAKE_63_5:
-            if (uDriveType != DRIVE_REMOVABLE)
-            {
-                AssertMsgFailed(("Configuration error: '%s' is not a floppy (type=%d)\n",
-                                 pThis->pszDevice, uDriveType));
-                return VERR_INVALID_PARAMETER;
-            }
-            break;
-        case PDMMEDIATYPE_CDROM:
-        case PDMMEDIATYPE_DVD:
-            if (uDriveType != DRIVE_CDROM)
-            {
-                AssertMsgFailed(("Configuration error: '%s' is not a cdrom (type=%d)\n",
-                                 pThis->pszDevice, uDriveType));
-                return VERR_INVALID_PARAMETER;
-            }
-            break;
-        case PDMMEDIATYPE_HARD_DISK:
-        default:
-            AssertMsgFailed(("enmType=%d\n", pThis->enmType));
-            return VERR_INVALID_PARAMETER;
-    }
-#endif
+     * Initialize the critical section used for serializing the access to the media.
+     */
+    rc = RTCritSectInit(&pThis->CritSect);
+    if (RT_FAILURE(rc))
+        return rc;
 
     /*
      * Open the device.
      */
-#if defined(RT_OS_DARWIN)
-    rc = drvHostBaseOpen(pThis, NULL, pThis->fReadOnlyConfig);
-#else
-    rc = drvHostBaseReopen(pThis);
-#endif
+    rc = drvHostBaseOpenOs(pThis, pThis->fReadOnlyConfig);
     if (RT_FAILURE(rc))
     {
@@ -1710 +886 @@
             && RT_SUCCESS(RTPathReal(pszDevice, szPathReal, sizeof(szPathReal))))
             pszDevice = szPathReal;
-        pThis->hFileDevice = NIL_RTFILE;
-#endif
-#ifdef RT_OS_SOLARIS
-        pThis->hFileRawDevice = NIL_RTFILE;
 #endif
 
@@ -1752 +924 @@
         }
     }
-#ifdef RT_OS_WINDOWS
-    if (RT_SUCCESS(src))
-        DRVHostBaseMediaPresent(pThis);
-#endif
 
     /*
@@ -1771 +939 @@
     }
 
-#ifndef RT_OS_WINDOWS
-    if (RT_SUCCESS(src))
+    if (RT_SUCCESS(src) && drvHostBaseIsMediaPollingRequiredOs(pThis))
     {
         /*
@@ -1780 +947 @@
         if (RT_FAILURE(rc))
             return rc;
-    }
-#endif
-
-    /*
-     * Initialize the critical section used for serializing the access to the media.
-     */
-    rc = RTCritSectInit(&pThis->CritSect);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    if (RT_SUCCESS(src))
-    {
+
         /*
          * Start the thread which will poll for the media.
@@ -1808 +964 @@
         rc = RTThreadUserWait(pThis->ThreadPoller, 10000);
         AssertRC(rc);
-#ifdef RT_OS_WINDOWS
-        if (!pThis->hwndDeviceChange)
-            return VERR_GENERAL_FAILURE;
-#endif
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (!pThis->fAttachFailError)
+        {
+            /* Suppressing the attach failure error must not affect the normal
+             * DRVHostBaseDestruct, so reset this flag below before leaving. */
+            pThis->fKeepInstance = true;
+            rc = VINF_SUCCESS;
+        }
+        DRVHostBaseDestruct(pDrvIns);
+        pThis->fKeepInstance = false;
     }
 
     if (RT_FAILURE(src))
         return src;
-    return rc;
-}
-
+
+    return rc;
+}
+

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

@@ -62 +62 @@
     /** Device name to open (RTStrFree). */
     char                   *pszDeviceOpen;
-#ifdef RT_OS_SOLARIS
-    /** Device name of raw device (RTStrFree). */
-    char                   *pszRawDeviceOpen;
-#endif
     /** Uuid of the drive. */
     RTUUID                  Uuid;
@@ -85 +81 @@
      * This is invalid if no drive is in the drive. */
     uint64_t volatile       cbSize;
-#if !defined(RT_OS_DARWIN)
-    /** The filehandle of the device. */
-    RTFILE                  hFileDevice;
-#endif
-#ifdef RT_OS_SOLARIS
-    /** The raw filehandle of the device. */
-    RTFILE                  hFileRawDevice;
-#endif
 
     /** Handle of the poller thread. */
     RTTHREAD                ThreadPoller;
-#ifndef RT_OS_WINDOWS
     /** Event semaphore the thread will wait on. */
     RTSEMEVENT              EventPoller;
-#endif
     /** The poller interval. */
     RTMSINTERVAL            cMilliesPoller;
@@ -109 +95 @@
     /** BIOS LCHS geometry. */
     PDMMEDIAGEOMETRY        LCHSGeometry;
-
-    /** The number of errors that could go into the release log. (flood gate) */
-    uint32_t                cLogRelErrors;
-
-#ifdef RT_OS_DARWIN
-    /** The master port. */
-    mach_port_t             MasterPort;
-    /** The MMC-2 Device Interface. (This is only used to get the scsi task interface.) */
-    MMCDeviceInterface    **ppMMCDI;
-    /** The SCSI Task Device Interface. */
-    SCSITaskDeviceInterface **ppScsiTaskDI;
-    /** The block size. Set when querying the media size. */
-    uint32_t                cbBlock;
-    /** The disk arbitration session reference. NULL if we didn't have to claim & unmount the device. */
-    DASessionRef            pDASession;
-    /** The disk arbitration disk reference. NULL if we didn't have to claim & unmount the device. */
-    DADiskRef               pDADisk;
-#endif
-
-#ifdef RT_OS_WINDOWS
-    /** Handle to the window we use to catch the device change broadcast messages. */
-    volatile HWND           hwndDeviceChange;
-    /** The unit mask. */
-    DWORD                   fUnitMask;
-#endif
-
-#ifdef RT_OS_LINUX
-    /** Double buffer required for ioctl with the Linux kernel as long as we use
-     * remap_pfn_range() instead of vm_insert_page(). */
-    uint8_t                *pbDoubleBuffer;
-#endif
-
-#ifdef RT_OS_FREEBSD
-    /** The block size. Set when querying the media size. */
-    uint32_t                cbBlock;
-    /** SCSI bus number. */
-    path_id_t               ScsiBus;
-    /** target ID of the passthrough device. */
-    target_id_t             ScsiTargetID;
-    /** LUN of the passthrough device. */
-    lun_id_t                ScsiLunID;
-#endif
 
     /**
@@ -163 +107 @@
     DECLCALLBACKMEMBER(int, pfnDoLock)(PDRVHOSTBASE pThis, bool fLock);
 
-    /**
-     * Queries the media size.
-     * Can also be used to perform actions on media change.
-     *
-     * This callback pointer should be set to NULL if the default action is fine for this device.
-     *
-     * @returns VBox status code.
-     * @param   pThis       Pointer to the instance data.
-     * @param   pcb         Where to store the media size in bytes.
-     */
-    DECLCALLBACKMEMBER(int, pfnGetMediaSize)(PDRVHOSTBASE pThis, uint64_t *pcb);
-
-    /***
-     * Performs the polling operation.
-     *
-     * @returns VBox status code. (Failure means retry.)
-     * @param   pThis       Pointer to the instance data.
-     */
-    DECLCALLBACKMEMBER(int, pfnPoll)(PDRVHOSTBASE pThis);
+    union
+    {
+#ifdef DRVHOSTBASE_OS_INT_DECLARED
+        DRVHOSTBASEOS       Os;
+#endif
+        uint8_t             abPadding[64];
+    };
 } DRVHOSTBASE;
 
 
-int DRVHostBaseInitData(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, const char *pszCfgValid, PDMMEDIATYPE enmType);
-int DRVHostBaseInitFinish(PDRVHOSTBASE pThis);
-int DRVHostBaseMediaPresent(PDRVHOSTBASE pThis);
-void DRVHostBaseMediaNotPresent(PDRVHOSTBASE pThis);
+DECLHIDDEN(int) DRVHostBaseInit(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, const char *pszCfgValid, PDMMEDIATYPE enmType);
+DECLHIDDEN(int) DRVHostBaseMediaPresent(PDRVHOSTBASE pThis);
+DECLHIDDEN(void) DRVHostBaseMediaNotPresent(PDRVHOSTBASE pThis);
 DECLCALLBACK(void) DRVHostBaseDestruct(PPDMDRVINS pDrvIns);
 
@@ -200 +131 @@
 DECLHIDDEN(int) drvHostBaseEjectOs(PDRVHOSTBASE pThis);
 
+DECLHIDDEN(void) drvHostBaseInitOs(PDRVHOSTBASE pThis);
+DECLHIDDEN(int) drvHostBaseOpenOs(PDRVHOSTBASE pThis, bool fReadOnly);
+DECLHIDDEN(int) drvHostBaseMediaRefreshOs(PDRVHOSTBASE pThis);
 DECLHIDDEN(int) drvHostBaseQueryMediaStatusOs(PDRVHOSTBASE pThis, bool *pfMediaChanged, bool *pfMediaPresent);
-DECLHIDDEN(int) drvHostBasePollerWakeupOs(PDRVHOSTBASE pThis);
+DECLHIDDEN(bool) drvHostBaseIsMediaPollingRequiredOs(PDRVHOSTBASE pThis);
 DECLHIDDEN(void) drvHostBaseDestructOs(PDRVHOSTBASE pThis);
-
-/** Makes a PDRVHOSTBASE out of a PPDMIMOUNT. */
-#define PDMIMOUNT_2_DRVHOSTBASE(pInterface)        ( (PDRVHOSTBASE)((uintptr_t)pInterface - RT_OFFSETOF(DRVHOSTBASE, IMount)) )
-
-/** Makes a PDRVHOSTBASE out of a PPDMIMEDIA. */
-#define PDMIMEDIA_2_DRVHOSTBASE(pInterface)        ( (PDRVHOSTBASE)((uintptr_t)pInterface - RT_OFFSETOF(DRVHOSTBASE, IMedia)) )
 
 RT_C_DECLS_END

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

@@ -21 +21 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_HOST_DVD
-#define __STDC_LIMIT_MACROS
-#define __STDC_CONSTANT_MACROS
+#if defined(RT_OS_DARWIN) || defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
+# define USE_MEDIA_POLLING
+#endif
 
-#ifdef RT_OS_DARWIN
-# include <mach/mach.h>
-# include <Carbon/Carbon.h>
-# include <IOKit/IOKitLib.h>
-# include <IOKit/IOCFPlugIn.h>
-# include <IOKit/scsi/SCSITaskLib.h>
-# include <IOKit/scsi/SCSICommandOperationCodes.h>
-# include <IOKit/storage/IOStorageDeviceCharacteristics.h>
-# include <mach/mach_error.h>
-# define USE_MEDIA_POLLING
-
-#elif defined RT_OS_LINUX
-# include <sys/ioctl.h>
-# include <linux/version.h>
-/* All the following crap is apparently not necessary anymore since Linux
- * version 2.6.29. */
-# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
-/* This is a hack to work around conflicts between these linux kernel headers
- * and the GLIBC tcpip headers. They have different declarations of the 4
- * standard byte order functions. */
-#  define _LINUX_BYTEORDER_GENERIC_H
-/* This is another hack for not bothering with C++ unfriendly byteswap macros. */
-/* Those macros that are needed are defined in the header below. */
-#  include "swab.h"
-# endif
-# include <linux/cdrom.h>
-# include <sys/fcntl.h>
-# include <errno.h>
-# include <limits.h>
-# include <iprt/mem.h>
-# define USE_MEDIA_POLLING
-
-#elif defined(RT_OS_SOLARIS)
-# include <stropts.h>
-# include <fcntl.h>
-# include <errno.h>
-# include <pwd.h>
-# include <unistd.h>
-# include <syslog.h>
-# ifdef VBOX_WITH_SUID_WRAPPER
-#  include <auth_attr.h>
-# endif
-# include <sys/dkio.h>
-# include <sys/sockio.h>
-# include <sys/scsi/scsi.h>
-# define USE_MEDIA_POLLING
-
-#elif defined(RT_OS_WINDOWS)
-# pragma warning(disable : 4163)
-# define _interlockedbittestandset      they_messed_it_up_in_winnt_h_this_time_sigh__interlockedbittestandset
-# define _interlockedbittestandreset    they_messed_it_up_in_winnt_h_this_time_sigh__interlockedbittestandreset
-# define _interlockedbittestandset64    they_messed_it_up_in_winnt_h_this_time_sigh__interlockedbittestandset64
-# define _interlockedbittestandreset64  they_messed_it_up_in_winnt_h_this_time_sigh__interlockedbittestandreset64
-# include <iprt/win/windows.h>
-# include <winioctl.h>
-# include <ntddscsi.h>
-# pragma warning(default : 4163)
-# undef _interlockedbittestandset
-# undef _interlockedbittestandreset
-# undef _interlockedbittestandset64
-# undef _interlockedbittestandreset64
-# undef USE_MEDIA_POLLING
-
-#elif defined(RT_OS_FREEBSD)
-# include <sys/cdefs.h>
-# include <sys/param.h>
-# include <stdio.h>
-# include <cam/cam.h>
-# include <cam/cam_ccb.h>
-# define USE_MEDIA_POLLING
-
-#else
-# error "Unsupported Platform."
+#if defined(RT_OS_SOLARIS) && defined(VBOX_WITH_SUID_WRAPPER)
+# include <auth_attr.h>
 #endif
 
@@ -117 +47 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int) drvHostDvdDoLock(PDRVHOSTBASE pThis, bool fLock);
-
-#ifdef VBOX_WITH_SUID_WRAPPER
-/**
- * Checks if the current user is authorized using Solaris' role-based access control.
- * Made as a separate function with so that it need not be invoked each time we need
- * to gain root access.
- *
- * @returns VBox error code.
- */
-static int solarisCheckUserAuth()
-{
-    /* Uses Solaris' role-based access control (RBAC).*/
-    struct passwd *pPass = getpwuid(getuid());
-    if (pPass == NULL || chkauthattr("solaris.device.cdrw", pPass->pw_name) == 0)
-        return VERR_PERMISSION_DENIED;
-
-    return VINF_SUCCESS;
-}
-#endif
-
-/** @interface_method_impl{PDMIMOUNT,pfnUnmount} */
-static DECLCALLBACK(int) drvHostDvdUnmount(PPDMIMOUNT pInterface, bool fForce, bool fEject)
-{
-    PDRVHOSTBASE pThis = PDMIMOUNT_2_DRVHOSTBASE(pInterface);
-    RTCritSectEnter(&pThis->CritSect);
-
-    /*
-     * Validate state.
-     */
-    int rc = VINF_SUCCESS;
-    if (!pThis->fLocked || fForce)
-    {
-        /* Unlock drive if necessary. */
-        if (pThis->fLocked)
-            drvHostBaseDoLockOs(pThis, false);
-
-        if (fEject)
-        {
-            /*
-             * Eject the disc.
-             */
-            rc = drvHostBaseEjectOs(pThis);
-        }
-
-        /*
-         * Media is no longer present.
-         */
-        DRVHostBaseMediaNotPresent(pThis);  /** @todo This isn't thread safe! */
-    }
-    else
-    {
-        Log(("drvHostDvdUnmount: Locked\n"));
-        rc = VERR_PDM_MEDIA_LOCKED;
-    }
-
-    RTCritSectLeave(&pThis->CritSect);
-    LogFlow(("drvHostDvdUnmount: returns %Rrc\n", rc));
-    return rc;
-}
 
 
@@ -195 +65 @@
 
 
-#ifdef USE_MEDIA_POLLING
-/**
- * Do media change polling.
- */
-static DECLCALLBACK(int) drvHostDvdPoll(PDRVHOSTBASE pThis)
-{
-    /*
-     * Poll for media change.
-     */
-    bool fMediaPresent = false;
-    bool fMediaChanged = false;
-    drvHostBaseQueryMediaStatusOs(pThis, &fMediaChanged, &fMediaPresent);
-
-    RTCritSectEnter(&pThis->CritSect);
-
-    int rc = VINF_SUCCESS;
-    if (pThis->fMediaPresent != fMediaPresent)
-    {
-        LogFlow(("drvHostDvdPoll: %d -> %d\n", pThis->fMediaPresent, fMediaPresent));
-        pThis->fMediaPresent = false;
-        if (fMediaPresent)
-            rc = DRVHostBaseMediaPresent(pThis);
-        else
-            DRVHostBaseMediaNotPresent(pThis);
-    }
-    else if (fMediaPresent)
-    {
-        /*
-         * Poll for media change.
-         */
-        if (fMediaChanged)
-        {
-            LogFlow(("drvHostDVDMediaThread: Media changed!\n"));
-            DRVHostBaseMediaNotPresent(pThis);
-            rc = DRVHostBaseMediaPresent(pThis);
-        }
-    }
-
-    RTCritSectLeave(&pThis->CritSect);
-    return rc;
-}
-#endif /* USE_MEDIA_POLLING */
-
-
 /** @interface_method_impl{PDMIMEDIA,pfnSendCmd} */
 static DECLCALLBACK(int) drvHostDvdSendCmd(PPDMIMEDIA pInterface, const uint8_t *pbCmd,
@@ -244 +70 @@
                                            uint8_t *pabSense, size_t cbSense, uint32_t cTimeoutMillies)
 {
-    RT_NOREF(cbSense);
-    PDRVHOSTBASE pThis = PDMIMEDIA_2_DRVHOSTBASE(pInterface);
+    PDRVHOSTBASE pThis = RT_FROM_MEMBER(pInterface, DRVHOSTBASE, IMedia);
     int rc;
     LogFlow(("%s: cmd[0]=%#04x txdir=%d pcbBuf=%d timeout=%d\n", __FUNCTION__, pbCmd[0], enmTxDir, *pcbBuf, cTimeoutMillies));
@@ -276 +101 @@
 
 
-/** @copydoc FNPDMDRVDESTRUCT */
-static DECLCALLBACK(void) drvHostDvdDestruct(PPDMDRVINS pDrvIns)
-{
-    return DRVHostBaseDestruct(pDrvIns);
-}
-
-
 /**
  * Construct a host dvd drive driver instance.
@@ -294 +112 @@
     LogFlow(("drvHostDvdConstruct: iInstance=%d\n", pDrvIns->iInstance));
 
+    bool fPassthrough;
+    int rc = CFGMR3QueryBool(pCfg, "Passthrough", &fPassthrough);
+    if (RT_SUCCESS(rc) && fPassthrough)
+    {
+        pThis->IMedia.pfnSendCmd = drvHostDvdSendCmd;
+        /* Passthrough requires opening the device in R/W mode. */
+        pThis->fReadOnlyConfig = false;
+    }
+
+    pThis->pfnDoLock = drvHostDvdDoLock;
+
     /*
      * Init instance data.
      */
-    int rc = DRVHostBaseInitData(pDrvIns, pCfg, "Path\0Interval\0Locked\0BIOSVisible\0AttachFailError\0Passthrough\0",
-                                 PDMMEDIATYPE_DVD);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Override stuff.
-         */
-#ifdef RT_OS_LINUX
-        pThis->pbDoubleBuffer = (uint8_t *)RTMemAlloc(SCSI_MAX_BUFFER_SIZE);
-        if (!pThis->pbDoubleBuffer)
-            return VERR_NO_MEMORY;
-#endif
-
-        bool fPassthrough;
-        rc = CFGMR3QueryBool(pCfg, "Passthrough", &fPassthrough);
-        if (RT_SUCCESS(rc) && fPassthrough)
-        {
-            pThis->IMedia.pfnSendCmd = drvHostDvdSendCmd;
-            /* Passthrough requires opening the device in R/W mode. */
-            pThis->fReadOnlyConfig = false;
-#ifdef VBOX_WITH_SUID_WRAPPER  /* Solaris setuid for Passthrough mode. */
-            rc = solarisCheckUserAuth();
-            if (RT_FAILURE(rc))
-            {
-                Log(("DVD: solarisCheckUserAuth failed. Permission denied!\n"));
-                return rc;
-            }
-#endif /* VBOX_WITH_SUID_WRAPPER */
-        }
-
-        pThis->IMount.pfnUnmount = drvHostDvdUnmount;
-        pThis->pfnDoLock         = drvHostDvdDoLock;
-#ifdef USE_MEDIA_POLLING
-        if (!fPassthrough)
-            pThis->pfnPoll       = drvHostDvdPoll;
-        else
-            pThis->pfnPoll       = NULL;
-#endif
-
-        /*
-         * 2nd init part.
-         */
-        rc = DRVHostBaseInitFinish(pThis);
-    }
-    if (RT_FAILURE(rc))
-    {
-        if (!pThis->fAttachFailError)
-        {
-            /* Suppressing the attach failure error must not affect the normal
-             * DRVHostBaseDestruct, so reset this flag below before leaving. */
-            pThis->fKeepInstance = true;
-            rc = VINF_SUCCESS;
-        }
-        DRVHostBaseDestruct(pDrvIns);
-        pThis->fKeepInstance = false;
-    }
-
+    rc = DRVHostBaseInit(pDrvIns, pCfg, "Path\0Interval\0Locked\0BIOSVisible\0AttachFailError\0Passthrough\0",
+                         PDMMEDIATYPE_DVD);
     LogFlow(("drvHostDvdConstruct: returns %Rrc\n", rc));
     return rc;
@@ -385 +159 @@
     drvHostDvdConstruct,
     /* pfnDestruct */
-    drvHostDvdDestruct,
+    DRVHostBaseDestruct,
     /* pfnRelocate */
     NULL,

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

@@ -23 +23 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_HOST_FLOPPY
-#ifdef RT_OS_LINUX
-# include <sys/ioctl.h>
-# include <linux/fd.h>
-# include <sys/fcntl.h>
-# include <errno.h>
-# elif defined(RT_OS_WINDOWS)
-# include <iprt/win/windows.h>
-# include <dbt.h>
-#endif
 
 #include <VBox/vmm/pdmdrv.h>
@@ -48 +39 @@
 
 
-/**
- * Floppy driver instance data.
- */
-typedef struct DRVHOSTFLOPPY
-{
-    DRVHOSTBASE     Base;
-    /** Previous poll status. */
-    bool            fPrevDiskIn;
-
-} DRVHOSTFLOPPY, *PDRVHOSTFLOPPY;
-
-
-#ifdef RT_OS_LINUX
-/**
- * This thread will periodically poll the Floppy for media presence.
- *
- * @returns Ignored.
- * @param   ThreadSelf  Handle of this thread. Ignored.
- * @param   pvUser      Pointer to the driver instance structure.
- */
-static DECLCALLBACK(int) drvHostFloppyPoll(PDRVHOSTBASE pThis)
-{
-    PDRVHOSTFLOPPY          pThisFloppy = (PDRVHOSTFLOPPY)pThis;
-    floppy_drive_struct     DrvStat;
-    int rc = ioctl(RTFileToNative(pThis->hFileDevice), FDPOLLDRVSTAT, &DrvStat);
-    if (rc)
-        return RTErrConvertFromErrno(errno);
-
-    RTCritSectEnter(&pThis->CritSect);
-    bool fDiskIn = !(DrvStat.flags & (FD_VERIFY | FD_DISK_NEWCHANGE));
-    if (    fDiskIn
-        &&  !pThisFloppy->fPrevDiskIn)
-    {
-        if (pThis->fMediaPresent)
-            DRVHostBaseMediaNotPresent(pThis);
-        rc = DRVHostBaseMediaPresent(pThis);
-        if (RT_FAILURE(rc))
-        {
-            pThisFloppy->fPrevDiskIn = fDiskIn;
-            RTCritSectLeave(&pThis->CritSect);
-            return rc;
-        }
-    }
-
-    if (    !fDiskIn
-        &&  pThisFloppy->fPrevDiskIn
-        &&  pThis->fMediaPresent)
-        DRVHostBaseMediaNotPresent(pThis);
-    pThisFloppy->fPrevDiskIn = fDiskIn;
-
-    RTCritSectLeave(&pThis->CritSect);
-    return VINF_SUCCESS;
-}
-#endif /* RT_OS_LINUX */
-
 
 /**
@@ -110 +46 @@
 {
     RT_NOREF(fFlags);
-    PDRVHOSTFLOPPY pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTFLOPPY);
     LogFlow(("drvHostFloppyConstruct: iInstance=%d\n", pDrvIns->iInstance));
 
@@ -116 +51 @@
      * Init instance data.
      */
-    int rc = DRVHostBaseInitData(pDrvIns, pCfg, "Path\0ReadOnly\0Interval\0Locked\0BIOSVisible\0",
-                                 PDMMEDIATYPE_FLOPPY_1_44);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Override stuff.
-         */
-#ifdef RT_OS_LINUX
-        pThis->Base.pfnPoll         = drvHostFloppyPoll;
-#endif
-
-        /*
-         * 2nd init part.
-         */
-        rc = DRVHostBaseInitFinish(&pThis->Base);
-    }
-
-    if (RT_FAILURE(rc))
-    {
-        if (!pThis->Base.fAttachFailError)
-        {
-            /* Suppressing the attach failure error must not affect the normal
-             * DRVHostBaseDestruct, so reset this flag below before leaving. */
-            pThis->Base.fKeepInstance = true;
-            rc = VINF_SUCCESS;
-        }
-        DRVHostBaseDestruct(pDrvIns);
-        pThis->Base.fKeepInstance = false;
-    }
-
+    int rc = DRVHostBaseInit(pDrvIns, pCfg, "Path\0ReadOnly\0Interval\0Locked\0BIOSVisible\0",
+                             PDMMEDIATYPE_FLOPPY_1_44);
     LogFlow(("drvHostFloppyConstruct: returns %Rrc\n", rc));
     return rc;
@@ -173 +80 @@
     ~0U,
     /* cbInstance */
-    sizeof(DRVHOSTFLOPPY),
+    sizeof(DRVHOSTBASE),
     /* pfnConstruct */
     drvHostFloppyConstruct,