+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):
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
/**
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);
}
}
}
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;
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;
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,
_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;
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);
_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);
}
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);
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);
}
allocator->allocated_slots = NULL;
allocator->n_allocated_slots = 0;
allocator->n_used_slots = 0;
- allocator->lock = NULL;
+ allocator->lock_loc = NULL;
return TRUE;
}
* 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");
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;
}
_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);
if (allocator->allocated_slots[*slot_id_p].refcount > 0)
{
- _dbus_mutex_unlock (allocator->lock);
+ _dbus_mutex_unlock (*(allocator->lock_loc));
return;
}
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));
}
}
* 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)
* 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)
_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");
*/
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");
++i;
}
- _dbus_mutex_free (mutex);
+ _dbus_mutex_free_at_location (&mutex);
return TRUE;
}
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 */
};
/**
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);
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);
}
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);
}
if (server->address == NULL)
goto failed;
- server->mutex = _dbus_mutex_new ();
+ _dbus_mutex_new_at_location (&server->mutex);
if (server->mutex == NULL)
goto failed;
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);
_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);
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);
}
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
#include "dbus-threads.h"
#include "dbus-internals.h"
#include "dbus-threads-internal.h"
+#include "dbus-list.h"
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)
}
/**
+ * 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.
*/
}
/**
+ * 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.
*
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.
}
/**
+ * 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.
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;
if (!_dbus_register_shutdown_func (shutdown_global_locks,
dynamic_global_locks))
goto failed;
+
+ if (!init_uninitialized_locks ())
+ goto failed;
return TRUE;
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;
thread_functions.mask = functions->mask;
- if (!init_global_locks ())
+ if (!init_locks ())
return FALSE;
thread_init_generation = _dbus_current_generation;
## 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
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
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"
--- /dev/null
+/**
+* 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);
+}
projects / platform / upstream / dbus.git / commitdiff