Changeset 31644 in vbox for trunk/src/VBox/Main

Timestamp:

Aug 13, 2010 12:47:07 PM (14 years ago)

Author:

vboxsync

Message:

Main/HostHardwareLinux: switch the stl vectors to a C implementation

Location:

trunk/src/VBox/Main

Files:

• include/HostHardwareLinux.h (modified) (2 diffs)
• linux/HostHardwareLinux.cpp (modified) (5 diffs)
• testcase/tstHostHardwareLinux.cpp (modified) (3 diffs)

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

@@ -109 +109 @@
 typedef VBoxMainDriveInfo::DriveInfo DriveInfo;
 
+
+/** Vector type for the list of interfaces. */
+#define VECTOR_TYPE       char *
+#define VECTOR_TYPENAME   USBInterfaceList
+static inline void USBInterfaceListCleanup(char **ppsz)
+{
+    RTStrFree(*ppsz);
+}
+#define VECTOR_DESTRUCTOR USBInterfaceListCleanup
+#include "vector.h"
+
+/** Structure describing a host USB device */
+typedef struct USBDeviceInfo
+{
+    /** The device node of the device. */
+    char *mDevice;
+    /** The system identifier of the device.  Specific to the probing
+     * method. */
+    char *mSysfsPath;
+    /** Type for the list of interfaces. */
+    USBInterfaceList mInterfaces;
+} USBDeviceInfo;
+
+
+/** Destructor. */
+static inline void USBDevInfoCleanup(USBDeviceInfo *pSelf)
+{
+    RTStrFree(pSelf->mDevice);
+    RTStrFree(pSelf->mSysfsPath);
+    pSelf->mDevice = pSelf->mSysfsPath = NULL;
+    USBInterfaceList_cleanup(&pSelf->mInterfaces);
+}
+
+
+/** Constructor - the strings will be duplicated. */
+static inline int USBDevInfoInit(USBDeviceInfo *pSelf, const char *aDevice,
+                                 const char *aSystemID)
+{
+    pSelf->mDevice = aDevice ? RTStrDup(aDevice) : NULL;
+    pSelf->mSysfsPath = aSystemID ? RTStrDup(aSystemID) : NULL;
+    if (   !USBInterfaceList_init(&pSelf->mInterfaces)
+        || (aDevice && !pSelf->mDevice) || (aSystemID && ! pSelf->mSysfsPath))
+    {
+        USBDevInfoCleanup(pSelf);
+        return 0;
+    }
+    return 1;
+}
+
+
+/** Vector type holding device information */
+#define VECTOR_TYPE       USBDeviceInfo
+#define VECTOR_TYPENAME   USBDeviceInfoList
+#define VECTOR_DESTRUCTOR USBDevInfoCleanup
+#include "vector.h"
+
+
 /**
  * Class for probing and returning information about host USB devices.
@@ -114 +171 @@
  * actual probing and use the iterator methods to get the result of the probe.
  */
-class VBoxMainUSBDeviceInfo
-{
-public:
-    /** Structure describing a host USB device */
-    struct USBDeviceInfo
-    {
-        /** The device node of the device. */
-        iprt::MiniString mDevice;
-        /** The system identifier of the device.  Specific to the probing
-         * method. */
-        iprt::MiniString mSysfsPath;
-        /** Type for the list of interfaces. */
-        typedef std::vector<iprt::MiniString> InterfaceList;
-        /** The system IDs of the device's interfaces. */
-        InterfaceList mInterfaces;
-
-        /** Constructors */
-        USBDeviceInfo(const iprt::MiniString &aDevice,
-                      const iprt::MiniString &aSystemID)
-            : mDevice(aDevice),
-              mSysfsPath(aSystemID)
-        { }
-    };
-
-    /** List (resp vector) holding drive information */
-    typedef std::vector<USBDeviceInfo> DeviceInfoList;
-
-    /**
-     * Search for host USB devices and rebuild the list, which remains empty
-     * until the first time this method is called.
-     * @returns iprt status code
-     */
-    int UpdateDevices ();
-
-    /** Get the first element in the list of USB devices. */
-    DeviceInfoList::const_iterator DevicesBegin()
-    {
-        return mDeviceList.begin();
-    }
-
-    /** Get the last element in the list of USB devices. */
-    DeviceInfoList::const_iterator DevicesEnd()
-    {
-        return mDeviceList.end();
-    }
-
-private:
+typedef struct VBoxMainUSBDeviceInfo
+{
     /** The list of currently available USB devices */
-    DeviceInfoList mDeviceList;
-};
-
-/** Convenience typedef. */
-typedef VBoxMainUSBDeviceInfo::DeviceInfoList USBDeviceInfoList;
-/** Convenience typedef. */
-typedef VBoxMainUSBDeviceInfo::USBDeviceInfo USBDeviceInfo;
-/** Convenience typedef. */
-typedef VBoxMainUSBDeviceInfo::USBDeviceInfo::InterfaceList USBInterfaceList;
+    USBDeviceInfoList mDeviceList;
+} VBoxMainUSBDeviceInfo;
+
+/** Constructor */
+static inline int VBoxMainUSBDevInfoInit(VBoxMainUSBDeviceInfo *pSelf)
+{
+    return USBDeviceInfoList_init(&pSelf->mDeviceList);
+}
+
+/** Destructor */
+static inline void VBoxMainUSBDevInfoCleanup(VBoxMainUSBDeviceInfo *pSelf)
+{
+    USBDeviceInfoList_cleanup(&pSelf->mDeviceList);
+}
+
+/**
+ * Search for host USB devices and rebuild the list, which remains empty
+ * until the first time this method is called.
+ * @returns iprt status code
+ */
+int USBDevInfoUpdateDevices(VBoxMainUSBDeviceInfo *pSelf);
+
+
+/** Get the first element in the list of USB devices. */
+static inline const USBDeviceInfoList_iterator *USBDevInfoBegin
+                (VBoxMainUSBDeviceInfo *pSelf)
+{
+    return USBDeviceInfoList_begin(&pSelf->mDeviceList);
+}
+
+
+/** Get the last element in the list of USB devices. */
+static inline const USBDeviceInfoList_iterator *USBDevInfoEnd
+                (VBoxMainUSBDeviceInfo *pSelf)
+{
+    return USBDeviceInfoList_end(&pSelf->mDeviceList);
+}
+
 
 /** Implementation of the hotplug waiter class below */

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

@@ -995 +995 @@
 
 
-int VBoxMainUSBDeviceInfo::UpdateDevices ()
-{
-    LogFlowThisFunc(("entered\n"));
+int USBDevInfoUpdateDevices (VBoxMainUSBDeviceInfo *pSelf)
+{
+    LogFlowFunc(("entered\n"));
     int rc = VINF_SUCCESS;
     bool success = false;  /* Have we succeeded in finding anything yet? */
-    try
-    {
-        mDeviceList.clear();
+    USBDeviceInfoList_clear(&pSelf->mDeviceList);
 #ifdef VBOX_USB_WITH_SYSFS
 # ifdef VBOX_USB_WITH_INOTIFY
-        if (   RT_SUCCESS(rc)
-            && (!success || testing()))
-            rc = getUSBDeviceInfoFromSysfs(&mDeviceList, &success);
+    if (   RT_SUCCESS(rc)
+        && (!success || testing()))
+        rc = getUSBDeviceInfoFromSysfs(&pSelf->mDeviceList, &success);
 # endif
 #else /* !VBOX_USB_WITH_SYSFS */
-        NOREF(success);
+    NOREF(success);
 #endif /* !VBOX_USB_WITH_SYSFS */
-    }
-    catch(std::bad_alloc &e)
-    {
-        rc = VERR_NO_MEMORY;
-    }
-    LogFlowThisFunc(("rc=%Rrc\n", rc));
+    LogFlowFunc(("rc=%Rrc\n", rc));
     return rc;
 }
@@ -1504 +1497 @@
     if (cchDevPath < 0)
         return true;
-    try
-    {
-        pSelf->mList->push_back(USBDeviceInfo(szDevPath, pcszNode));
-    }
-    catch(std::bad_alloc &e)
-    {
-        return false;
-    }
-    return true;
+    
+    USBDeviceInfo info;
+    if (USBDevInfoInit(&info, szDevPath, pcszNode))
+        if (USBDeviceInfoList_push_back(pSelf->mList, &info))
+            return true;
+    USBDevInfoCleanup(&info);
+    return false;
 }
 
@@ -1568 +1559 @@
     AssertReturn(pParent->handle == muiHandle, false);
     matchUSBInterface *pSelf = (matchUSBInterface *)pParent;
-    if (!muiIsAnInterfaceOf(pcszNode, pSelf->mInfo->mSysfsPath.c_str()))
-        return true;
-    try
-    {
-        pSelf->mInfo->mInterfaces.push_back(pcszNode);
-    }
-    catch(std::bad_alloc &e)
-    {
-        return false;
-    }
-    return true;
+    if (!muiIsAnInterfaceOf(pcszNode, pSelf->mInfo->mSysfsPath))
+        return true;
+    char *pcszDup = RTStrDup(pcszNode);
+    if (pcszDup)
+        if (USBInterfaceList_push_back(&pSelf->mInfo->mInterfaces, &pcszDup))
+            return true;
+    RTStrFree(pcszDup);
+    return false;
 }
 
@@ -1613 +1601 @@
     LogFlowFunc (("pList=%p, pfSuccess=%p\n",
                   pList, pfSuccess));
-    size_t cDevices = pList->size();
     matchUSBDevice devHandler;
     mudInit(&devHandler, pList);
@@ -1620 +1607 @@
         if (RT_FAILURE(rc))
             break;
-        for (USBDeviceInfoList::iterator pInfo = pList->begin();
-             pInfo != pList->end(); ++pInfo)
+        USBDeviceInfoList_iterator info;
+        USBDeviceInfoList_iter_init(&info,
+                                    USBDeviceInfoList_begin(pList));
+        while (!USBDeviceInfoList_iter_eq(&info,
+                                          USBDeviceInfoList_end(pList)))
         {
             matchUSBInterface ifaceHandler;
-            muiInit(&ifaceHandler, &*pInfo);
+            muiInit(&ifaceHandler, USBDeviceInfoList_iter_target(&info));
             rc = getDeviceInfoFromSysfs("/sys/bus/usb/devices",
                                         &ifaceHandler.mParent);
             if (RT_FAILURE(rc))
                 break;
+            USBDeviceInfoList_iter_incr(&info);
         }
     } while(0);
-    if (RT_FAILURE(rc))
-        /* Clean up again */
-        while (pList->size() > cDevices)
-            pList->pop_back();
     if (pfSuccess)
         *pfSuccess = RT_SUCCESS(rc);

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

@@ -92 +92 @@
 #ifdef VBOX_USB_WITH_SYSFS
     VBoxMainUSBDeviceInfo deviceInfo;
-    rc = deviceInfo.UpdateDevices();
+    AssertReturn(VBoxMainUSBDevInfoInit(&deviceInfo), 1);
+    rc = USBDevInfoUpdateDevices(&deviceInfo);
     if (RT_FAILURE(rc))
     {
@@ -100 +101 @@
     }
     RTPrintf ("Listing USB devices detected:\n");
-    for (USBDeviceInfoList::const_iterator it = deviceInfo.DevicesBegin();
-         it != deviceInfo.DevicesEnd(); ++it)
+    USBDeviceInfoList_iterator it;
+    USBDeviceInfoList_iter_init(&it, USBDevInfoBegin(&deviceInfo));
+    for (; !USBDeviceInfoList_iter_eq(&it, USBDevInfoEnd(&deviceInfo));
+           USBDeviceInfoList_iter_incr(&it))
     {
         char szProduct[1024];
+        USBDeviceInfo *pInfo = USBDeviceInfoList_iter_target(&it);
         if (RTLinuxSysFsReadStrFile(szProduct, sizeof(szProduct),
-                                    "%s/product", it->mSysfsPath.c_str()) == -1)
+                                    "%s/product", pInfo->mSysfsPath) == -1)
         {
             if (errno != ENOENT)
             {
                 RTPrintf ("Failed to get the product name for device %s: error %s\n",
-                          it->mDevice.c_str(), strerror(errno));
+                          pInfo->mDevice, strerror(errno));
                 return 1;
             }
@@ -116 +120 @@
                 szProduct[0] = '\0';
         }
-        RTPrintf ("  device: %s (%s), sysfs path: %s\n", szProduct, it->mDevice.c_str(),
-                  it->mSysfsPath.c_str());
+        RTPrintf ("  device: %s (%s), sysfs path: %s\n", szProduct, pInfo->mDevice,
+                  pInfo->mSysfsPath);
         RTPrintf ("    interfaces:\n");
-        for (USBInterfaceList::const_iterator it2 = it->mInterfaces.begin();
-             it2 != it->mInterfaces.end(); ++it2)
+        USBInterfaceList_iterator it2;
+        USBInterfaceList_iter_init(&it2, USBInterfaceList_begin(&pInfo->mInterfaces));
+        for (; !USBInterfaceList_iter_eq(&it2, USBInterfaceList_end(&pInfo->mInterfaces));
+               USBInterfaceList_iter_incr(&it2))
         {
             char szDriver[RTPATH_MAX];
+            char *pszIf = *USBInterfaceList_iter_target(&it2);
             strcpy(szDriver, "none");
             ssize_t size = RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver),
-                                                   "%s/driver", it2->c_str());
+                                                   "%s/driver", pszIf);
             if (size == -1 && errno != ENOENT)
             {
                 RTPrintf ("Failed to get the driver for interface %s of device %s: error %s\n",
-                          it2->c_str(), it->mDevice.c_str(), strerror(errno));
+                          pszIf, pInfo->mDevice, strerror(errno));
                 return 1;
             }
-            if (RTLinuxSysFsExists("%s/driver", it2->c_str()) != (size != -1))
+            if (RTLinuxSysFsExists("%s/driver", pszIf) != (size != -1))
             {
                 RTPrintf ("RTLinuxSysFsExists did not return the expected value for the driver link of interface %s of device %s.\n",
-                          it2->c_str(), it->mDevice.c_str());
+                          pszIf, pInfo->mDevice);
                 return 1;
             }
             uint64_t u64InterfaceClass;
             u64InterfaceClass = RTLinuxSysFsReadIntFile(16, "%s/bInterfaceClass",
-                                                        it2->c_str());
+                                                        pszIf);
             RTPrintf ("      sysfs path: %s, driver: %s, interface class: 0x%x\n",
-                      it2->c_str(), szDriver, u64InterfaceClass);
+                      pszIf, szDriver, u64InterfaceClass);
         }
     }