12 files changed, 528 insertions, 118 deletions

diff --git a/ChangeLog b/ChangeLog
index 14f89ed3..a394d5cc 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,45 @@
+2006-08-16  John (J5) Palmieri  <johnp@redhat.com>
+
+	* dbus/dbus-threads.c: Add static DBusList *uninitialized_mutex_list and
+	static DBusList *uninitialized_condvar_list to support new late 
+	initialization threading model.  In this model threads can be initialized
+	even after the D-Bus API has been used but still needs to be initialized 
+	before the second thread has been started.  Mutexes and condvar addresses
+	are stored in the two static lists and are replaced with actuall locks
+	when threads are initalized.
+	(_dbus_mutex_new_at_location): New method for creating a mutex and placing
+	the location into the static list
+	(_dbus_mutex_free_at_location): New method for removing a mutex location 
+	from the static list and freeing the mutex
+	(_dbus_condvar_new_at_location): New method for creating a conditional 
+	variable and placing the location into the static list
+	(_dbus_condvar_free_at_location): New method for removing a conditional
+	variable location from the static list and freeing the conditional variable 
+
+	* dbus/dbus-connection.c:
+	(_dbus_connection_test_get_locks): New method for tests to check connections
+	(_dbus_connection_new_for_transport): Use the new at_location mutex and
+	condvar API
+	(dbus_connection_allocate_data_slot): Pass in the global lock address
+	to _dbus_data_slot_allocator_alloc
+
+	* dbus/dbus-dataslot.c:
+	(_dbus_data_slot_allocator_alloc): Use the address of the mutex
+	instead of the mutex itself
+
+	* dbus/dbus-message.c:
+	(dbus_message_allocate_data_slot): Pass in the global lock address
+	to _dbus_data_slot_allocator_alloc
+
+	* dbus/dbus-pending-call.c:
+	(dbus_pending_call_allocate_data_slot): Pass in the global lock address
+	to _dbus_data_slot_allocator_alloc
+
+	* dbus/dbus-server.c:
+	(_dbus_server_init_base): Use the new at_location mutex API
+	(dbus_server_allocate_data_slot): Pass in the global lock address
+	to _dbus_data_slot_allocator_alloc
+
 2006-08-14  John (J5) Palmieri  <johnp@redhat.com>
 
 	* dbus/dbus-dataslot.c (_dbus_data_slot_allocator_alloc):
diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
index 2e942064..27720998 100644
--- a/dbus/dbus-connection.c
+++ b/dbus/dbus-connection.c
@@ -347,6 +347,33 @@ _dbus_connection_queue_received_message (DBusConnection *connection,
 
   return TRUE;
 }
+
+/**
+ * Gets the locks so we can examine them
+ *
+ * @param connection the connection.
+ * @param mutex_loc return for the location of the main mutex pointer
+ * @param dispatch_mutex_loc return location of the dispatch mutex pointer
+ * @param io_path_mutex_loc return location of the io_path mutex pointer
+ * @param dispatch_cond_loc return location of the dispatch conditional 
+ *        variable pointer
+ * @param io_path_cond_loc return location of the io_path conditional 
+ *        variable pointer
+ */ 
+void 
+_dbus_connection_test_get_locks (DBusConnection *conn,
+                                 DBusMutex **mutex_loc,
+                                 DBusMutex **dispatch_mutex_loc,
+                                 DBusMutex **io_path_mutex_loc,
+                                 DBusCondVar **dispatch_cond_loc,
+                                 DBusCondVar **io_path_cond_loc)
+{
+  *mutex_loc = conn->mutex;
+  *dispatch_mutex_loc = conn->dispatch_mutex;
+  *io_path_mutex_loc = conn->io_path_mutex; 
+  *dispatch_cond_loc = conn->dispatch_cond;
+  *io_path_cond_loc = conn->io_path_cond;
+}
 #endif
 
 /**
@@ -936,7 +963,8 @@ _dbus_connection_acquire_io_path (DBusConnection *connection,
           while (connection->io_path_acquired)
             {
               _dbus_verbose ("%s waiting for IO path to be acquirable\n", _DBUS_FUNCTION_NAME);
-              _dbus_condvar_wait (connection->io_path_cond, connection->io_path_mutex);
+              _dbus_condvar_wait (connection->io_path_cond, 
+                                  connection->io_path_mutex);
             }
         }
     }
@@ -1060,11 +1088,6 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   DBusWatchList *watch_list;
   DBusTimeoutList *timeout_list;
   DBusHashTable *pending_replies;
-  DBusMutex *mutex;
-  DBusMutex *io_path_mutex;
-  DBusMutex *dispatch_mutex;
-  DBusCondVar *dispatch_cond;
-  DBusCondVar *io_path_cond;
   DBusList *disconnect_link;
   DBusMessage *disconnect_message;
   DBusCounter *outgoing_counter;
@@ -1074,11 +1097,6 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   connection = NULL;
   pending_replies = NULL;
   timeout_list = NULL;
-  mutex = NULL;
-  io_path_mutex = NULL;
-  dispatch_mutex = NULL;
-  dispatch_cond = NULL;
-  io_path_cond = NULL;
   disconnect_link = NULL;
   disconnect_message = NULL;
   outgoing_counter = NULL;
@@ -1103,24 +1121,24 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   if (connection == NULL)
     goto error;
 
-  mutex = _dbus_mutex_new ();
-  if (mutex == NULL)
+  _dbus_mutex_new_at_location (&connection->mutex);
+  if (connection->mutex == NULL)
     goto error;
 
-  io_path_mutex = _dbus_mutex_new ();
-  if (io_path_mutex == NULL)
+  _dbus_mutex_new_at_location (&connection->io_path_mutex);
+  if (connection->io_path_mutex == NULL)
     goto error;
 
-  dispatch_mutex = _dbus_mutex_new ();
-  if (dispatch_mutex == NULL)
+  _dbus_mutex_new_at_location (&connection->dispatch_mutex);
+  if (connection->dispatch_mutex == NULL)
     goto error;
   
-  dispatch_cond = _dbus_condvar_new ();
-  if (dispatch_cond == NULL)
+  _dbus_condvar_new_at_location (&connection->dispatch_cond);
+  if (connection->dispatch_cond == NULL)
     goto error;
   
-  io_path_cond = _dbus_condvar_new ();
-  if (io_path_cond == NULL)
+  _dbus_condvar_new_at_location (&connection->io_path_cond);
+  if (connection->io_path_cond == NULL)
     goto error;
 
   disconnect_message = dbus_message_new_signal (DBUS_PATH_LOCAL,
@@ -1146,11 +1164,6 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
     _dbus_disable_sigpipe ();
   
   connection->refcount.value = 1;
-  connection->mutex = mutex;
-  connection->dispatch_cond = dispatch_cond;
-  connection->dispatch_mutex = dispatch_mutex;
-  connection->io_path_cond = io_path_cond;
-  connection->io_path_mutex = io_path_mutex;
   connection->transport = transport;
   connection->watches = watch_list;
   connection->timeouts = timeout_list;
@@ -1189,24 +1202,15 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   if (disconnect_link != NULL)
     _dbus_list_free_link (disconnect_link);
   
-  if (io_path_cond != NULL)
-    _dbus_condvar_free (io_path_cond);
-  
-  if (dispatch_cond != NULL)
-    _dbus_condvar_free (dispatch_cond);
-  
-  if (mutex != NULL)
-    _dbus_mutex_free (mutex);
-
-  if (io_path_mutex != NULL)
-    _dbus_mutex_free (io_path_mutex);
-
-  if (dispatch_mutex != NULL)
-    _dbus_mutex_free (dispatch_mutex);
-  
   if (connection != NULL)
-    dbus_free (connection);
-
+    {
+      _dbus_condvar_free_at_location (&connection->io_path_cond);
+      _dbus_condvar_free_at_location (&connection->dispatch_cond);
+      _dbus_mutex_free_at_location (&connection->mutex);
+      _dbus_mutex_free_at_location (&connection->io_path_mutex);
+      _dbus_mutex_free_at_location (&connection->dispatch_mutex);
+      dbus_free (connection);
+    }
   if (pending_replies)
     _dbus_hash_table_unref (pending_replies);
   
@@ -1836,13 +1840,13 @@ _dbus_connection_last_unref (DBusConnection *connection)
 
   _dbus_list_clear (&connection->link_cache);
   
-  _dbus_condvar_free (connection->dispatch_cond);
-  _dbus_condvar_free (connection->io_path_cond);
+  _dbus_condvar_free_at_location (&connection->dispatch_cond);
+  _dbus_condvar_free_at_location (&connection->io_path_cond);
 
-  _dbus_mutex_free (connection->io_path_mutex);
-  _dbus_mutex_free (connection->dispatch_mutex);
+  _dbus_mutex_free_at_location (&connection->io_path_mutex);
+  _dbus_mutex_free_at_location (&connection->dispatch_mutex);
 
-  _dbus_mutex_free (connection->mutex);
+  _dbus_mutex_free_at_location (&connection->mutex);
   
   dbus_free (connection);
 }
@@ -3305,7 +3309,8 @@ _dbus_connection_acquire_dispatch (DBusConnection *connection)
   while (connection->dispatch_acquired)
     {
       _dbus_verbose ("%s waiting for dispatch to be acquirable\n", _DBUS_FUNCTION_NAME);
-      _dbus_condvar_wait (connection->dispatch_cond, connection->dispatch_mutex);
+      _dbus_condvar_wait (connection->dispatch_cond, 
+                          connection->dispatch_mutex);
     }
   
   _dbus_assert (!connection->dispatch_acquired);
@@ -4582,7 +4587,7 @@ dbus_bool_t
 dbus_connection_allocate_data_slot (dbus_int32_t *slot_p)
 {
   return _dbus_data_slot_allocator_alloc (&slot_allocator,
-                                          _DBUS_LOCK_NAME (connection_slots),
+                                          &_DBUS_LOCK_NAME (connection_slots),
                                           slot_p);
 }
 
diff --git a/dbus/dbus-dataslot.c b/dbus/dbus-dataslot.c
index 78e94c37..d53f3bd7 100644
--- a/dbus/dbus-dataslot.c
+++ b/dbus/dbus-dataslot.c
@@ -46,7 +46,7 @@ _dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator)
   allocator->allocated_slots = NULL;
   allocator->n_allocated_slots = 0;
   allocator->n_used_slots = 0;
-  allocator->lock = NULL;
+  allocator->lock_loc = NULL;
   
   return TRUE;
 }
@@ -59,26 +59,26 @@ _dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator)
  * is allocated and stored at *slot_id_p.
  * 
  * @param allocator the allocator
- * @param mutex the lock for this allocator
+ * @param mutex_loc the location lock for this allocator
  * @param slot_id_p address to fill with the slot ID
  * @returns #TRUE on success
  */
 dbus_bool_t
 _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator,
-                                 DBusMutex             *mutex,
+                                 DBusMutex             **mutex_loc,
                                  dbus_int32_t          *slot_id_p)
 {
   dbus_int32_t slot;
 
-  if (!_dbus_mutex_lock (mutex))
+  if (!_dbus_mutex_lock (*mutex_loc))
     return FALSE;
 
   if (allocator->n_allocated_slots == 0)
     {
-      _dbus_assert (allocator->lock == NULL);
-      allocator->lock = mutex;
+      _dbus_assert (allocator->lock_loc == NULL);
+      allocator->lock_loc = mutex_loc;
     }
-  else if (allocator->lock != mutex)
+  else if (allocator->lock_loc != mutex_loc)
     {
       _dbus_warn ("D-Bus threads were initialized after first using the D-Bus library. If your application does not directly initialize threads or use D-Bus, keep in mind that some library or plugin may have used D-Bus or initialized threads behind your back. You can often fix this problem by calling dbus_init_threads() or dbus_g_threads_init() early in your main() method, before D-Bus is used.");
       _dbus_assert_not_reached ("exiting");
@@ -145,7 +145,7 @@ _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator,
                  slot, allocator, allocator->n_allocated_slots, allocator->n_used_slots);
   
  out:
-  _dbus_mutex_unlock (allocator->lock);
+  _dbus_mutex_unlock (*(allocator->lock_loc));
   return slot >= 0;
 }
 
@@ -164,7 +164,7 @@ void
 _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
                                 dbus_int32_t          *slot_id_p)
 {
-  _dbus_mutex_lock (allocator->lock);
+  _dbus_mutex_lock (*(allocator->lock_loc));
   
   _dbus_assert (*slot_id_p < allocator->n_allocated_slots);
   _dbus_assert (allocator->allocated_slots[*slot_id_p].slot_id == *slot_id_p);
@@ -174,7 +174,7 @@ _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
 
   if (allocator->allocated_slots[*slot_id_p].refcount > 0)
     {
-      _dbus_mutex_unlock (allocator->lock);
+      _dbus_mutex_unlock (*(allocator->lock_loc));
       return;
     }
 
@@ -189,18 +189,18 @@ _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
   
   if (allocator->n_used_slots == 0)
     {
-      DBusMutex *mutex = allocator->lock;
+      DBusMutex **mutex_loc = allocator->lock_loc;
       
       dbus_free (allocator->allocated_slots);
       allocator->allocated_slots = NULL;
       allocator->n_allocated_slots = 0;
-      allocator->lock = NULL;
+      allocator->lock_loc = NULL;
 
-      _dbus_mutex_unlock (mutex);
+      _dbus_mutex_unlock (*mutex_loc);
     }
   else
     {
-      _dbus_mutex_unlock (allocator->lock);
+      _dbus_mutex_unlock (*(allocator->lock_loc));
     }
 }
 
@@ -246,11 +246,11 @@ _dbus_data_slot_list_set  (DBusDataSlotAllocator *allocator,
    * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts
    * are disabled, since then the asserts are empty.
    */
-  if (!_dbus_mutex_lock (allocator->lock))
+  if (!_dbus_mutex_lock (*(allocator->lock_loc)))
     return FALSE;
   _dbus_assert (slot < allocator->n_allocated_slots);
   _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
-  _dbus_mutex_unlock (allocator->lock);
+  _dbus_mutex_unlock (*(allocator->lock_loc));
 #endif
   
   if (slot >= list->n_slots)
@@ -304,12 +304,12 @@ _dbus_data_slot_list_get  (DBusDataSlotAllocator *allocator,
    * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts
    * are disabled, since then the asserts are empty.
    */
-  if (!_dbus_mutex_lock (allocator->lock))
+  if (!_dbus_mutex_lock (*(allocator->lock_loc)))
     return NULL;
   _dbus_assert (slot >= 0);
   _dbus_assert (slot < allocator->n_allocated_slots);
   _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
-  _dbus_mutex_unlock (allocator->lock);
+  _dbus_mutex_unlock (*(allocator->lock_loc));
 #endif
 
   if (slot >= list->n_slots)
@@ -392,7 +392,7 @@ _dbus_data_slot_test (void)
 
   _dbus_data_slot_list_init (&list);
 
-  mutex = _dbus_mutex_new ();
+  _dbus_mutex_new_at_location (&mutex);
   if (mutex == NULL)
     _dbus_assert_not_reached ("failed to alloc mutex");
   
@@ -407,7 +407,7 @@ _dbus_data_slot_test (void)
        */
       dbus_int32_t tmp = -1;
       
-      _dbus_data_slot_allocator_alloc (&allocator, mutex, &tmp);
+      _dbus_data_slot_allocator_alloc (&allocator, &mutex, &tmp);
 
       if (tmp != i)
         _dbus_assert_not_reached ("did not allocate slots in numeric order\n");
@@ -472,7 +472,7 @@ _dbus_data_slot_test (void)
       ++i;
     }
 
-  _dbus_mutex_free (mutex);
+  _dbus_mutex_free_at_location (&mutex);
   
   return TRUE;
 }
diff --git a/dbus/dbus-dataslot.h b/dbus/dbus-dataslot.h
index 04c8f309..72fca619 100644
--- a/dbus/dbus-dataslot.h
+++ b/dbus/dbus-dataslot.h
@@ -57,7 +57,7 @@ struct DBusDataSlotAllocator
   DBusAllocatedSlot *allocated_slots; /**< Allocated slots */
   int  n_allocated_slots; /**< number of slots malloc'd */
   int  n_used_slots;      /**< number of slots used */
-  DBusMutex *lock;        /**< thread lock */
+  DBusMutex **lock_loc;   /**< location of thread lock */
 };
 
 /**
@@ -72,7 +72,7 @@ struct DBusDataSlotList
 
 dbus_bool_t _dbus_data_slot_allocator_init  (DBusDataSlotAllocator  *allocator);
 dbus_bool_t _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator  *allocator,
-                                             DBusMutex              *mutex,
+                                             DBusMutex              **mutex_loc,
                                              int                    *slot_id_p);
 void        _dbus_data_slot_allocator_free  (DBusDataSlotAllocator  *allocator,
                                              int                    *slot_id_p);
diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index f032f82a..9b0d7a0b 100644
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -3595,7 +3595,7 @@ dbus_bool_t
 dbus_message_allocate_data_slot (dbus_int32_t *slot_p)
 {
   return _dbus_data_slot_allocator_alloc (&slot_allocator,
-                                          _DBUS_LOCK_NAME (message_slots),
+                                          &_DBUS_LOCK_NAME (message_slots),
                                           slot_p);
 }
 
diff --git a/dbus/dbus-pending-call.c b/dbus/dbus-pending-call.c
index e6ece9dd..6076d723 100644
--- a/dbus/dbus-pending-call.c
+++ b/dbus/dbus-pending-call.c
@@ -651,7 +651,7 @@ dbus_bool_t
 dbus_pending_call_allocate_data_slot (dbus_int32_t *slot_p)
 {
   return _dbus_data_slot_allocator_alloc (&slot_allocator,
-                                          _DBUS_LOCK_NAME (pending_call_slots),
+                                          &_DBUS_LOCK_NAME (pending_call_slots),
                                           slot_p);
 }
 
diff --git a/dbus/dbus-server.c b/dbus/dbus-server.c
index d1ab496a..b406c869 100644
--- a/dbus/dbus-server.c
+++ b/dbus/dbus-server.c
@@ -141,7 +141,7 @@ _dbus_server_init_base (DBusServer             *server,
   if (server->address == NULL)
     goto failed;
   
-  server->mutex = _dbus_mutex_new ();
+  _dbus_mutex_new_at_location (&server->mutex);
   if (server->mutex == NULL)
     goto failed;
   
@@ -160,11 +160,8 @@ _dbus_server_init_base (DBusServer             *server,
   return TRUE;
 
  failed:
-  if (server->mutex)
-    {
-      _dbus_mutex_free (server->mutex);
-      server->mutex = NULL;
-    }
+  _dbus_mutex_free_at_location (&server->mutex);
+  server->mutex = NULL;
   if (server->watches)
     {
       _dbus_watch_list_free (server->watches);
@@ -210,7 +207,7 @@ _dbus_server_finalize_base (DBusServer *server)
   _dbus_watch_list_free (server->watches);
   _dbus_timeout_list_free (server->timeouts);
 
-  _dbus_mutex_free (server->mutex);
+  _dbus_mutex_free_at_location (&server->mutex);
   
   dbus_free (server->address);
 
@@ -1060,7 +1057,7 @@ dbus_bool_t
 dbus_server_allocate_data_slot (dbus_int32_t *slot_p)
 {
   return _dbus_data_slot_allocator_alloc (&slot_allocator,
-                                          _DBUS_LOCK_NAME (server_slots),
+                                          (DBusMutex **)&_DBUS_LOCK_NAME (server_slots),
                                           slot_p);
 }
 
diff --git a/dbus/dbus-threads-internal.h b/dbus/dbus-threads-internal.h
index 8cc3a7ac..700c4f75 100644
--- a/dbus/dbus-threads-internal.h
+++ b/dbus/dbus-threads-internal.h
@@ -29,21 +29,24 @@
 
 DBUS_BEGIN_DECLS
 
-DBusMutex*   _dbus_mutex_new            (void);
-void         _dbus_mutex_free           (DBusMutex                 *mutex);
-dbus_bool_t  _dbus_mutex_lock           (DBusMutex                 *mutex);
-dbus_bool_t  _dbus_mutex_unlock         (DBusMutex                 *mutex);
-
-DBusCondVar* _dbus_condvar_new          (void);
-void         _dbus_condvar_free         (DBusCondVar               *cond);
-void         _dbus_condvar_wait         (DBusCondVar               *cond,
-					DBusMutex                 *mutex);
-dbus_bool_t  _dbus_condvar_wait_timeout (DBusCondVar               *cond,
-					DBusMutex                 *mutex,
-					int                        timeout_milliseconds);
-void         _dbus_condvar_wake_one     (DBusCondVar               *cond);
-void         _dbus_condvar_wake_all     (DBusCondVar               *cond);
+DBusMutex*   _dbus_mutex_new                 (void);
+void         _dbus_mutex_free                (DBusMutex         *mutex);
+dbus_bool_t  _dbus_mutex_lock                (DBusMutex         *mutex);
+dbus_bool_t  _dbus_mutex_unlock              (DBusMutex         *mutex);
+void         _dbus_mutex_new_at_location     (DBusMutex        **location_p);
+void         _dbus_mutex_free_at_location    (DBusMutex        **location_p);
 
+DBusCondVar* _dbus_condvar_new               (void);
+void         _dbus_condvar_free              (DBusCondVar       *cond);
+void         _dbus_condvar_wait              (DBusCondVar       *cond,
+                                              DBusMutex         *mutex);
+dbus_bool_t  _dbus_condvar_wait_timeout      (DBusCondVar       *cond,
+                                              DBusMutex         *mutex,
+                                              int                timeout_milliseconds);
+void          _dbus_condvar_wake_one         (DBusCondVar       *cond);
+void          _dbus_condvar_wake_all         (DBusCondVar       *cond);
+void          _dbus_condvar_new_at_location  (DBusCondVar      **location_p);
+void          _dbus_condvar_free_at_location (DBusCondVar      **location_p);
 
 DBUS_END_DECLS
 
diff --git a/dbus/dbus-threads.c b/dbus/dbus-threads.c
index f22d0a68..78269634 100644
--- a/dbus/dbus-threads.c
+++ b/dbus/dbus-threads.c
@@ -23,6 +23,7 @@
 #include "dbus-threads.h"
 #include "dbus-internals.h"
 #include "dbus-threads-internal.h"
+#include "dbus-list.h"
 
 static DBusThreadFunctions thread_functions =
 {
@@ -35,6 +36,9 @@ static DBusThreadFunctions thread_functions =
 };
 static int thread_init_generation = 0;
 
+static DBusList *uninitialized_mutex_list = NULL;
+static DBusList *uninitialized_condvar_list = NULL;
+
 /** This is used for the no-op default mutex pointer, just to be distinct from #NULL */
 #define _DBUS_DUMMY_MUTEX ((DBusMutex*)0xABCDEF)
 
@@ -69,6 +73,32 @@ _dbus_mutex_new (void)
 }
 
 /**
+ * This does the same thing as _dbus_mutex_new.  It however
+ * gives another level of indirection by allocating a pointer
+ * to point to the mutex location.  This allows the threading
+ * module to swap out dummy mutexes for real a real mutex so libraries
+ * can initialize threads even after the D-Bus API has been used.
+ *
+ * @param location_p the location of the new mutex, can return #NULL on OOM
+ */
+void
+_dbus_mutex_new_at_location (DBusMutex **location_p)
+{
+  _dbus_assert (location_p != NULL);
+
+  *location_p = _dbus_mutex_new();
+
+  if (thread_init_generation != _dbus_current_generation && *location_p)
+    {
+      if (!_dbus_list_append (&uninitialized_mutex_list, location_p))
+        {
+	  _dbus_mutex_free (*location_p);
+	  *location_p = NULL;
+	}
+    }
+}
+
+/**
  * Frees a mutex created with dbus_mutex_new(); does
  * nothing if passed a #NULL pointer.
  */
@@ -80,6 +110,23 @@ _dbus_mutex_free (DBusMutex *mutex)
 }
 
 /**
+ * Frees a mutex and removes it from the 
+ * uninitialized_mutex_list;
+ * does nothing if passed a #NULL pointer.
+ */
+void
+_dbus_mutex_free_at_location (DBusMutex **location_p)
+{
+  if (location_p)
+    {
+      if (thread_init_generation != _dbus_current_generation)
+        _dbus_list_remove (&uninitialized_mutex_list, location_p);
+
+      _dbus_mutex_free (*location_p);
+    }
+}
+
+/**
  * Locks a mutex. Does nothing if passed a #NULL pointer.
  * Locks are not recursive.
  *
@@ -125,6 +172,33 @@ _dbus_condvar_new (void)
     return _DBUS_DUMMY_CONDVAR;
 }
 
+
+/**
+ * This does the same thing as _dbus_condvar_new.  It however
+ * gives another level of indirection by allocating a pointer
+ * to point to the condvar location.  This allows the threading
+ * module to swap out dummy condvars for real a real condvar so libraries
+ * can initialize threads even after the D-Bus API has been used.
+ *
+ * @returns the location of a new condvar or #NULL on OOM
+ */
+
+void 
+_dbus_condvar_new_at_location (DBusCondVar **location_p)
+{
+  *location_p = _dbus_condvar_new();
+
+  if (thread_init_generation != _dbus_current_generation && *location_p)
+    {
+      if (!_dbus_list_append (&uninitialized_condvar_list, location_p))
+        {
+          _dbus_condvar_free (*location_p);
+          *location_p = NULL;
+        }
+    }
+}
+
+
 /**
  * Frees a conditional variable created with dbus_condvar_new(); does
  * nothing if passed a #NULL pointer.
@@ -137,6 +211,23 @@ _dbus_condvar_free (DBusCondVar *cond)
 }
 
 /**
+ * Frees a conditional variable and removes it from the 
+ * uninitialized_condvar_list; 
+ * does nothing if passed a #NULL pointer.
+ */
+void
+_dbus_condvar_free_at_location (DBusCondVar **location_p)
+{
+  if (location_p)
+    {
+      if (thread_init_generation != _dbus_current_generation)
+        _dbus_list_remove (&uninitialized_condvar_list, location_p);
+
+      _dbus_condvar_free (*location_p);
+    }
+}
+
+/**
  * Atomically unlocks the mutex and waits for the conditions
  * variable to be signalled. Locks the mutex again before
  * returning.
@@ -214,8 +305,100 @@ shutdown_global_locks (void *data)
   dbus_free (locks);
 }
 
+static void
+shutdown_uninitialized_locks (void *data)
+{
+  _dbus_list_clear (&uninitialized_mutex_list);
+  _dbus_list_clear (&uninitialized_condvar_list);
+}
+
 static dbus_bool_t
-init_global_locks (void)
+init_uninitialized_locks (void)
+{
+  DBusList *link;
+
+  _dbus_assert (thread_init_generation == 0);
+
+  link = uninitialized_mutex_list;
+  while (link != NULL)
+    {
+      DBusMutex **mp;
+
+      mp = (DBusMutex **)link->data;
+      _dbus_assert (*mp == _DBUS_DUMMY_MUTEX);
+
+      *mp = _dbus_mutex_new ();
+      if (*mp == NULL)
+        goto fail_mutex;
+
+      link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);
+    }
+
+  link = uninitialized_condvar_list;
+  while (link != NULL)
+    {
+      DBusCondVar **cp;
+
+      cp = (DBusCondVar **)link->data;
+      _dbus_assert (*cp == _DBUS_DUMMY_CONDVAR);
+
+      *cp = _dbus_condvar_new ();
+      if (*cp == NULL)
+        goto fail_condvar;
+
+      link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);
+    }
+
+  _dbus_list_clear (&uninitialized_mutex_list);
+  _dbus_list_clear (&uninitialized_condvar_list);
+
+  if (!_dbus_register_shutdown_func (shutdown_uninitialized_locks,
+                                     NULL))
+    goto fail_condvar;
+
+  return TRUE;
+
+ fail_condvar:
+  link = uninitialized_condvar_list;
+  while (link != NULL)
+    {
+      DBusCondVar **cp;
+
+      cp = (DBusCondVar **)link->data;
+
+      if (*cp != _DBUS_DUMMY_CONDVAR)
+        _dbus_condvar_free (*cp);
+      else
+        break;
+
+      *cp = _DBUS_DUMMY_CONDVAR;
+
+      link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);
+    }
+
+ fail_mutex:
+  link = uninitialized_mutex_list;
+  while (link != NULL)
+    {
+      DBusMutex **mp;
+
+      mp = (DBusMutex **)link->data;
+
+      if (*mp != _DBUS_DUMMY_MUTEX)
+        _dbus_mutex_free (*mp);
+      else
+        break;
+
+      *mp = _DBUS_DUMMY_MUTEX;
+
+      link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);
+    }
+
+  return FALSE;
+}
+
+static dbus_bool_t
+init_locks (void)
 {
   int i;
   DBusMutex ***dynamic_global_locks;
@@ -260,6 +443,9 @@ init_global_locks (void)
   if (!_dbus_register_shutdown_func (shutdown_global_locks,
                                      dynamic_global_locks))
     goto failed;
+
+  if (!init_uninitialized_locks ())
+    goto failed;
   
   return TRUE;
 
@@ -339,24 +525,12 @@ dbus_threads_init (const DBusThreadFunctions *functions)
 
   if (thread_init_generation != _dbus_current_generation)
     thread_functions.mask = 0; /* allow re-init in new generation */
-  
+ 
+  /* Silently allow multiple init
+   * First init wins and D-Bus will always use its threading system 
+   */ 
   if (thread_functions.mask != 0)
-    {
-      /* Silently allow multiple init if the functions are the same ones.
-       * Well, we only bother checking two of them, just out of laziness.
-       */
-      if (thread_functions.mask == functions->mask &&
-          thread_functions.mutex_new == functions->mutex_new &&
-          thread_functions.condvar_new == functions->condvar_new)
-        {
-          return TRUE;
-        }
-      else
-        {
-          _dbus_warn ("dbus_threads_init() called twice with two different sets of functions\n");
-          return FALSE;
-        }
-    }
+    return TRUE;
   
   thread_functions.mutex_new = functions->mutex_new;
   thread_functions.mutex_free = functions->mutex_free;
@@ -372,7 +546,7 @@ dbus_threads_init (const DBusThreadFunctions *functions)
   
   thread_functions.mask = functions->mask;
 
-  if (!init_global_locks ())
+  if (!init_locks ())
     return FALSE;
 
   thread_init_generation = _dbus_current_generation;
diff --git a/test/name-test/Makefile.am b/test/name-test/Makefile.am
index 34dd85a8..41bb24be 100644
--- a/test/name-test/Makefile.am
+++ b/test/name-test/Makefile.am
@@ -16,10 +16,10 @@ if DBUS_BUILD_TESTS
 
 ## we use noinst_PROGRAMS not check_PROGRAMS for TESTS so that we
 ## build even when not doing "make check"
-noinst_PROGRAMS=test-names test-pending-call-dispatch 
+noinst_PROGRAMS=test-names test-pending-call-dispatch test-threads-init
 
 test_names_SOURCES=				\
-	test-names.c                             
+	test-names.c
 
 test_names_LDADD=$(top_builddir)/dbus/libdbus-1.la $(top_builddir)/dbus/libdbus-convenience.la
 
@@ -29,5 +29,10 @@ test_pending_call_dispatch_SOURCES =		\
 test_pending_call_dispatch_LDADD=$(top_builddir)/dbus/libdbus-1.la $(top_builddir)/dbus/libdbus-convenience.la
 
 
+test_threads_init_SOURCES =            \
+	test-threads-init.c
+
+test_threads_init_LDADD=$(top_builddir)/dbus/libdbus-1.la $(top_builddir)/dbus/libdbus-convenience.la
+
 endif
 
diff --git a/test/name-test/run-test.sh b/test/name-test/run-test.sh
index 6c612499..81e2e84e 100755
--- a/test/name-test/run-test.sh
+++ b/test/name-test/run-test.sh
@@ -31,3 +31,6 @@ libtool --mode=execute $DEBUG $DBUS_TOP_BUILDDIR/test/name-test/test-names || di
 
 echo "running test-pending-call-dispatch"
 libtool --mode=execute $DEBUG $DBUS_TOP_BUILDDIR/test/name-test/test-pending-call-dispatch || die "test-client failed"
+
+echo "running test-threads-init"
+libtool --mode=execute $DEBUG $DBUS_TOP_BUILDDIR/test/name-test/test-threads-init || die "test-client failed"
diff --git a/test/name-test/test-threads-init.c b/test/name-test/test-threads-init.c
new file mode 100644
index 00000000..e6743cce
--- /dev/null
+++ b/test/name-test/test-threads-init.c
@@ -0,0 +1,181 @@
+/**
+* Test to make sure late thread initialization works
+**/
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-sysdeps.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <dbus/dbus-internals.h>
+
+static void
+_run_iteration (DBusConnection *conn)
+{
+  DBusPendingCall *echo_pending;
+  DBusPendingCall *dbus_pending;
+  DBusMessage *method;
+  DBusMessage *reply;
+  char *echo = "echo";
+
+  /* send the first message */
+  method = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteEchoService",
+                                         "/org/freedesktop/TestSuite",
+                                         "org.freedesktop.TestSuite",
+                                         "Echo");
+
+  dbus_message_append_args (method, DBUS_TYPE_STRING, &echo, NULL);
+  dbus_connection_send_with_reply (conn, method, &echo_pending, -1);
+  dbus_message_unref (method);
+  
+  /* send the second message */
+  method = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+                                         DBUS_PATH_DBUS,
+                                         "org.freedesktop.Introspectable",
+                                         "Introspect");
+
+  dbus_connection_send_with_reply (conn, method, &dbus_pending, -1);
+  dbus_message_unref (method);
+
+  /* block on the second message (should return immediately) */
+  dbus_pending_call_block (dbus_pending);
+
+  /* block on the first message */
+  /* if it does not return immediately chances 
+     are we hit the block in poll bug */
+  dbus_pending_call_block (echo_pending);
+
+  /* check the reply only to make sure we
+     are not getting errors unrelated
+     to the block in poll bug */
+  reply = dbus_pending_call_steal_reply (echo_pending);
+
+  if (reply == NULL)
+    {
+      printf ("Failed: Reply is NULL ***\n");
+      exit (1);
+    }
+
+  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
+    {
+      printf ("Failed: Reply is error: %s ***\n", dbus_message_get_error_name (reply));
+      exit (1);
+    } 
+
+  dbus_message_unref (reply);
+  dbus_pending_call_unref (dbus_pending);
+  dbus_pending_call_unref (echo_pending);
+  
+}
+static void
+check_mutex_lock (DBusMutex *mutex1, 
+                  DBusMutex *mutex2, 
+                  dbus_bool_t is_same)
+{
+  _dbus_assert (mutex1 != NULL);
+  _dbus_assert (mutex2 != NULL);
+  
+  if (is_same)
+    {
+      _dbus_assert (mutex1 == mutex2);
+    }
+  else
+    {
+      _dbus_assert (mutex1 != mutex2);
+    }
+}
+
+static void
+check_condvar_lock (DBusCondVar *condvar1,  
+                    DBusCondVar *condvar2,   
+                    dbus_bool_t is_same)
+{
+  _dbus_assert (condvar1 != NULL);
+  _dbus_assert (condvar2 != NULL);
+
+  if (is_same)
+    {
+      _dbus_assert (condvar1 == condvar2);
+    }
+  else
+    {
+      _dbus_assert (condvar1 != condvar2);
+    }
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  long start_tv_sec, start_tv_usec;
+  long end_tv_sec, end_tv_usec;
+  int i;
+  DBusMessage *method;
+  DBusConnection *conn;
+  DBusError error;
+  DBusMutex *mutex1, *dispatch_mutex1, *io_path_mutex1;
+  DBusCondVar *dispatch_cond1, *io_path_cond1;
+  DBusMutex *mutex2, *dispatch_mutex2, *io_path_mutex2;
+  DBusCondVar *dispatch_cond2, *io_path_cond2;
+
+  printf ("*** Testing late thread init\n");
+
+  dbus_error_init (&error);
+
+  conn = dbus_bus_get (DBUS_BUS_SESSION, &error);
+
+  _dbus_connection_test_get_locks (conn, &mutex1, 
+                                         &dispatch_mutex1, 
+                                         &io_path_mutex1,
+                                         &dispatch_cond1,
+                                         &io_path_cond1);
+  _run_iteration (conn);
+  _dbus_connection_test_get_locks (conn, &mutex2,
+                                         &dispatch_mutex2,
+                                         &io_path_mutex2,
+                                         &dispatch_cond2,
+                                         &io_path_cond2);
+
+  check_mutex_lock (mutex1, mutex2, TRUE);
+  check_mutex_lock (dispatch_mutex1, dispatch_mutex2, TRUE);
+  check_mutex_lock (io_path_mutex1, io_path_mutex2, TRUE);
+  check_condvar_lock (dispatch_cond1, dispatch_cond2, TRUE);
+  check_condvar_lock (io_path_cond1, io_path_cond2, TRUE);
+
+  _dbus_threads_init_debug ();
+
+  _dbus_connection_test_get_locks (conn, &mutex1,
+                                         &dispatch_mutex1,
+                                         &io_path_mutex1,
+                                         &dispatch_cond1,
+                                         &io_path_cond1);
+
+  check_mutex_lock (mutex1, mutex2, FALSE);
+  check_mutex_lock (dispatch_mutex1, dispatch_mutex2, FALSE);
+  check_mutex_lock (io_path_mutex1, io_path_mutex2, FALSE);
+  check_condvar_lock (dispatch_cond1, dispatch_cond2, FALSE);
+  check_condvar_lock (io_path_cond1, io_path_cond2, FALSE);
+
+  _run_iteration (conn);
+  _dbus_connection_test_get_locks (conn, &mutex2,
+                                         &dispatch_mutex2,
+                                         &io_path_mutex2,
+                                         &dispatch_cond2,
+                                         &io_path_cond2);
+
+  check_mutex_lock (mutex1, mutex2, TRUE);
+  check_mutex_lock (dispatch_mutex1, dispatch_mutex2, TRUE);
+  check_mutex_lock (io_path_mutex1, io_path_mutex2, TRUE);
+  check_condvar_lock (dispatch_cond1, dispatch_cond2, TRUE);
+  check_condvar_lock (io_path_cond1, io_path_cond2, TRUE);
+
+  method = dbus_message_new_method_call ("org.freedesktop.TestSuiteEchoService",
+                                         "/org/freedesktop/TestSuite",
+                                         "org.freedesktop.TestSuite",
+                                         "Exit");
+  dbus_connection_send (conn, method, NULL);
+  dbus_message_unref (method);
+
+  printf ("Success ***\n");
+  exit (0);
+}