Changeset 34341 in vbox for trunk

Timestamp:

Nov 24, 2010 8:14:36 PM (14 years ago)

Author:

vboxsync

Message:

Main/linux/USB and RDP/client/vrdp: clean up the handling of the USB device tree path and get rid of data duplication

Location:

trunk/src/VBox

Files:

• Main/include/HostHardwareLinux.h (modified) (1 diff)
• Main/include/USBGetDevices.h (modified) (1 diff)
• Main/include/USBProxyService.h (modified) (3 diffs)
• Main/linux/HostHardwareLinux.cpp (modified) (10 diffs)
• Main/linux/USBGetDevices.cpp (modified) (11 diffs)
• Main/linux/USBProxyServiceLinux.cpp (modified) (10 diffs)
• Main/testcase/tstHostHardwareLinux.cpp (modified) (2 diffs)
• RDP/client/vrdp/rdpusb.c (modified) (3 diffs)

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

@@ -136 +136 @@
 public:
     /** Constructor.  Responsible for selecting the implementation. */
-    VBoxMainHotplugWaiter (void);
+    VBoxMainHotplugWaiter(const char *pcszDevicesRoot);
     /** Destructor. */
     ~VBoxMainHotplugWaiter (void)

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

@@ -75 +75 @@
 RT_C_DECLS_BEGIN
 
+/** List of well-known USB device tree locations */
+typedef struct USBDEVTREELOCATION
+{
+    /** The root of the device tree for this location. */
+    char szDevicesRoot[256];
+    /** Whether this location requires device enumeration using sysfs. */
+    bool fUseSysfs;
+} USBDEVTREELOCATION, *PUSBDEVTREELOCATION;
+typedef const USBDEVTREELOCATION *PCUSBDEVTREELOCATION;
+
 /**
- * Check whether @a pcszDevices is a valid usbfs devices file for checking
- * whether usbfs is supported or not.
- * @returns VINF_SUCCESS if it is
- * @returns VERR_NOT_FOUND if it isn't
- * @returns iprt status code if an error occurred
- * @todo  test whether USB with sysfs/dev is supported
+ * Get the USB device tree root
+ * @param  fPreferSysfs  whether we wish to use sysfs over usbfs for
+ *                       enumeration if we have the choice
+ * @note   returns a pointer into a static array so it will stay valid
  */
-extern int USBProxyLinuxCheckForUsbfs(const char *pcszDevices);
+extern PCUSBDEVTREELOCATION USBProxyLinuxGetDeviceRoot(bool fPreferSysfs);
 
 /**
  * Get the list of USB devices supported by the system.  Should be freed using
  * @a deviceFree or something equivalent.
- * @param pcszUsbfsRoot  the path to usbfs, or NULL to use sysfs
+ * @param pcszDevicesRoot  the path to the root of the device tree
+ * @param fUseSysfs       whether to use sysfs (or usbfs) for enumeration
  */
-extern PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszUsbfsRoot);
+extern PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszDevicesRoot,
+                                          bool fUseSysfs);
 
 RT_C_DECLS_END

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

@@ -204 +204 @@
 {
 public:
-    USBProxyServiceLinux(Host *aHost,
-                         const char *aUsbfsRoot = "/proc/bus/usb");
+    USBProxyServiceLinux(Host *aHost);
     HRESULT init(void);
     ~USBProxyServiceLinux();
@@ -234 +233 @@
     RTFILE mWakeupPipeW;
     /** The root of usbfs. */
-    Utf8Str mUsbfsRoot;
+    Utf8Str mDevicesRoot;
     /** Whether we're using <mUsbfsRoot>/devices or /sys/whatever. */
     bool mUsingUsbfsDevices;
@@ -241 +240 @@
 #  ifdef VBOX_USB_WITH_SYSFS
     /** Object used for polling for hotplug events from hal. */
-    VBoxMainHotplugWaiter mWaiter;
+    VBoxMainHotplugWaiter *mpWaiter;
 #  endif
 };

trunk/src/VBox/Main/linux/HostHardwareLinux.cpp

@@ -1054 +1054 @@
 {
 public:
-    hotplugNullImpl (void) {}
+    hotplugNullImpl(const char *) {}
     virtual ~hotplugNullImpl (void) {}
     /** @copydoc VBoxMainHotplugWaiter::Wait */
@@ -1155 +1155 @@
 }
 
-# define SYSFS_USB_DEVICE_PATH "/dev/bus/usb"
 # define SYSFS_WAKEUP_STRING "Wake up!"
 
@@ -1169 +1168 @@
      * ensure that it isn't called multiple times in parallel. */
     volatile uint32_t mfWaiting;
+    /** The root of the USB devices tree. */
+    const char *mpcszDevicesRoot;
     /** iprt result code from object initialisation.  Should be AssertReturn-ed
      * on at the start of all methods.  I went this way because I didn't want
@@ -1192 +1193 @@
     int drainWakeupPipe(void);
 public:
-    hotplugInotifyImpl(void);
+    hotplugInotifyImpl(const char *pcszDevicesRoot);
     virtual ~hotplugInotifyImpl(void)
     {
@@ -1202 +1203 @@
 #endif
     }
-    /** Are sysfs and inotify available on this system?  If so we expect that
+    /** Is inotify available and working on this system?  If so we expect that
      * this implementation will be usable. */
+    /** @todo test the "inotify in glibc but not in the kernel" case. */
     static bool Available(void)
     {
-        return (   RTDirExists(SYSFS_USB_DEVICE_PATH)
-                && dlsym(RTLD_DEFAULT, "inotify_init") != NULL);
+        int (*inotify_init)(void);
+
+        *(void **)(&inotify_init) = dlsym(RTLD_DEFAULT, "inotify_init");
+        if (!inotify_init)
+            return false;
+        int fd = inotify_init();
+        if (fd == -1)
+            return false;
+        close(fd);
+        return true;
     }
 
@@ -1252 +1262 @@
 }
 
-hotplugInotifyImpl::hotplugInotifyImpl(void) :
+hotplugInotifyImpl::hotplugInotifyImpl(const char *pcszDevicesRoot) :
     mhWakeupPipeR(-1), mhWakeupPipeW(-1), mfWaiting(0),
-    mStatus(VERR_WRONG_ORDER)
+    mpcszDevicesRoot(pcszDevicesRoot), mStatus(VERR_WRONG_ORDER)
 {
 #  ifdef DEBUG
@@ -1269 +1279 @@
         if (RT_FAILURE(rc = iwInit(&mWatches)))
             break;
-        if (RT_FAILURE(rc = iwAddWatch(&mWatches, SYSFS_USB_DEVICE_PATH)))
+        if (RT_FAILURE(rc = iwAddWatch(&mWatches, mpcszDevicesRoot)))
             break;
         if (RT_FAILURE(rc = pipeCreateSimple(&mhWakeupPipeR, &mhWakeupPipeW)))
@@ -1338 +1348 @@
         struct pollfd pollFD[MAX_POLLID];
 
-        rc = readFilePaths(SYSFS_USB_DEVICE_PATH, &vecpchDevs, false);
+        rc = readFilePaths(mpcszDevicesRoot, &vecpchDevs, false);
         if (RT_SUCCESS(rc))
             VEC_FOR_EACH(&vecpchDevs, char *, ppszEntry)
@@ -1392 +1402 @@
 #endif  /* VBOX_USB_WTH_SYSFS */
 
-VBoxMainHotplugWaiter::VBoxMainHotplugWaiter(void)
+VBoxMainHotplugWaiter::VBoxMainHotplugWaiter(const char *pcszDevicesRoot)
 {
     try
@@ -1400 +1410 @@
         if (hotplugInotifyImpl::Available())
         {
-            mImpl = new hotplugInotifyImpl;
+            mImpl = new hotplugInotifyImpl(pcszDevicesRoot);
             return;
         }
 # endif /* VBOX_USB_WITH_INOTIFY */
 #endif  /* VBOX_USB_WITH_SYSFS */
-        mImpl = new hotplugNullImpl;
+        mImpl = new hotplugNullImpl(pcszDevicesRoot);
     }
     catch(std::bad_alloc &e)

trunk/src/VBox/Main/linux/USBGetDevices.cpp

@@ -34 +34 @@
 #include <iprt/mem.h>
 #include <iprt/param.h>
+#include <iprt/path.h>
 #include <iprt/string.h>
 #include "vector.h"
@@ -93 +94 @@
 };
 
-
-int USBProxyLinuxCheckForUsbfs(const char *pcszDevices)
-{
-    int fd, rc = VINF_SUCCESS;
-
-    fd = open(pcszDevices, O_RDONLY, 00600);
-    if (fd >= 0)
-    {
-        /*
-         * Check that we're actually on the usbfs.
-         */
-        struct statfs StFS;
-        if (!fstatfs(fd, &StFS))
-        {
-            if (StFS.f_type != USBDEVICE_SUPER_MAGIC)
-                rc = VERR_NOT_FOUND;
-        }
-        else
-            rc = RTErrConvertFromErrno(errno);
-        close(fd);
-    }
-    else
-        rc = RTErrConvertFromErrno(errno);
-    return rc;
-}
+/**
+ * List of well-known USB device tree locations.
+ */
+static const USBDEVTREELOCATION s_aTreeLocations[] =
+{
+    { "/proc/bus/usb", false },
+    { "/dev/bus/usb",  false },
+    { "/dev/bus/usb",  true },
+};
 
 
@@ -870 +855 @@
  * interface add an element for the device to @a pvecDevInfo.
  */
-static int addIfDevice(const char *pcszNode,
+static int addIfDevice(const char *pcszDevicesRoot,
+                       const char *pcszNode,
                        VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo)
 {
@@ -886 +872 @@
     cchDevPath = RTLinuxFindDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
                                        szDevPath, sizeof(szDevPath),
-                                       "/dev/bus/usb/%.3d/%.3d",
+                                       "%s/%.3d/%.3d",
+                                       pcszDevicesRoot,
                                        usbBusFromDevNum(devnum),
                                        usbDeviceFromDevNum(devnum));
@@ -1025 +1012 @@
  * @param pvecDevInfo  vector of device information structures to add device
  *                     information to
- * @param pvecpchDevs  empty scratch vector which will be freed by the caller
- */
-static int doSysfsEnumerateHostDevices(VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo,
-                              VECTOR_PTR(char *) *pvecpchDevs)
+ * @param pvecpchDevs  empty scratch vector which will be freed by the caller,
+ *                     to simplify exit logic
+ */
+static int doSysfsEnumerateHostDevices(const char *pcszDevicesRoot,
+                                       VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo,
+                                       VECTOR_PTR(char *) *pvecpchDevs)
 {
     char **ppszEntry;
@@ -1041 +1030 @@
         return rc;
     VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
-        if (RT_FAILURE(rc = addIfDevice(*ppszEntry, pvecDevInfo)))
+        if (RT_FAILURE(rc = addIfDevice(pcszDevicesRoot, *ppszEntry,
+                                        pvecDevInfo)))
             return rc;
     VEC_FOR_EACH(pvecDevInfo, USBDeviceInfo, pInfo)
@@ -1050 +1040 @@
 }
 
-static int USBSysfsEnumerateHostDevices(VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo)
+static int USBSysfsEnumerateHostDevices(const char *pcszDevicesRoot,
+                                        VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo)
 {
     VECTOR_PTR(char *) vecpchDevs;
@@ -1058 +1049 @@
     LogFlowFunc(("entered\n"));
     VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
-    rc = doSysfsEnumerateHostDevices(pvecDevInfo, &vecpchDevs);
+    rc = doSysfsEnumerateHostDevices(pcszDevicesRoot, pvecDevInfo,
+                                     &vecpchDevs);
     VEC_CLEANUP_PTR(&vecpchDevs);
     LogFlowFunc(("rc=%Rrc\n", rc));
@@ -1350 +1342 @@
  * USBProxyService::getDevices() implementation for sysfs.
  */
-static PUSBDEVICE getDevicesFromSysfs(void)
+static PUSBDEVICE getDevicesFromSysfs(const char *pcszDevicesRoot)
 {
 #ifdef VBOX_USB_WITH_SYSFS
@@ -1361 +1353 @@
 
     VEC_INIT_OBJ(&vecDevInfo, USBDeviceInfo, USBDevInfoCleanup);
-    rc = USBSysfsEnumerateHostDevices(&vecDevInfo);
+    rc = USBSysfsEnumerateHostDevices(pcszDevicesRoot, &vecDevInfo);
     if (RT_FAILURE(rc))
         return NULL;
@@ -1401 +1393 @@
 }
 
-PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszUsbfsRoot)
-{
-    if (pcszUsbfsRoot)
-        return getDevicesFromUsbfs(pcszUsbfsRoot);
+PCUSBDEVTREELOCATION USBProxyLinuxGetDeviceRoot(bool fPreferSysfs)
+{
+    PCUSBDEVTREELOCATION pcBestUsbfs = NULL;
+    PCUSBDEVTREELOCATION pcBestSysfs = NULL;
+
+    for (unsigned i = 0; i < RT_ELEMENTS(s_aTreeLocations); ++i)
+        if (!s_aTreeLocations[i].fUseSysfs)
+        {
+            if (!pcBestUsbfs)
+            {
+                PUSBDEVICE pDevices;
+
+                pDevices = getDevicesFromUsbfs(s_aTreeLocations[i].szDevicesRoot);
+                if (pDevices)
+                {
+                    pcBestUsbfs = &s_aTreeLocations[i];
+                    deviceListFree(&pDevices);
+                }
+            }
+        }
+        else
+        {
+            if (   !pcBestSysfs
+                && RTPathExists(s_aTreeLocations[i].szDevicesRoot))
+                pcBestSysfs = &s_aTreeLocations[i];
+        }
+    if (pcBestUsbfs && !fPreferSysfs)
+        return pcBestUsbfs;
+    return pcBestSysfs;
+}
+
+
+PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszDevicesRoot,
+                                   bool fUseSysfs)
+{
+    if (!fUseSysfs)
+        return getDevicesFromUsbfs(pcszDevicesRoot);
     else
-        return getDevicesFromSysfs();
-}
+        return getDevicesFromSysfs(pcszDevicesRoot);
+}

trunk/src/VBox/Main/linux/USBProxyServiceLinux.cpp

@@ -55 +55 @@
 
 
-/*******************************************************************************
-*   Structures and Typedefs                                                    *
-*******************************************************************************/
-/** Suffix translation. */
-typedef struct USBSUFF
-{
-    char        szSuff[4];
-    unsigned    cchSuff;
-    unsigned    uMul;
-    unsigned    uDiv;
-} USBSUFF, *PUSBSUFF;
-typedef const USBSUFF *PCUSBSUFF;
-
-
-/*******************************************************************************
-*   Global Variables                                                           *
-*******************************************************************************/
-/**
- * Suffixes for the endpoint polling interval.
- */
-static const USBSUFF s_aIntervalSuff[] =
-{
-    { "ms", 2,    1,       0 },
-    { "us", 2,    1,    1000 },
-    { "ns", 2,    1, 1000000 },
-    { "s",  1, 1000,       0 },
-    { "",   0,    0,       0 }  /* term */
-};
-
-
 /**
  * Initialize data members.
  */
-USBProxyServiceLinux::USBProxyServiceLinux(Host *aHost, const char *aUsbfsRoot /* = "/proc/bus/usb" */)
+USBProxyServiceLinux::USBProxyServiceLinux(Host *aHost)
     : USBProxyService(aHost), mFile(NIL_RTFILE), mWakeupPipeR(NIL_RTFILE),
-      mWakeupPipeW(NIL_RTFILE), mUsbfsRoot(aUsbfsRoot), mUsingUsbfsDevices(true /* see init */), mUdevPolls(0)
-{
-    LogFlowThisFunc(("aHost=%p aUsbfsRoot=%p:{%s}\n", aHost, aUsbfsRoot, aUsbfsRoot));
+      mWakeupPipeW(NIL_RTFILE), mUsingUsbfsDevices(true /* see init */),
+      mUdevPolls(0), mpWaiter(NULL)
+{
+    LogFlowThisFunc(("aHost=%p:{%s}\n", aHost));
 }
 
@@ -118 +89 @@
      */
 #ifdef VBOX_WITH_SYSFS_BY_DEFAULT
-    mUsingUsbfsDevices = false;
+    bool fUseSysfs = true;
 #else
-    mUsingUsbfsDevices = true;
+    bool fUseSysfs = false;
 #endif
     const char *pszUsbFromEnv = RTEnvGet("VBOX_USB");
@@ -128 +99 @@
         {
             LogRel(("Default USB access method set to \"usbfs\" from environment\n"));
-            mUsingUsbfsDevices = true;
+            fUseSysfs = false;
         }
         else if (!RTStrICmp(pszUsbFromEnv, "SYSFS"))
         {
             LogRel(("Default USB method set to \"sysfs\" from environment\n"));
-            mUsingUsbfsDevices = false;
+            fUseSysfs = true;
         }
         else
@@ -139 +110 @@
                     pszUsbFromEnv));
     }
-    int rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
-    if (RT_FAILURE(rc))
-    {
+    PCUSBDEVTREELOCATION pcLocation = USBProxyLinuxGetDeviceRoot(fUseSysfs);
+    if (pcLocation)
+    {
+        mUsingUsbfsDevices = !pcLocation->fUseSysfs;
+        mDevicesRoot = pcLocation->szDevicesRoot;
+        int rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
         /* For the day when we have VBoxSVC release logging... */
-        LogRel(("Failed to initialise host USB using %s\n",
+        LogRel((RT_SUCCESS(rc) ? "Successfully initialised host USB using %s\n"
+                               : "Failed to initialise host USB using %s\n",
                 mUsingUsbfsDevices ? "USBFS" : "sysfs/hal"));
-        mUsingUsbfsDevices = !mUsingUsbfsDevices;
-        rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
-    }
-    LogRel((RT_SUCCESS(rc) ? "Successfully initialised host USB using %s\n"
-                           : "Failed to initialise host USB using %s\n",
-            mUsingUsbfsDevices ? "USBFS" : "sysfs/hal"));
-    mLastError = rc;
+        mLastError = rc;
+    }
+    else
+        mLastError = VERR_NOT_FOUND;
     return S_OK;
 }
@@ -169 +141 @@
      */
     int rc;
-    char *pszDevices = RTPathJoinA(mUsbfsRoot.c_str(), "devices");
+    char *pszDevices = RTPathJoinA(mDevicesRoot.c_str(), "devices");
     if (pszDevices)
     {
-        rc = USBProxyLinuxCheckForUsbfs(pszDevices);
+        rc = RTFileOpen(&mFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
         if (RT_SUCCESS(rc))
         {
-            rc = RTFileOpen(&mFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
-            if (RT_SUCCESS(rc))
+            int pipes[2];
+            if (!pipe(pipes))
             {
-                int pipes[2];
-                if (!pipe(pipes))
+                /* Set close on exec (race here!) */
+                if (   fcntl(pipes[0], F_SETFD, FD_CLOEXEC) >= 0
+                    && fcntl(pipes[1], F_SETFD, FD_CLOEXEC) >= 0)
                 {
-                    /* Set close on exec (race here!) */
-                    if (   fcntl(pipes[0], F_SETFD, FD_CLOEXEC) >= 0
-                        && fcntl(pipes[1], F_SETFD, FD_CLOEXEC) >= 0)
+                    mWakeupPipeR = pipes[0];
+                    mWakeupPipeW = pipes[1];
+                    /*
+                     * Start the poller thread.
+                     */
+                    rc = start();
+                    if (RT_SUCCESS(rc))
                     {
-                        mWakeupPipeR = pipes[0];
-                        mWakeupPipeW = pipes[1];
-                        /*
-                         * Start the poller thread.
-                         */
-                        rc = start();
-                        if (RT_SUCCESS(rc))
-                        {
-                            RTStrFree(pszDevices);
-                            LogFlowThisFunc(("returns successfully - mWakeupPipeR/W=%d/%d\n",
-                                             mWakeupPipeR, mWakeupPipeW));
-                            return VINF_SUCCESS;
-                        }
-
-                        RTFileClose(mWakeupPipeR);
-                        RTFileClose(mWakeupPipeW);
-                        mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
+                        RTStrFree(pszDevices);
+                        LogFlowThisFunc(("returns successfully - mWakeupPipeR/W=%d/%d\n",
+                                         mWakeupPipeR, mWakeupPipeW));
+                        return VINF_SUCCESS;
                     }
-                    else
-                    {
-                        rc = RTErrConvertFromErrno(errno);
-                        Log(("USBProxyServiceLinux::USBProxyServiceLinux: fcntl failed, errno=%d\n", errno));
-                        close(pipes[0]);
-                        close(pipes[1]);
-                    }
+
+                    RTFileClose(mWakeupPipeR);
+                    RTFileClose(mWakeupPipeW);
+                    mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
                 }
                 else
                 {
                     rc = RTErrConvertFromErrno(errno);
-                    Log(("USBProxyServiceLinux::USBProxyServiceLinux: pipe failed, errno=%d\n", errno));
+                    Log(("USBProxyServiceLinux::USBProxyServiceLinux: fcntl failed, errno=%d\n", errno));
+                    close(pipes[0]);
+                    close(pipes[1]);
                 }
-                RTFileClose(mFile);
             }
-
+            else
+            {
+                rc = RTErrConvertFromErrno(errno);
+                Log(("USBProxyServiceLinux::USBProxyServiceLinux: pipe failed, errno=%d\n", errno));
+            }
+            RTFileClose(mFile);
         }
+
         RTStrFree(pszDevices);
     }
@@ -243 +211 @@
 
 #ifdef VBOX_USB_WITH_SYSFS
-    int rc = mWaiter.getStatus();
+    try 
+    {
+        mpWaiter = new VBoxMainHotplugWaiter(mDevicesRoot.c_str());
+    }
+    catch(std::bad_alloc &e)
+    {
+        return VERR_NO_MEMORY;
+    }
+    int rc = mpWaiter->getStatus();
     if (RT_SUCCESS(rc) || rc == VERR_TIMEOUT || rc == VERR_TRY_AGAIN)
         rc = start();
@@ -275 +251 @@
      */
     doUsbfsCleanupAsNeeded();
-
-    /* (No extra work for !mUsingUsbfsDevices.) */
+#ifdef VBOX_USB_WITH_SYSFS
+    if (mpWaiter)
+        delete mpWaiter;
+#endif
 }
 
@@ -417 +395 @@
 {
 #ifdef VBOX_USB_WITH_SYSFS
-    int rc = mWaiter.Wait(aMillies);
+    int rc = mpWaiter->Wait(aMillies);
     if (rc == VERR_TRY_AGAIN)
     {
@@ -436 +414 @@
     if (!mUsingUsbfsDevices)
     {
-        mWaiter.Interrupt();
+        mpWaiter->Interrupt();
         LogFlowFunc(("Returning VINF_SUCCESS\n"));
         return VINF_SUCCESS;
@@ -451 +429 @@
 PUSBDEVICE USBProxyServiceLinux::getDevices(void)
 {
-    if (mUsingUsbfsDevices)
-        return USBProxyLinuxGetDevices(mUsbfsRoot.c_str());
-    else
-        return USBProxyLinuxGetDevices(NULL);
-}
-
+    return USBProxyLinuxGetDevices(mDevicesRoot.c_str(), !mUsingUsbfsDevices);
+}

trunk/src/VBox/Main/testcase/tstHostHardwareLinux.cpp

@@ -55 +55 @@
 }
 
-void printDevices(PUSBDEVICE pDevices, const char *pcszAccess)
+void printDevices(PUSBDEVICE pDevices,
+                  const char *pcszDevices,
+                  const char *pcszMethod)
 {
     PUSBDEVICE pDevice = pDevices;
 
-    RTPrintf("Enumerating usb devices using %s\n", pcszAccess);
+    RTPrintf("Enumerating usb devices using %s at %s\n", pcszMethod, pcszDevices);
     while (pDevice)
     {
@@ -118 +120 @@
         RTPrintf ("\n");
     }
-#ifdef VBOX_USB_WITH_SYSFS
-    PUSBDEVICE pDevice = USBProxyLinuxGetDevices(NULL);
-    printDevices(pDevice, "sysfs");
-    freeDevices(pDevice);
-    if (USBProxyLinuxCheckForUsbfs("/proc/bus/usb/devices"))
+    PCUSBDEVTREELOCATION pcLocation = USBProxyLinuxGetDeviceRoot(false);
+    if (pcLocation && !pcLocation->fUseSysfs)
     {
-        pDevice = USBProxyLinuxGetDevices("/proc/bus/usb");
-        printDevices(pDevice, "/proc/bus/usb");
+        PUSBDEVICE pDevice = USBProxyLinuxGetDevices(pcLocation->szDevicesRoot,
+                                                     false);
+        printDevices(pDevice, pcLocation->szDevicesRoot, "usbfs");
         freeDevices(pDevice);
     }
-    if (USBProxyLinuxCheckForUsbfs("/dev/bus/usb/devices"))
+#ifdef VBOX_USB_WITH_SYSFS
+    pcLocation = USBProxyLinuxGetDeviceRoot(true);
+    if (pcLocation && pcLocation->fUseSysfs)
     {
-        pDevice = USBProxyLinuxGetDevices("/dev/bus/usb");
-        printDevices(pDevice, "/dev/bus/usb");
+        PUSBDEVICE pDevice = USBProxyLinuxGetDevices(pcLocation->szDevicesRoot,
+                                                     true);
+        printDevices(pDevice, pcLocation->szDevicesRoot, "sysfs");
         freeDevices(pDevice);
     }
-    VBoxMainHotplugWaiter waiter;
+    VBoxMainHotplugWaiter waiter(pcLocation->szDevicesRoot);
     RTPrintf ("Waiting for a hotplug event for five seconds...\n");
     doHotplugEvent(&waiter, 5000);

trunk/src/VBox/RDP/client/vrdp/rdpusb.c

@@ -63 +63 @@
 };
 
-/** Location at which the Linux Usbfs filesystem was found.  NULL means not
- * found, in which case USB devices will be accessed through /dev and sysfs. */
-static const char *g_pcszUsbfsRoot = NULL;
+/** Location at which the USB device tree was found.  NULL means not
+ * found. */
+static const char *g_pcszDevicesRoot = NULL;
+static bool g_fUseSysfs = false;
 
 static PUSBDEVICE g_pUsbDevices = NULL;
@@ -252 +253 @@
     if (g_pUsbDevices)
         deviceListFree(&g_pUsbDevices);
-    g_pUsbDevices = USBProxyLinuxGetDevices(g_pcszUsbfsRoot);
+    g_pUsbDevices = USBProxyLinuxGetDevices(g_pcszDevicesRoot, g_fUseSysfs);
     if (!g_pUsbDevices)
         return NULL;
@@ -852 +853 @@
 
 
-/** Check for the Linux Usbfs filesystem in a couple of common locations. */
-static void checkUsbfsRoot(void)
-{
-    unsigned i;
-    for (i = 0; i < RT_ELEMENTS(g_usbfsPaths); ++i)
-        if (RT_SUCCESS(USBProxyLinuxCheckForUsbfs(g_usbfsPaths[i].pcszDevices)))
-        {
-            g_pcszUsbfsRoot = g_usbfsPaths[i].pcszRoot;
-            break;
-        }
-}
-
-
 RD_BOOL
 rdpusb_init(void)
 {
-        checkUsbfsRoot();
+        PCUSBDEVTREELOCATION pcLocation = USBProxyLinuxGetDeviceRoot(false);
+        g_fUseSysfs       = pcLocation->fUseSysfs;
+        g_pcszDevicesRoot = pcLocation->szDevicesRoot;
         rdpusb_channel =
                 channel_register("vrdpusb", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP,