Changeset 3764 in vbox

Timestamp:

Jul 22, 2007 1:19:02 PM (18 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

23092

Message:

Drop holdDevice(). darwin changes.

Location:

trunk/src/VBox/Main

Files:

• Makefile.kmk (modified) (1 diff)
• USBProxyService.cpp (modified) (2 diffs)
• darwin/iokit.cpp (modified) (7 diffs)
• darwin/iokit.h (modified) (1 diff)
• include/HostUSBDeviceImpl.h (modified) (3 diffs)
• include/USBProxyService.h (modified) (6 diffs)

trunk/src/VBox/Main/Makefile.kmk

@@ -219 +219 @@
 endif
 
-## Alternative USB filtering.
-#ifeq ($(filter-out darwin,$(BUILD_TARGET)),)
-#VBoxSVC_DEFS += VBOX_WITH_USBFILTER
-#VBoxSVC_LIBS += $(PATH_LIB)/USBLib$(VBOX_SUFF_LIB)
-#endif
+# Alternative USB filtering.
+ifeq ($(filter-out darwin,$(BUILD_TARGET)),)
+VBoxSVC_DEFS += VBOX_WITH_USBFILTER
+VBoxSVC_LIBS += $(PATH_LIB)/USBLib$(VBOX_SUFF_LIB)
+endif
 
 

trunk/src/VBox/Main/USBProxyService.cpp

@@ -456 +456 @@
 
 
+#ifdef VBOX_WITH_USBFILTER
+/*static*/ void USBProxyService::initFilterFromDevice (PUSBFILTER aFilter, HostUSBDevice *aDevice)
+{
+    PCUSBDEVICE pDev = aDevice->mUsb;
+    int vrc;
+
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_VENDOR_ID,         pDev->idVendor,         true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_PRODUCT_ID,        pDev->idProduct,        true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_DEVICE_REV,        pDev->bcdDevice,        true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_DEVICE_CLASS,      pDev->bDeviceClass,     true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_DEVICE_SUB_CLASS,  pDev->bDeviceSubClass,  true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_DEVICE_PROTOCOL,   pDev->bDeviceProtocol,  true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_PORT,              pDev->bPort,            true); AssertRC(vrc);
+    vrc = USBFilterSetNumExact (aFilter, USBFILTERIDX_BUS,               pDev->bBus,            false); AssertRC(vrc); /* not available on darwin yet... */
+    if (pDev->pszSerialNumber)
+    {
+        vrc = USBFilterSetStringExact (aFilter, USBFILTERIDX_SERIAL_NUMBER_STR, pDev->pszSerialNumber, true);
+        AssertRC (vrc);
+    }
+    if (pDev->pszProduct)
+    {
+        vrc = USBFilterSetStringExact (aFilter, USBFILTERIDX_PRODUCT_STR, pDev->pszProduct, true);
+        AssertRC (vrc);
+    }
+    if (pDev->pszManufacturer)
+    {
+        vrc = USBFilterSetStringExact (aFilter, USBFILTERIDX_MANUFACTURER_STR, pDev->pszManufacturer, true);
+        AssertRC (vrc);
+    }
+}
+#endif /* VBOX_WITH_USBFILTER */
+
+
 bool USBProxyService::updateDeviceStateFake (HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice)
 {
@@ -561 +594 @@
 
 
-int USBProxyService::holdDevice (HostUSBDevice * /* aDevice */)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
 void USBProxyService::detachingDevice (HostUSBDevice * /* aDevice */)
 {

trunk/src/VBox/Main/darwin/iokit.cpp

@@ -42 +42 @@
 
 #include <VBox/log.h>
+#include <VBox/err.h>
 #include <iprt/mem.h>
 #include <iprt/string.h>
+#include <iprt/process.h>
 #include <iprt/assert.h>
+#include <iprt/thread.h>
 
 #include "iokit.h"
@@ -55 +58 @@
 #define MY_CHECK_CREFS(cRefs)   do { AssertMsg(cRefs < 25, ("%ld\n", cRefs)); NOREF(cRefs); } while (0)
 
+/** Contains the pid of the current client. If 0, the kernel is the current client. */
+#define VBOXUSB_CLIENT_KEY  "VBoxUSB-Client"
+/** Contains the pid of the filter owner (i.e. the VBoxSVC pid). */
+#define VBOXUSB_OWNER_KEY   "VBoxUSB-Owner"
+/** The VBoxUSBDevice class name. */
+#define VBOXUSBDEVICE_CLASS_NAME "org_virtualbox_VBoxUSBDevice"
+
 
 /*******************************************************************************
@@ -162 +172 @@
     *pu64 = 0;
     return false;
+}
+
+
+/**
+ * Gets a RTPROCESS value.
+ *
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   pProcess    Where to store the key value.
+ */
+static bool darwinDictGetProccess(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, PRTPROCESS pProcess)
+{
+    switch (sizeof(*pProcess))
+    {
+        case sizeof(uint16_t):  return darwinDictGetU16(DictRef, KeyStrRef, (uint16_t *)pProcess);
+        case sizeof(uint32_t):  return darwinDictGetU32(DictRef, KeyStrRef, (uint32_t *)pProcess);
+        case sizeof(uint64_t):  return darwinDictGetU64(DictRef, KeyStrRef, (uint64_t *)pProcess);
+        default:
+            AssertMsgFailedReturn(("%d\n", sizeof(*pProcess)), false);
+    }
 }
 
@@ -630 +661 @@
         return;
 
+    RTPROCESS Owner = NIL_RTPROCESS;
+    RTPROCESS Client = NIL_RTPROCESS;
     bool fUserClientOnly = true;
     bool fConfigured = false;
@@ -686 +719 @@
             }
         }
+        /*
+         * Not an interface, could it be VBoxUSBDevice?
+         * If it is, get the owner and client properties.
+         */
+        else if (    krc == KERN_SUCCESS
+                 &&  !strcmp(szName, VBOXUSBDEVICE_CLASS_NAME))
+        {
+            CFMutableDictionaryRef PropsRef = 0;
+            krc = IORegistryEntryCreateCFProperties(Interface, &PropsRef, kCFAllocatorDefault, kNilOptions);
+            if (krc == KERN_SUCCESS)
+            {
+                darwinDictGetProccess(PropsRef, CFSTR(VBOXUSB_OWNER_KEY), &Owner);
+                darwinDictGetProccess(PropsRef, CFSTR(VBOXUSB_CLIENT_KEY), &Client);
+                CFRelease(PropsRef);
+            }
+        }
+
         IOObjectRelease(Interface);
     }
@@ -693 +743 @@
      * Calc the status.
      */
-    if (fUserClientOnly)
-        /** @todo how to detect other user client?!? */
+    if (    Owner != NIL_RTPROCESS
+        &&  !Owner)
+    {
+        if (Owner == RTProcSelf())
+            pCur->enmState = Client == NIL_RTPROCESS || !Client
+                           ? USBDEVICESTATE_HELD_BY_PROXY
+                           : USBDEVICESTATE_USED_BY_GUEST;
+        else
+            pCur->enmState = USBDEVICESTATE_USED_BY_HOST;
+    }
+    else if (fUserClientOnly)
+        /** @todo how to detect other user client?!? - Look for IOUSBUserClient! */
         pCur->enmState = !fConfigured
                        ? USBDEVICESTATE_UNUSED
                        : USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
-
     else if (!fInUse)
         pCur->enmState = USBDEVICESTATE_UNUSED;
@@ -909 +968 @@
 }
 
+
+/**
+ * Triggers re-enumeration of a device.
+ *
+ * @returns VBox status code.
+ * @param   pCur    The USBDEVICE structure for the device.
+ */
+int DarwinReEnumerateUSBDevice(PCUSBDEVICE pCur)
+{
+    int vrc;
+    const char *pszAddress = pCur->pszAddress;
+    AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
+    AssertReturn(darwinOpenMasterPort(), VERR_GENERAL_FAILURE);
+
+    /*
+     * This code is a short version of the Open method in USBProxyDevice-darwin.cpp stuff.
+     * Fixes made to this code probably applies there too!
+     */
+
+    CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName);
+    AssertReturn(RefMatchingDict, NULL);
+
+    uint64_t u64SessionId = 0;
+    uint32_t u32LocationId = 0;
+    const char *psz = pszAddress;
+    do
+    {
+        const char chValue = *psz;
+        AssertReleaseReturn(psz[1] == '=', VERR_INTERNAL_ERROR);
+        uint64_t u64Value;
+        int rc = RTStrToUInt64Ex(psz + 2, (char **)&psz, 0, &u64Value);
+        AssertReleaseRCReturn(rc, rc);
+        AssertReleaseReturn(!*psz || *psz == ';', rc);
+        switch (chValue)
+        {
+            case 'l':
+                u32LocationId = (uint32_t)u64Value;
+                break;
+            case 's':
+                u64SessionId = u64Value;
+                break;
+            case 'p':
+            case 'v':
+            {
+#if 0 /* Guess what, this doesn't 'ing work either! */
+                SInt32 i32 = (int16_t)u64Value;
+                CFNumberRef Num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i32);
+                AssertBreak(Num,);
+                CFDictionarySetValue(RefMatchingDict, chValue == 'p' ? CFSTR(kUSBProductID) : CFSTR(kUSBVendorID), Num);
+                CFRelease(Num);
+#endif
+                break;
+            }
+            default:
+                AssertReleaseMsgFailedReturn(("chValue=%#x\n", chValue), VERR_INTERNAL_ERROR);
+        }
+        if (*psz == ';')
+            psz++;
+    } while (*psz);
+
+    io_iterator_t USBDevices = NULL;
+    IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
+    AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%#x\n", irc), NULL);
+    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
+
+    unsigned cMatches = 0;
+    io_object_t USBDevice;
+    while ((USBDevice = IOIteratorNext(USBDevices)))
+    {
+        cMatches++;
+        CFMutableDictionaryRef PropsRef = 0;
+        kern_return_t krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions);
+        if (krc == KERN_SUCCESS)
+        {
+            uint64_t u64CurSessionId;
+            uint32_t u32CurLocationId;
+            if (    (    !u64SessionId
+                     || (   darwinDictGetU64(PropsRef, CFSTR("sessionID"), &u64CurSessionId)
+                         && u64CurSessionId == u64SessionId))
+                &&  (   !u32LocationId
+                     || (   darwinDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32CurLocationId)
+                         && u32CurLocationId == u32LocationId))
+                )
+            {
+                CFRelease(PropsRef);
+                break;
+            }
+            CFRelease(PropsRef);
+        }
+        IOObjectRelease(USBDevice);
+    }
+    IOObjectRelease(USBDevices);
+    USBDevices = NULL;
+    if (!USBDevice)
+    {
+        LogRel(("USB: Device '%s' not found (%d pid+vid matches)\n", pszAddress, cMatches));
+        IOObjectRelease(USBDevices);
+        return VERR_VUSB_DEVICE_NAME_NOT_FOUND;
+    }
+
+    /*
+     * Create a plugin interface for the device and query its IOUSBDeviceInterface.
+     */
+    SInt32 Score = 0;
+    IOCFPlugInInterface **ppPlugInInterface = NULL;
+    irc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
+                                            kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
+    if (irc == kIOReturnSuccess)
+    {
+        IOUSBDeviceInterface245 **ppDevI = NULL;
+        HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
+                                                           CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
+                                                           (LPVOID *)&ppDevI);
+        irc = IODestroyPlugInInterface(ppPlugInInterface); Assert(irc == kIOReturnSuccess);
+        ppPlugInInterface = NULL;
+        if (hrc == S_OK)
+        {
+            /*
+             * Try open the device for exclusive access.
+             */
+            irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
+            if (irc == kIOReturnExclusiveAccess)
+            {
+                RTThreadSleep(20);
+                irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
+            }
+            if (irc == kIOReturnSuccess)
+            {
+                /*
+                 * Re-enumerate the device and bail out.
+                 */
+                irc = (*ppDevI)->USBDeviceReEnumerate(ppDevI, 0);
+                if (irc != kIOReturnSuccess)
+                {
+                    LogRel(("USB: Failed to open device '%s', plug-in creation failed with irc=%#x.\n", pszAddress, irc));
+                    vrc = RTErrConvertFromDarwinIO(irc);
+                }
+
+                (*ppDevI)->USBDeviceClose(ppDevI);
+            }
+            else if (irc == kIOReturnExclusiveAccess)
+            {
+                LogRel(("USB: Device '%s' is being used by another process\n", pszAddress));
+                vrc = VERR_SHARING_VIOLATION;
+            }
+            else
+            {
+                LogRel(("USB: Failed to open device '%s', irc=%#x.\n", pszAddress, irc));
+                vrc = VERR_OPEN_FAILED;
+            }
+        }
+        else
+        {
+            LogRel(("USB: Failed to create plugin interface for device '%s', hrc=%#x.\n", pszAddress, hrc));
+            vrc = VERR_OPEN_FAILED;
+        }
+
+        (*ppDevI)->Release(ppDevI);
+    }
+    else
+    {
+        LogRel(("USB: Failed to open device '%s', plug-in creation failed with irc=%#x.\n", pszAddress, irc));
+        vrc = RTErrConvertFromDarwinIO(irc);
+    }
+
+    return vrc;
+}
+
 #endif /* VBOX_WITH_USB */
 

trunk/src/VBox/Main/darwin/iokit.h

@@ -51 +51 @@
 PUSBDEVICE  DarwinGetUSBDevices(void);
 void        DarwinFreeUSBDeviceFromIOKit(PUSBDEVICE pCur);
+int         DarwinReEnumerateUSBDevice(PCUSBDEVICE pCur);
 #endif
 __END_DECLS

trunk/src/VBox/Main/include/HostUSBDeviceImpl.h

@@ -84 +84 @@
 
     /** Additional internal states.
-     * The async detach stuff for Darwin is a two stage journey with a variation 
+     * The async detach stuff for Darwin is a two stage journey with a variation
      * (filters) depending on who won the race to lock the Host object.
-     * 
-     * @remark Trying out mac os x style enum naming convention here. nice or what? 
+     *
+     * @remark Trying out mac os x style enum naming convention here. nice or what?
      */
     typedef enum
-    { 
+    {
         /** Nothing is pending here, check mPendingState. */
-        kNothingPending, 
+        kNothingPending,
         /** 1st stage of the detch, waiting for the logical detach notification. */
-        kDetachingPendingDetach, 
-        /** 1st stage of the detch, waiting for the logical detach notification - re-run filters. 
+        kDetachingPendingDetach,
+        /** 1st stage of the detch, waiting for the logical detach notification - re-run filters.
          * Prev: kDetachingPendingDetach */
-        kDetachingPendingDetachFilters, 
-        /** 2nd stage of the detach, waiting for the logical attach notification. 
+        kDetachingPendingDetachFilters,
+        /** 2nd stage of the detach, waiting for the logical attach notification.
          * Prev: kDetachingPendingDetach */
         kDetachingPendingAttach,
-        /** 2nd stage of the detach, waiting for the logical attach notification - re-run filters. 
+        /** 2nd stage of the detach, waiting for the logical attach notification - re-run filters.
          * Prev: kDetachingPendingDetachFilters */
         kDetachingPendingAttachFilters
@@ -163 +163 @@
     /** Same as mPendingState but for the internal states. */
     InternalState mPendingStateEx;
-    /** RTTimeNanoTS() of when mIsStatePending was set or mDetaching changed 
+    /** RTTimeNanoTS() of when mIsStatePending was set or mDetaching changed
      * from kNotDetaching. For operations that cannot be cancelled it's 0. */
     uint64_t mPendingSince;
@@ -179 +179 @@
 #ifdef RT_OS_LINUX
     friend class USBProxyServiceLinux;
+#endif
+#ifdef RT_OS_DARWIN
+    /** One-shot filter id. */
+    void *mOneShotId;
+
+    friend class USBProxyServiceDarwin;
 #endif
 };

trunk/src/VBox/Main/include/USBProxyService.h

@@ -64 +64 @@
 
     /**
-     * The device is to be held so that the host OS will not start using it.
-     *
-     * @returns VBox status code.
-     * @param   aDevice     The device in question.
-     */
-    virtual int holdDevice (HostUSBDevice *aDevice);
-
-    /**
      * The device is going to be detached from a VM.
      *
@@ -137 +129 @@
      */
     static uint64_t calcSerialHash (const char *aSerial);
+
+#ifdef VBOX_WITH_USBFILTER
+    /**
+     * Initializes a filter with the data from the specified device.
+     *
+     * @param   aFilter     The filter to fill.
+     * @param   aDevice     The device to fill it with.
+     */
+    static void initFilterFromDevice (PUSBFILTER aFilter, HostUSBDevice *aDevice);
+#endif
 
 protected:
@@ -270 +272 @@
 
     virtual int captureDevice (HostUSBDevice *aDevice);
-    virtual int holdDevice (HostUSBDevice *aDevice);
     virtual void detachingDevice (HostUSBDevice *aDevice);
     virtual int releaseDevice (HostUSBDevice *aDevice);
@@ -291 +292 @@
      * not including newly attached devices. */
     bool mWaitABitNextTime;
+#ifndef VBOX_WITH_USBFILTER
     /** Whether we've got a fake async event and should return without entering the runloop. */
     bool volatile mFakeAsync;
+#endif
     /** Whether we've successfully initialized the USBLib and should call USBLibTerm in the destructor. */
     bool mUSBLibInitialized;
@@ -312 +315 @@
 
     virtual int captureDevice (HostUSBDevice *aDevice);
-    virtual int holdDevice (HostUSBDevice *aDevice);
     virtual int releaseDevice (HostUSBDevice *aDevice);
     virtual bool updateDeviceState (HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice);
@@ -354 +356 @@
 
     virtual int captureDevice (HostUSBDevice *aDevice);
-    virtual int holdDevice (HostUSBDevice *aDevice);
     virtual int releaseDevice (HostUSBDevice *aDevice);
     virtual bool updateDeviceState (HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice);