Changeset 16178 in vbox for trunk/src/VBox/Main/linux

Timestamp:

Jan 22, 2009 3:39:48 PM (16 years ago)

Author:

vboxsync

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

41924

Message:

Main/Linux: fixes and clean ups in the DBus code

Location:

trunk/src/VBox/Main/linux

Files:

• HostHardwareLinux.cpp (modified) (10 diffs)
• vbox-dbus.cpp (modified) (1 diff)

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

@@ -79 +79 @@
 extern void VBoxHalShutdown (DBusConnection *pConnection);
 extern void VBoxHalShutdownPrivate (DBusConnection *pConnection);
+extern void VBoxDBusConnectionUnref(DBusConnection *pConnection);
+extern void VBoxDBusConnectionCloseAndUnref(DBusConnection *pConnection);
+extern void VBoxDBusMessageUnref(DBusMessage *pMessage);
 
 static int halInit(RTMemAutoPtr <DBusConnection, VBoxHalShutdown> *pConnection);
@@ -109 +112 @@
 #if defined(RT_OS_LINUX)
 #ifdef VBOX_WITH_DBUS
-        if (RT_SUCCESS (rc) && VBoxDBusCheckPresence() && (!success || testing()))
+        if (RT_SUCCESS (rc) && RT_SUCCESS(VBoxLoadDBusLib()) && (!success || testing()))
             rc = getDriveInfoFromHal(&mDVDList, true /* isDVD */, &success);
 #endif /* VBOX_WITH_DBUS defined */
@@ -154 +157 @@
 #if defined(RT_OS_LINUX)
 #ifdef VBOX_WITH_DBUS
-        if (RT_SUCCESS (rc) && VBoxDBusCheckPresence() && (!success || testing()))
+        if (   RT_SUCCESS (rc)
+            && RT_SUCCESS(VBoxLoadDBusLib())
+            && (!success || testing()))
             rc = getDriveInfoFromHal(&mFloppyList, false /* isDVD */, &success);
 #endif /* VBOX_WITH_DBUS defined */
@@ -197 +202 @@
 #if defined(RT_OS_LINUX)
 #ifdef VBOX_WITH_DBUS
-        if (RT_SUCCESS (rc) && VBoxDBusCheckPresence() && (!success || testing()))
+        if (   RT_SUCCESS (rc)
+            && RT_SUCCESS(VBoxLoadDBusLib())
+            && (!success || testing()))
             rc = getUSBDeviceInfoFromHal(&mDeviceList, &halSuccess);
         /* Try the old API if the new one *succeeded* as only one of them will
@@ -226 +233 @@
     /** A flag to say that we wish to interrupt the current wait. */
     bool mInterrupt;
+    /** Constructor */
+    Context() : mTriggered(false), mInterrupt(false) {}
 #endif  /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
 };
@@ -238 +247 @@
     int rc = VINF_SUCCESS;
 
-    if (VBoxDBusCheckPresence())
-    {
-        mContext = new Context;
+    mContext = new Context;
+    if (RT_SUCCESS(VBoxLoadDBusLib()))
+    {
         for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mContext->mConnection; ++i)
         {
@@ -617 +626 @@
     autoDBusError dbusError;
 
-    RTMemAutoPtr <DBusConnection, VBoxDBusConnectionUnref> dbusConnection;
+    RTMemAutoPtr <DBusConnection, VBoxDBusConnectionCloseAndUnref> dbusConnection;
     dbusConnection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbusError.get());
     if (!dbusConnection)
@@ -650 +659 @@
  * @param   pConnection  the connection handle
  */
-/* static */
+/* extern */
 void VBoxHalShutdown (DBusConnection *pConnection)
 {
@@ -672 +681 @@
  * @param   pConnection  the connection handle
  */
-/* static */
+/* extern */
 void VBoxHalShutdownPrivate (DBusConnection *pConnection)
 {
@@ -689 +698 @@
     LogFlowFunc(("returning\n"));
     dbusError.FlowLog();
+}
+
+/** Wrapper around dbus_connection_unref.  We need this to use it as a real
+ * function in auto pointers, as a function pointer won't wash here. */
+/* extern */
+void VBoxDBusConnectionUnref(DBusConnection *pConnection)
+{
+    dbus_connection_unref(pConnection);
+}
+
+/**
+ * This function closes and unrefs a private connection to dbus.  It should
+ * only be called once no-one else is referencing the connection.
+ */
+/* extern */
+void VBoxDBusConnectionCloseAndUnref(DBusConnection *pConnection)
+{
+    dbus_connection_close(pConnection);
+    dbus_connection_unref(pConnection);
+}
+
+/** Wrapper around dbus_message_unref.  We need this to use it as a real
+ * function in auto pointers, as a function pointer won't wash here. */
+/* extern */
+void VBoxDBusMessageUnref(DBusMessage *pMessage)
+{
+    dbus_message_unref(pMessage);
 }
 

trunk/src/VBox/Main/linux/vbox-dbus.cpp

@@ -23 +23 @@
 #include "vbox-dbus.h"
 
-#include <iprt/err.h>
+#define LOG_GROUP LOG_GROUP_MAIN
+#include <VBox/log.h>
+#include <VBox/err.h>
+
 #include <iprt/ldr.h>
-
-/**
- * Whether we have tried to load libdbus-1 yet.  This flag should only be set
- * to "true" after we have either loaded the library and all symbols which we
- * need, or failed to load something and unloaded and set back to zero
- * pLibDBus.
- */
-static bool gCheckedForLibDBus = false;
-/**
- * Pointer to the libdbus-1 shared object.  This should only be set once all
- * needed libraries and symbols have been successfully loaded.
- */
-static RTLDRMOD ghLibDBus = NULL;
+#include <iprt/assert.h>
+#include <iprt/once.h>
 
 /** The following are the symbols which we need from libdbus. */
-void (*vbox_dbus_error_init)(DBusError *);
-DBusConnection *(*vbox_dbus_bus_get)(DBusBusType, DBusError *);
-DBusConnection *(*vbox_dbus_bus_get_private)(DBusBusType, DBusError *);
-void (*vbox_dbus_error_free)(DBusError *);
-void (*vbox_dbus_connection_unref)(DBusConnection *);
-void (*vbox_dbus_connection_close)(DBusConnection *);
-void (*vbox_dbus_connection_set_exit_on_disconnect)(DBusConnection *, dbus_bool_t);
-dbus_bool_t (*vbox_dbus_bus_name_has_owner)(DBusConnection *, const char *,
-                                            DBusError *);
-void (*vbox_dbus_bus_add_match)(DBusConnection *, const char *, DBusError *);
-void (*vbox_dbus_bus_remove_match)(DBusConnection *, const char *, DBusError *);
-void (*vbox_dbus_message_unref)(DBusMessage *);
-DBusMessage* (*vbox_dbus_message_new_method_call)(const char *, const char *,
-                                                  const char *, const char *);
-void (*vbox_dbus_message_iter_init_append)(DBusMessage *, DBusMessageIter *);
-dbus_bool_t (*vbox_dbus_message_iter_append_basic)(DBusMessageIter *, int,
-                                                   const void *);
-DBusMessage * (*vbox_dbus_connection_send_with_reply_and_block)(DBusConnection *,
-                                                                DBusMessage *, int,
-                                                                DBusError *error);
-dbus_bool_t (*vbox_dbus_message_iter_init) (DBusMessage *, DBusMessageIter *);
-int (*vbox_dbus_message_iter_get_arg_type) (DBusMessageIter *);
-int (*vbox_dbus_message_iter_get_element_type) (DBusMessageIter *);
-void (*vbox_dbus_message_iter_recurse) (DBusMessageIter *, DBusMessageIter *);
-void (*vbox_dbus_message_iter_get_basic) (DBusMessageIter *, void *);
-dbus_bool_t (*vbox_dbus_message_iter_next) (DBusMessageIter *);
-dbus_bool_t (*vbox_dbus_connection_add_filter) (DBusConnection *, DBusHandleMessageFunction,
-                                                void *, DBusFreeFunction);
-void (*vbox_dbus_connection_remove_filter) (DBusConnection *, DBusHandleMessageFunction,
-                                            void *);
-dbus_bool_t (*vbox_dbus_connection_read_write_dispatch) (DBusConnection *, int);
-dbus_bool_t (*vbox_dbus_message_is_signal) (DBusMessage *, const char *, const char *);
-DBusMessage *(*vbox_dbus_connection_pop_message)(DBusConnection *);
+#define VBOX_PROXY_STUB(function, rettype, signature, shortsig) \
+void (*function ## _fn)(void); \
+rettype function signature \
+{ return ( (rettype (*) signature) function ## _fn ) shortsig; }
 
-bool VBoxDBusCheckPresence(void)
+#include "vbox-dbus-internal.h"
+
+static int32_t loadDBusLibOnce(void *, void *);
+
+#undef VBOX_PROXY_STUB
+
+/* Now comes a table of functions to be loaded from libdbus-1 */
+typedef struct
 {
-    RTLDRMOD hLibDBus;
+    const char *name;
+    void (**fn)(void);
+} SHARED_FUNC;
 
-    if (ghLibDBus != 0 && gCheckedForLibDBus == true)
-        return true;
-    if (gCheckedForLibDBus == true)
-        return false;
-    if (   !RT_SUCCESS(RTLdrLoad(LIB_DBUS_1_3, &hLibDBus))
-        && !RT_SUCCESS(RTLdrLoad(LIB_DBUS_1_2, &hLibDBus)))
-    {
-        return false;
-    }
-    if (   RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_error_init",
-                                     (void **) &vbox_dbus_error_init))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_bus_get",
-                                     (void **) &vbox_dbus_bus_get))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_bus_get_private",
-                                     (void **) &vbox_dbus_bus_get_private))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_error_free",
-                                     (void **) &vbox_dbus_error_free))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_unref",
-                                     (void **) &vbox_dbus_connection_unref))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_close",
-                                     (void **) &vbox_dbus_connection_close))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_set_exit_on_disconnect",
-                                     (void **) &vbox_dbus_connection_set_exit_on_disconnect))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_bus_name_has_owner",
-                                     (void **) &vbox_dbus_bus_name_has_owner))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_bus_add_match",
-                                     (void **) &vbox_dbus_bus_add_match))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_bus_remove_match",
-                                     (void **) &vbox_dbus_bus_remove_match))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_unref",
-                                     (void **) &vbox_dbus_message_unref))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_new_method_call",
-                                     (void **) &vbox_dbus_message_new_method_call))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_init_append",
-                                     (void **) &vbox_dbus_message_iter_init_append))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_append_basic",
-                                     (void **) &vbox_dbus_message_iter_append_basic))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_send_with_reply_and_block",
-                                     (void **) &vbox_dbus_connection_send_with_reply_and_block))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_init",
-                                     (void **) &vbox_dbus_message_iter_init))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_get_arg_type",
-                                     (void **) &vbox_dbus_message_iter_get_arg_type))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_get_element_type",
-                                     (void **) &vbox_dbus_message_iter_get_element_type))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_recurse",
-                                     (void **) &vbox_dbus_message_iter_recurse))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_get_basic",
-                                     (void **) &vbox_dbus_message_iter_get_basic))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_iter_next",
-                                     (void **) &vbox_dbus_message_iter_next))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_add_filter",
-                                     (void **) &vbox_dbus_connection_add_filter))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_remove_filter",
-                                     (void **) &vbox_dbus_connection_remove_filter))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_read_write_dispatch",
-                                     (void **) &vbox_dbus_connection_read_write_dispatch))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_message_is_signal",
-                                     (void **) &vbox_dbus_message_is_signal))
-        && RT_SUCCESS(RTLdrGetSymbol(hLibDBus, "dbus_connection_pop_message",
-                                     (void **) &vbox_dbus_connection_pop_message))
-       )
-    {
-        ghLibDBus = hLibDBus;
-        gCheckedForLibDBus = true;
-        return true;
-    }
-    else
-    {
-        RTLdrClose(hLibDBus);
-        gCheckedForLibDBus = true;
-        return false;
-    }
+#define VBOX_PROXY_STUB(s, dummy1, dummy2, dummy3 ) { #s , & s ## _fn } ,
+static SHARED_FUNC SharedFuncs[] =
+{
+#include "vbox-dbus-internal.h"
+    { NULL, NULL }
+};
+#undef VBOX_PROXY_STUB
+
+/* extern */
+int VBoxLoadDBusLib(void)
+{
+    static RTONCE sOnce = RTONCE_INITIALIZER;
+
+    LogFlowFunc(("\n"));
+    int rc = RTOnce (&sOnce, loadDBusLibOnce, NULL, NULL);
+    LogFlowFunc(("rc = %Rrc\n", rc));
+    return rc;
 }
 
-void VBoxDBusConnectionUnref(DBusConnection *pConnection)
+/* The function which does the actual work for VBoxLoadDBusLib, serialised for
+ * thread safety. */
+static int32_t loadDBusLibOnce(void *, void *)
 {
-    dbus_connection_unref(pConnection);
+    int rc = VINF_SUCCESS;
+    RTLDRMOD hLib;
+
+    LogFlowFunc(("\n"));
+    rc = RTLdrLoad(VBOX_DBUS_1_2_LIB, &hLib);
+    if (RT_FAILURE(rc))
+        rc = RTLdrLoad(VBOX_DBUS_1_3_LIB, &hLib);
+    if (RT_FAILURE(rc))
+        LogRelFunc(("Failed to load library %s or %s\n",
+                    VBOX_DBUS_1_2_LIB, VBOX_DBUS_1_3_LIB));
+    for (unsigned i = 0; RT_SUCCESS(rc) && SharedFuncs[i].name != NULL; ++i)
+        rc = RTLdrGetSymbol(hLib, SharedFuncs[i].name, (void**)SharedFuncs[i].fn);
+    LogFlowFunc(("rc = %Rrc\n", rc));
+    return rc;
 }
 
-void VBoxDBusMessageUnref(DBusMessage *pMessage)
-{
-    dbus_message_unref(pMessage);
-}
-