X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-threads.c;h=1781bdafdf74107dac89d69d0ba11eb22eded318;hb=757b80b9711d9733798c927495d74c7323e95400;hp=e8b9f3cdc579b75c79f2e23970dde3821e903688;hpb=bc8b061eec0fd9de6552a9e6118c40283863b6dc;p=platform%2Fupstream%2Fdbus.git diff --git a/dbus/dbus-threads.c b/dbus/dbus-threads.c index e8b9f3c..1781bda 100644 --- a/dbus/dbus-threads.c +++ b/dbus/dbus-threads.c @@ -1,9 +1,9 @@ -/* -*- mode: C; c-file-style: "gnu" -*- */ -/* dbus-threads.h D-BUS threads handling +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ +/* dbus-threads.h D-Bus threads handling * - * Copyright (C) 2002, 2003 Red Hat Inc. + * Copyright (C) 2002, 2003, 2006 Red Hat Inc. * - * Licensed under the Academic Free License version 1.2 + * Licensed under the Academic Free License version 2.1 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,33 +17,21 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ +#include #include "dbus-threads.h" #include "dbus-internals.h" +#include "dbus-threads-internal.h" +#include "dbus-list.h" -static DBusThreadFunctions thread_functions = -{ - 0, - NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL, NULL, - - NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL -}; static int thread_init_generation = 0; -/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */ -#define _DBUS_DUMMY_MUTEX ((DBusMutex*)0xABCDEF) - -/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */ -#define _DBUS_DUMMY_CONDVAR ((DBusCondVar*)0xABCDEF2) - /** - * @defgroup DBusThreads Thread functions - * @ingroup DBus - * @brief dbus_threads_init(), dbus_mutex_lock(), etc. + * @defgroup DBusThreadsInternals Thread functions + * @ingroup DBusInternals + * @brief _dbus_rmutex_lock(), etc. * * Functions and macros related to threads and thread locks. * @@ -51,46 +39,120 @@ static int thread_init_generation = 0; */ /** - * Creates a new mutex using the function supplied to dbus_threads_init(), + * Creates a new mutex * or creates a no-op mutex if threads are not initialized. * May return #NULL even if threads are initialized, indicating * out-of-memory. * - * @returns new mutex or #NULL + * If possible, the mutex returned by this function is recursive, to + * avoid deadlocks. However, that cannot be relied on. + * + * @param location_p the location of the new mutex, can return #NULL on OOM */ -DBusMutex* -dbus_mutex_new (void) +void +_dbus_rmutex_new_at_location (DBusRMutex **location_p) { - if (thread_functions.mutex_new) - return (* thread_functions.mutex_new) (); - else - return _DBUS_DUMMY_MUTEX; + _dbus_assert (location_p != NULL); + + if (!dbus_threads_init_default ()) + { + *location_p = NULL; + return; + } + + *location_p = _dbus_platform_rmutex_new (); } /** - * Frees a mutex created with dbus_mutex_new(); does - * nothing if passed a #NULL pointer. + * Creates a new mutex + * or creates a no-op mutex if threads are not initialized. + * May return #NULL even if threads are initialized, indicating + * out-of-memory. + * + * The returned mutex is suitable for use with condition variables. + * + * @param location_p the location of the new mutex, can return #NULL on OOM + */ +void +_dbus_cmutex_new_at_location (DBusCMutex **location_p) +{ + _dbus_assert (location_p != NULL); + + if (!dbus_threads_init_default ()) + { + *location_p = NULL; + return; + } + + *location_p = _dbus_platform_cmutex_new (); +} + +/** + * Frees a DBusRMutex; does nothing if passed a #NULL pointer. */ void -dbus_mutex_free (DBusMutex *mutex) +_dbus_rmutex_free_at_location (DBusRMutex **location_p) { - if (mutex && thread_functions.mutex_free) - (* thread_functions.mutex_free) (mutex); + if (location_p == NULL) + return; + + if (*location_p != NULL) + _dbus_platform_rmutex_free (*location_p); +} + +/** + * Frees a DBusCMutex; does nothing if passed a #NULL pointer. + */ +void +_dbus_cmutex_free_at_location (DBusCMutex **location_p) +{ + if (location_p == NULL) + return; + + if (*location_p != NULL) + _dbus_platform_cmutex_free (*location_p); } /** * Locks a mutex. Does nothing if passed a #NULL pointer. - * Locks are not recursive. + * Locks may be recursive if threading implementation initialized + * recursive locks. + */ +void +_dbus_rmutex_lock (DBusRMutex *mutex) +{ + if (mutex == NULL) + return; + + _dbus_platform_rmutex_lock (mutex); +} + +/** + * Locks a mutex. Does nothing if passed a #NULL pointer. + * Locks may be recursive if threading implementation initialized + * recursive locks. + */ +void +_dbus_cmutex_lock (DBusCMutex *mutex) +{ + if (mutex == NULL) + return; + + _dbus_platform_cmutex_lock (mutex); +} + +/** + * Unlocks a mutex. Does nothing if passed a #NULL pointer. * * @returns #TRUE on success */ -dbus_bool_t -dbus_mutex_lock (DBusMutex *mutex) +void +_dbus_rmutex_unlock (DBusRMutex *mutex) { - if (mutex && thread_functions.mutex_lock) - return (* thread_functions.mutex_lock) (mutex); - else - return TRUE; + if (mutex == NULL) + return; + + _dbus_platform_rmutex_unlock (mutex); } /** @@ -98,13 +160,13 @@ dbus_mutex_lock (DBusMutex *mutex) * * @returns #TRUE on success */ -dbus_bool_t -dbus_mutex_unlock (DBusMutex *mutex) +void +_dbus_cmutex_unlock (DBusCMutex *mutex) { - if (mutex && thread_functions.mutex_unlock) - return (* thread_functions.mutex_unlock) (mutex); - else - return TRUE; + if (mutex == NULL) + return; + + _dbus_platform_cmutex_unlock (mutex); } /** @@ -116,23 +178,56 @@ dbus_mutex_unlock (DBusMutex *mutex) * @returns new mutex or #NULL */ DBusCondVar * -dbus_condvar_new (void) +_dbus_condvar_new (void) +{ + if (!dbus_threads_init_default ()) + return NULL; + + return _dbus_platform_condvar_new (); +} + + +/** + * 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 used to be useful. + * + * @returns the location of a new condvar or #NULL on OOM + */ + +void +_dbus_condvar_new_at_location (DBusCondVar **location_p) { - if (thread_functions.condvar_new) - return (* thread_functions.condvar_new) (); - else - return _DBUS_DUMMY_CONDVAR; + _dbus_assert (location_p != NULL); + + *location_p = _dbus_condvar_new(); } + /** * Frees a conditional variable created with dbus_condvar_new(); does * nothing if passed a #NULL pointer. */ void -dbus_condvar_free (DBusCondVar *cond) +_dbus_condvar_free (DBusCondVar *cond) +{ + if (cond == NULL) + return; + + _dbus_platform_condvar_free (cond); +} + +/** + * Frees a condition variable; does nothing if passed a #NULL pointer. + */ +void +_dbus_condvar_free_at_location (DBusCondVar **location_p) { - if (cond && thread_functions.condvar_free) - (* thread_functions.condvar_free) (cond); + if (location_p == NULL) + return; + + if (*location_p != NULL) + _dbus_platform_condvar_free (*location_p); } /** @@ -142,34 +237,36 @@ dbus_condvar_free (DBusCondVar *cond) * Does nothing if passed a #NULL pointer. */ void -dbus_condvar_wait (DBusCondVar *cond, - DBusMutex *mutex) +_dbus_condvar_wait (DBusCondVar *cond, + DBusCMutex *mutex) { - if (cond && mutex && thread_functions.condvar_wait) - (* thread_functions.condvar_wait) (cond, mutex); + if (cond == NULL || mutex == NULL) + return; + + _dbus_platform_condvar_wait (cond, mutex); } /** - * Atomically unlocks the mutex and waits for the conditions - * variable to be signalled, or for a timeout. Locks the - * mutex again before returning. - * Does nothing if passed a #NULL pointer. + * Atomically unlocks the mutex and waits for the conditions variable + * to be signalled, or for a timeout. Locks the mutex again before + * returning. Does nothing if passed a #NULL pointer. Return value + * is #FALSE if we timed out, #TRUE otherwise. * * @param cond the condition variable * @param mutex the mutex * @param timeout_milliseconds the maximum time to wait - * @returns TRUE if the condition was reached, or FALSE if the - * timeout was reached. + * @returns #FALSE if the timeout occurred, #TRUE if not */ dbus_bool_t -dbus_condvar_wait_timeout (DBusCondVar *cond, - DBusMutex *mutex, - int timeout_milliseconds) +_dbus_condvar_wait_timeout (DBusCondVar *cond, + DBusCMutex *mutex, + int timeout_milliseconds) { - if (cond && mutex && thread_functions.condvar_wait) - return (* thread_functions.condvar_wait_timeout) (cond, mutex, timeout_milliseconds); - else + if (cond == NULL || mutex == NULL) return TRUE; + + return _dbus_platform_condvar_wait_timeout (cond, mutex, + timeout_milliseconds); } /** @@ -178,316 +275,194 @@ dbus_condvar_wait_timeout (DBusCondVar *cond, * Does nothing if passed a #NULL pointer. */ void -dbus_condvar_wake_one (DBusCondVar *cond) +_dbus_condvar_wake_one (DBusCondVar *cond) { - if (cond && thread_functions.condvar_wake_one) - (* thread_functions.condvar_wake_one) (cond); + if (cond == NULL) + return; + + _dbus_platform_condvar_wake_one (cond); } -/** - * If there are threads waiting on the condition variable, wake - * up all of them. - * Does nothing if passed a #NULL pointer. - */ -void -dbus_condvar_wake_all (DBusCondVar *cond) +#ifdef DBUS_HAVE_STATIC_RECURSIVE_MUTEXES + +static dbus_bool_t +init_global_locks (void) { - if (cond && thread_functions.condvar_wake_all) - (* thread_functions.condvar_wake_all) (cond); + return TRUE; } +/* implementations in dbus-sysdeps-pthread.c */ + +#else /* !defined(DBUS_HAVE_STATIC_RECURSIVE_MUTEXES) */ + +static DBusRMutex *global_locks[_DBUS_N_GLOBAL_LOCKS] = { NULL }; + static void -shutdown_global_locks (void *data) +shutdown_global_locks (void *nil) { - DBusMutex ***locks = data; int i; - i = 0; - while (i < _DBUS_N_GLOBAL_LOCKS) + for (i = 0; i < _DBUS_N_GLOBAL_LOCKS; i++) { - dbus_mutex_free (*(locks[i])); - *(locks[i]) = NULL; - ++i; + _dbus_assert (global_locks[i] != NULL); + _dbus_platform_rmutex_free (global_locks[i]); + global_locks[i] = NULL; } - - dbus_free (locks); } static dbus_bool_t init_global_locks (void) { int i; - DBusMutex ***dynamic_global_locks; - - DBusMutex **global_locks[] = { -#define LOCK_ADDR(name) (& _dbus_lock_##name) - LOCK_ADDR (list), - LOCK_ADDR (connection_slots), - LOCK_ADDR (server_slots), - LOCK_ADDR (atomic), - LOCK_ADDR (message_handler), - LOCK_ADDR (user_info), - LOCK_ADDR (bus), - LOCK_ADDR (shutdown_funcs) -#undef LOCK_ADDR - }; - - _dbus_assert (_DBUS_N_ELEMENTS (global_locks) == - _DBUS_N_GLOBAL_LOCKS); - - i = 0; - - dynamic_global_locks = dbus_new (DBusMutex**, _DBUS_N_GLOBAL_LOCKS); - if (dynamic_global_locks == NULL) - goto failed; - - while (i < _DBUS_N_ELEMENTS (global_locks)) + dbus_bool_t ok; + + for (i = 0; i < _DBUS_N_GLOBAL_LOCKS; i++) { - *global_locks[i] = dbus_mutex_new (); - - if (*global_locks[i] == NULL) - goto failed; + _dbus_assert (global_locks[i] == NULL); - dynamic_global_locks[i] = global_locks[i]; + global_locks[i] = _dbus_platform_rmutex_new (); - ++i; + if (global_locks[i] == NULL) + goto failed; } - - if (!_dbus_register_shutdown_func (shutdown_global_locks, - dynamic_global_locks)) + + _dbus_platform_rmutex_lock (global_locks[_DBUS_LOCK_shutdown_funcs]); + ok = _dbus_register_shutdown_func_unlocked (shutdown_global_locks, NULL); + _dbus_platform_rmutex_unlock (global_locks[_DBUS_LOCK_shutdown_funcs]); + + if (!ok) goto failed; - + return TRUE; failed: - dbus_free (dynamic_global_locks); - for (i = i - 1; i >= 0; i--) { - dbus_mutex_free (*global_locks[i]); - *global_locks[i] = NULL; + _dbus_platform_rmutex_free (global_locks[i]); + global_locks[i] = NULL; } + return FALSE; } - -/** - * Initializes threads. If this function is not called, - * the D-BUS library will not lock any data structures. - * If it is called, D-BUS will do locking, at some cost - * in efficiency. Note that this function must be called - * BEFORE using any other D-BUS functions. - * - * @todo right now this function can only be called once, - * maybe we should instead silently ignore multiple calls. - * - * @param functions functions for using threads - * @returns #TRUE on success, #FALSE if no memory - */ dbus_bool_t -dbus_threads_init (const DBusThreadFunctions *functions) +_dbus_lock (DBusGlobalLock lock) { - _dbus_assert (functions != NULL); - - /* these base functions are required. Future additions to - * DBusThreadFunctions may be optional. - */ - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK); - _dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK); - _dbus_assert (functions->mutex_new != NULL); - _dbus_assert (functions->mutex_free != NULL); - _dbus_assert (functions->mutex_lock != NULL); - _dbus_assert (functions->mutex_unlock != NULL); - _dbus_assert (functions->condvar_new != NULL); - _dbus_assert (functions->condvar_free != NULL); - _dbus_assert (functions->condvar_wait != NULL); - _dbus_assert (functions->condvar_wait_timeout != NULL); - _dbus_assert (functions->condvar_wake_one != NULL); - _dbus_assert (functions->condvar_wake_all != NULL); - - /* Check that all bits in the mask actually are valid mask bits. - * ensures people won't write code that breaks when we add - * new bits. - */ - _dbus_assert ((functions->mask & ~DBUS_THREAD_FUNCTIONS_ALL_MASK) == 0); - - if (thread_init_generation != _dbus_current_generation) - thread_functions.mask = 0; /* allow re-init in new generation */ - - if (thread_functions.mask != 0) - { - _dbus_warn ("dbus_threads_init() may only be called one time\n"); - return FALSE; - } - - thread_functions.mutex_new = functions->mutex_new; - thread_functions.mutex_free = functions->mutex_free; - thread_functions.mutex_lock = functions->mutex_lock; - thread_functions.mutex_unlock = functions->mutex_unlock; - - thread_functions.condvar_new = functions->condvar_new; - thread_functions.condvar_free = functions->condvar_free; - thread_functions.condvar_wait = functions->condvar_wait; - thread_functions.condvar_wait_timeout = functions->condvar_wait_timeout; - thread_functions.condvar_wake_one = functions->condvar_wake_one; - thread_functions.condvar_wake_all = functions->condvar_wake_all; - - thread_functions.mask = functions->mask; - - if (!init_global_locks ()) + _dbus_assert (lock >= 0); + _dbus_assert (lock < _DBUS_N_GLOBAL_LOCKS); + + if (thread_init_generation != _dbus_current_generation && + !dbus_threads_init_default ()) return FALSE; - thread_init_generation = _dbus_current_generation; - + _dbus_platform_rmutex_lock (global_locks[lock]); return TRUE; } - -#ifdef DBUS_BUILD_TESTS -/** Fake mutex used for debugging */ -typedef struct DBusFakeMutex DBusFakeMutex; -/** Fake mutex used for debugging */ -struct DBusFakeMutex -{ - dbus_bool_t locked; /**< Mutex is "locked" */ -}; - -static DBusMutex * dbus_fake_mutex_new (void); -static void dbus_fake_mutex_free (DBusMutex *mutex); -static dbus_bool_t dbus_fake_mutex_lock (DBusMutex *mutex); -static dbus_bool_t dbus_fake_mutex_unlock (DBusMutex *mutex); -static DBusCondVar* dbus_fake_condvar_new (void); -static void dbus_fake_condvar_free (DBusCondVar *cond); -static void dbus_fake_condvar_wait (DBusCondVar *cond, - DBusMutex *mutex); -static dbus_bool_t dbus_fake_condvar_wait_timeout (DBusCondVar *cond, - DBusMutex *mutex, - int timeout_msec); -static void dbus_fake_condvar_wake_one (DBusCondVar *cond); -static void dbus_fake_condvar_wake_all (DBusCondVar *cond); - - -static const DBusThreadFunctions fake_functions = -{ - DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK | - DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK | - DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK | - DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK | - DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK | - DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK | - DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK | - DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK | - DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK| - DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK, - dbus_fake_mutex_new, - dbus_fake_mutex_free, - dbus_fake_mutex_lock, - dbus_fake_mutex_unlock, - dbus_fake_condvar_new, - dbus_fake_condvar_free, - dbus_fake_condvar_wait, - dbus_fake_condvar_wait_timeout, - dbus_fake_condvar_wake_one, - dbus_fake_condvar_wake_all -}; - -static DBusMutex * -dbus_fake_mutex_new (void) +void +_dbus_unlock (DBusGlobalLock lock) { - DBusFakeMutex *mutex; - - mutex = dbus_new0 (DBusFakeMutex, 1); + _dbus_assert (lock >= 0); + _dbus_assert (lock < _DBUS_N_GLOBAL_LOCKS); - return (DBusMutex *)mutex; + _dbus_platform_rmutex_unlock (global_locks[lock]); } -static void -dbus_fake_mutex_free (DBusMutex *mutex) -{ - DBusFakeMutex *fake = (DBusFakeMutex*) mutex; +#endif /* !defined(DBUS_HAVE_STATIC_RECURSIVE_MUTEXES) */ - _dbus_assert (!fake->locked); - - dbus_free (fake); -} +/** @} */ /* end of internals */ -static dbus_bool_t -dbus_fake_mutex_lock (DBusMutex *mutex) -{ - DBusFakeMutex *fake = (DBusFakeMutex*) mutex; +/** + * @defgroup DBusThreads Thread functions + * @ingroup DBus + * @brief dbus_threads_init() and dbus_threads_init_default() + * + * Functions and macros related to threads and thread locks. + * + * If threads are initialized, the D-Bus library has locks on all + * global data structures. In addition, each #DBusConnection has a + * lock, so only one thread at a time can touch the connection. (See + * @ref DBusConnection for more on connection locking.) + * + * Most other objects, however, do not have locks - they can only be + * used from a single thread at a time, unless you lock them yourself. + * For example, a #DBusMessage can't be modified from two threads + * at once. + * + * @{ + */ - _dbus_assert (!fake->locked); +/** + * Initializes threads, like dbus_threads_init_default(). + * This version previously allowed user-specified threading + * primitives, but since D-Bus 1.6 it ignores them and behaves + * exactly like dbus_threads_init_default(). + * + * @param functions ignored, formerly functions for using threads + * @returns #TRUE on success, #FALSE if no memory + */ +dbus_bool_t +dbus_threads_init (const DBusThreadFunctions *functions) +{ + _dbus_threads_lock_platform_specific (); - fake->locked = TRUE; - - return TRUE; -} + if (thread_init_generation == _dbus_current_generation) + { + _dbus_threads_unlock_platform_specific (); + return TRUE; + } -static dbus_bool_t -dbus_fake_mutex_unlock (DBusMutex *mutex) -{ - DBusFakeMutex *fake = (DBusFakeMutex*) mutex; + if (!_dbus_threads_init_platform_specific() || + !init_global_locks ()) + { + _dbus_threads_unlock_platform_specific (); + return FALSE; + } - _dbus_assert (fake->locked); + thread_init_generation = _dbus_current_generation; - fake->locked = FALSE; - + _dbus_threads_unlock_platform_specific (); return TRUE; } -static DBusCondVar* -dbus_fake_condvar_new (void) -{ - return (DBusCondVar*) _dbus_strdup ("FakeCondvar"); -} -static void -dbus_fake_condvar_free (DBusCondVar *cond) -{ - dbus_free (cond); -} -static void -dbus_fake_condvar_wait (DBusCondVar *cond, - DBusMutex *mutex) -{ - -} +/* Default thread implemenation */ -static dbus_bool_t -dbus_fake_condvar_wait_timeout (DBusCondVar *cond, - DBusMutex *mutex, - int timeout_msec) +/** + * Initializes threads. If this function is not called, the D-Bus + * library will not lock any data structures. If it is called, D-Bus + * will do locking, at some cost in efficiency. + * + * Since D-Bus 1.7 it is safe to call this function from any thread, + * any number of times (but it must be called before any other + * libdbus API is used). + * + * In D-Bus 1.6 or older, this function must be called in the main thread + * before any other thread starts. As a result, it is not sufficient to + * call this function in a library or plugin, unless the library or plugin + * imposes a similar requirement on its callers. + * + * dbus_shutdown() reverses the effects of this function when it + * resets all global state in libdbus. + * + * @returns #TRUE on success, #FALSE if not enough memory + */ +dbus_bool_t +dbus_threads_init_default (void) { - return TRUE; + return dbus_threads_init (NULL); } -static void -dbus_fake_condvar_wake_one (DBusCondVar *cond) -{ - -} -static void -dbus_fake_condvar_wake_all (DBusCondVar *cond) -{ +/** @} */ -} +#ifdef DBUS_BUILD_TESTS dbus_bool_t _dbus_threads_init_debug (void) { - return dbus_threads_init (&fake_functions); + return dbus_threads_init (NULL); } #endif /* DBUS_BUILD_TESTS */ - -/** @} */