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

Timestamp:

Apr 15, 2010 9:18:31 AM (15 years ago)

Author:

vboxsync

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

60109

Message:

Main/HostHardwareLinux: generalised the VBoxMainHotplugWaiter class to allow for runtime implementation selection

Location:

trunk/src/VBox/Main

Files:

• include/HostHardwareLinux.h (modified) (5 diffs)
• linux/HostHardwareLinux.cpp (modified) (5 diffs)

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

@@ -44 +44 @@
         /** The device node of the drive. */
         iprt::MiniString mDevice;
-        /** The hal unique device identifier, if available. */
+        /** A unique identifier for the device, if available.  This should be
+         * kept consistant accross different probing methods of a given
+         * platform if at all possible. */
         iprt::MiniString mUdi;
         /** A textual description of the drive. */
@@ -124 +126 @@
         /** The device node of the device. */
         iprt::MiniString mDevice;
-        /** The sysfs path of the device. */
+        /** 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 sysfs paths of the device's interfaces. */
+        /** The system IDs of the device's interfaces. */
         InterfaceList mInterfaces;
 
         /** Constructors */
         USBDeviceInfo(const iprt::MiniString &aDevice,
-                      const iprt::MiniString &aSysfsPath)
+                      const iprt::MiniString &aSystemID)
             : mDevice(aDevice),
-              mSysfsPath(aSysfsPath)
+              mSysfsPath(aSystemID)
         { }
     };
@@ -172 +175 @@
 /** Convenience typedef. */
 typedef VBoxMainUSBDeviceInfo::USBDeviceInfo::InterfaceList USBInterfaceList;
+
+/** Implementation of the hotplug waiter class below */
+class VBoxMainHotplugWaiterImpl
+{
+public:
+    VBoxMainHotplugWaiterImpl (void) {}
+    virtual ~VBoxMainHotplugWaiterImpl (void) {}
+    /** @copydoc VBoxMainHotplugWaiter::Wait */
+    virtual int Wait (RTMSINTERVAL cMillies) = 0;
+    /** @copydoc VBoxMainHotplugWaiter::Interrupt */
+    virtual void Interrupt (void) = 0;
+};
 
 /**
@@ -181 +196 @@
 class VBoxMainHotplugWaiter
 {
-    /** Opaque context struct. */
-    struct Context;
-
-    /** Opaque waiter context. */
-    Context *mContext;
-public:
-    /** Constructor */
+    /** Class implementation. */
+    VBoxMainHotplugWaiterImpl *mImpl;
+public:
+    /** Constructor.  Responsible for selecting the implementation. */
     VBoxMainHotplugWaiter (void);
     /** Destructor. */
-    ~VBoxMainHotplugWaiter (void);
+    ~VBoxMainHotplugWaiter (void)
+    {
+        delete mImpl;
+    }
     /**
      * Wait for a hotplug event.
@@ -202 +217 @@
      * @param    cMillies   How long to wait for at most.
      */
-    int Wait (RTMSINTERVAL cMillies);
+    int Wait (RTMSINTERVAL cMillies)
+    {
+        return mImpl->Wait(cMillies);
+    }
     /**
      * Interrupts an active wait.  In the current implementation, the wait
      * may not return until up to two seconds after calling this method.
      */
-    void Interrupt (void);
+    void Interrupt (void)
+    {
+        mImpl->Interrupt();
+    }
 };
 

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

@@ -1053 +1053 @@
 }
 
-struct VBoxMainHotplugWaiter::Context
-{
 #if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
+class hotplugDBusImpl : public VBoxMainHotplugWaiterImpl
+{
     /** The connection to DBus */
     RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> mConnection;
@@ -1063 +1063 @@
     /** A flag to say that we wish to interrupt the current wait. */
     volatile bool mInterrupt;
+
+public:
+    /** Test whether this implementation can be used on the current system */
+    static bool HalAvailable(void)
+    {
+        RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
+
+        /* Try to open a test connection to hal */
+        if (RT_SUCCESS(RTDBusLoadLib()) && RT_SUCCESS(halInit (&dbusConnection)))
+            return !!dbusConnection;
+        return false;
+    }
+
     /** Constructor */
-    Context() : mTriggered(false), mInterrupt(false) {}
-#endif  /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
+    hotplugDBusImpl (void);
+    virtual ~hotplugDBusImpl (void);
+    /** @copydoc VBoxMainHotplugWaiter::Wait */
+    virtual int Wait (RTMSINTERVAL cMillies);
+    /** @copydoc VBoxMainHotplugWaiter::Interrupt */
+    virtual void Interrupt (void);
 };
 
@@ -1072 +1089 @@
  * the Context structure when a device (not necessarily USB) is added or
  * removed. */
-VBoxMainHotplugWaiter::VBoxMainHotplugWaiter ()
-{
-#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
+hotplugDBusImpl::hotplugDBusImpl (void) : mTriggered(false), mInterrupt(false)
+{
     int rc = VINF_SUCCESS;
 
-    mContext = new Context;
     if (RT_SUCCESS(RTDBusLoadLib()))
     {
-        for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mContext->mConnection; ++i)
-        {
-            rc = halInitPrivate (&mContext->mConnection);
-        }
-        if (!mContext->mConnection)
+        for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mConnection; ++i)
+        {
+            rc = halInitPrivate (&mConnection);
+        }
+        if (!mConnection)
             rc = VERR_NOT_SUPPORTED;
         DBusMessage *pMessage;
         while (   RT_SUCCESS(rc)
-               && (pMessage = dbus_connection_pop_message (mContext->mConnection.get())) != NULL)
+               && (pMessage = dbus_connection_pop_message (mConnection.get())) != NULL)
             dbus_message_unref (pMessage); /* empty the message queue. */
         if (   RT_SUCCESS(rc)
-            && !dbus_connection_add_filter (mContext->mConnection.get(),
+            && !dbus_connection_add_filter (mConnection.get(),
                                             dbusFilterFunction,
-                                            (void *) &mContext->mTriggered, NULL))
+                                            (void *) &mTriggered, NULL))
             rc = VERR_NO_MEMORY;
         if (RT_FAILURE(rc))
-            mContext->mConnection.reset();
-    }
-#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
+            mConnection.reset();
+    }
 }
 
 /* Destructor */
-VBoxMainHotplugWaiter::~VBoxMainHotplugWaiter ()
-{
-#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
-    if (!!mContext->mConnection)
-        dbus_connection_remove_filter (mContext->mConnection.get(), dbusFilterFunction,
-                                       (void *) &mContext->mTriggered);
-    delete mContext;
-#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
+hotplugDBusImpl::~hotplugDBusImpl ()
+{
+    if (!!mConnection)
+        dbus_connection_remove_filter (mConnection.get(), dbusFilterFunction,
+                                       (void *) &mTriggered);
 }
 
@@ -1115 +1126 @@
  * connection.  Because the connection is private we don't have to worry about
  * blocking other users. */
-int VBoxMainHotplugWaiter::Wait(RTMSINTERVAL cMillies)
+int hotplugDBusImpl::Wait(RTMSINTERVAL cMillies)
 {
     int rc = VINF_SUCCESS;
-#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
-    if (!mContext->mConnection)
+    if (!mConnection)
         rc = VERR_NOT_SUPPORTED;
     bool connected = true;
-    mContext->mTriggered = false;
-    mContext->mInterrupt = false;
+    mTriggered = false;
+    mInterrupt = false;
     unsigned cRealMillies;
     if (cMillies != RT_INDEFINITE_WAIT)
@@ -1129 +1139 @@
     else
         cRealMillies = DBUS_POLL_TIMEOUT;
-    while (   RT_SUCCESS(rc) && connected && !mContext->mTriggered
-           && !mContext->mInterrupt)
-    {
-        connected = dbus_connection_read_write_dispatch (mContext->mConnection.get(),
+    while (   RT_SUCCESS(rc) && connected && !mTriggered
+           && !mInterrupt)
+    {
+        connected = dbus_connection_read_write_dispatch (mConnection.get(),
                                                          cRealMillies);
-        if (mContext->mInterrupt)
+        if (mInterrupt)
             LogFlowFunc(("wait loop interrupted\n"));
         if (cMillies != RT_INDEFINITE_WAIT)
-            mContext->mInterrupt = true;
+            mInterrupt = true;
     }
     if (!connected)
         rc = VERR_TRY_AGAIN;
-#else  /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
-    rc = VERR_NOT_IMPLEMENTED;
+    return rc;
+}
+
+/* Set a flag to tell the Wait not to resume next time it times out. */
+void hotplugDBusImpl::Interrupt()
+{
+    LogFlowFunc(("\n"));
+    mInterrupt = true;
+}
 #endif  /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
-    return rc;
-}
-
-/* Set a flag to tell the Wait not to resume next time it times out. */
-void VBoxMainHotplugWaiter::Interrupt()
+
+class hotplugNullImpl : public VBoxMainHotplugWaiterImpl
+{
+public:
+    hotplugNullImpl (void) {}
+    virtual ~hotplugNullImpl (void) {}
+    /** @copydoc VBoxMainHotplugWaiter::Wait */
+    virtual int Wait (RTMSINTERVAL)
+    {
+        return VERR_NOT_SUPPORTED;
+    }
+    /** @copydoc VBoxMainHotplugWaiter::Interrupt */
+    virtual void Interrupt (void) {}
+};
+
+VBoxMainHotplugWaiter::VBoxMainHotplugWaiter(void)
 {
 #if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
-    LogFlowFunc(("\n"));
-    mContext->mInterrupt = true;
-#endif  /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
-}
-
+    if (hotplugDBusImpl::HalAvailable())
+    {
+        mImpl = new hotplugDBusImpl;
+        return;
+    }
+#endif  /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
+    mImpl = new hotplugNullImpl;
+}
 
 class sysfsPathHandler