lock.h File Reference

Asterisk locking-related definitions: More...

#include <pthread.h>
#include <time.h>
#include <sys/param.h>
#include <execinfo.h>
#include "asterisk/backtrace.h"
#include "asterisk/logger.h"
#include "asterisk/compiler.h"
#include "asterisk/inline_api.h"

Include dependency graph for lock.h:

Go to the source code of this file.

Data Structures
struct	ast_lock_track
	Lock tracking information. More...
struct	ast_lock_track_flags
struct	ast_mutex_info
	Structure for mutex and tracking information. More...
struct	ast_rwlock_info
	Structure for rwlock and tracking information. More...

Macros
#define	__AST_MUTEX_DEFINE(scope, mutex, init_val, track)   scope ast_mutex_t mutex = init_val
#define	__AST_RWLOCK_DEFINE(scope, rwlock, init_val, track)   scope ast_rwlock_t rwlock = init_val
#define	__AST_RWLOCK_INIT_VALUE   PTHREAD_RWLOCK_INITIALIZER
#define	AO2_DEADLOCK_AVOIDANCE(obj)
#define	ast_cond_broadcast(cond)   __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
#define	ast_cond_destroy(cond)   __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
#define	ast_cond_init(cond, attr)   __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
#define	ast_cond_signal(cond)   __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
#define	ast_cond_timedwait(cond, mutex, time)   __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
#define	ast_cond_wait(cond, mutex)   __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
#define	AST_LOCK_TRACK_INIT_VALUE   { { NULL }, { 0 }, 0, { NULL }, { 0 }, {{{ 0 }}}, PTHREAD_MUTEX_INIT_VALUE }
#define	AST_MAX_REENTRANCY   10
#define	AST_MUTEX_DEFINE_STATIC(mutex)   __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE, 1)
#define	AST_MUTEX_DEFINE_STATIC_NOTRACKING(mutex)   __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE_NOTRACKING, 0)
#define	ast_mutex_destroy(a)   __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
#define	ast_mutex_init(pmutex)   __ast_pthread_mutex_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
#define	ast_mutex_init_notracking(pmutex)   __ast_pthread_mutex_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
#define	AST_MUTEX_INIT_VALUE   { PTHREAD_MUTEX_INIT_VALUE, NULL, {1, 0} }
#define	AST_MUTEX_INIT_VALUE_NOTRACKING   { PTHREAD_MUTEX_INIT_VALUE, NULL, {0, 0} }
#define	AST_MUTEX_INITIALIZER   __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
#define	AST_MUTEX_KIND   PTHREAD_MUTEX_RECURSIVE_NP
#define	ast_mutex_lock(a)   __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
#define	ast_mutex_trylock(a)   __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
#define	ast_mutex_unlock(a)   __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
#define	AST_PTHREADT_NULL   (pthread_t) -1
#define	AST_PTHREADT_STOP   (pthread_t) -2
#define	AST_RWLOCK_DEFINE_STATIC(rwlock)   __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE, 1)
#define	AST_RWLOCK_DEFINE_STATIC_NOTRACKING(rwlock)   __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE_NOTRACKING, 0)
#define	ast_rwlock_destroy(rwlock)   __ast_rwlock_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
#define	ast_rwlock_init(rwlock)   __ast_rwlock_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
	wrapper for rwlock with tracking enabled
#define	ast_rwlock_init_notracking(rwlock)   __ast_rwlock_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
	wrapper for ast_rwlock_init with tracking disabled
#define	AST_RWLOCK_INIT_VALUE   { __AST_RWLOCK_INIT_VALUE, NULL, {1, 0} }
#define	AST_RWLOCK_INIT_VALUE_NOTRACKING   { __AST_RWLOCK_INIT_VALUE, NULL, {0, 0} }
#define	ast_rwlock_rdlock(a)   __ast_rwlock_rdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
#define	ast_rwlock_timedrdlock(a, b)   __ast_rwlock_timedrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)
#define	ast_rwlock_timedwrlock(a, b)   __ast_rwlock_timedwrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)
#define	ast_rwlock_tryrdlock(a)   __ast_rwlock_tryrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
#define	ast_rwlock_trywrlock(a)   __ast_rwlock_trywrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
#define	ast_rwlock_unlock(a)   __ast_rwlock_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
#define	ast_rwlock_wrlock(a)   __ast_rwlock_wrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
#define	CHANNEL_DEADLOCK_AVOIDANCE(chan)
#define	DEADLOCK_AVOIDANCE(lock)
#define	DLA_LOCK(lock)   ast_mutex_lock(lock)
#define	DLA_UNLOCK(lock)   ast_mutex_unlock(lock)
#define	gethostbyname   __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
#define	pthread_cond_broadcast   use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
#define	pthread_cond_destroy   use_ast_cond_destroy_instead_of_pthread_cond_destroy
#define	pthread_cond_init   use_ast_cond_init_instead_of_pthread_cond_init
#define	pthread_cond_signal   use_ast_cond_signal_instead_of_pthread_cond_signal
#define	pthread_cond_t   use_ast_cond_t_instead_of_pthread_cond_t
#define	pthread_cond_timedwait   use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
#define	pthread_cond_wait   use_ast_cond_wait_instead_of_pthread_cond_wait
#define	pthread_create   __use_ast_pthread_create_instead__
#define	pthread_mutex_destroy   use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
#define	pthread_mutex_init   use_ast_mutex_init_instead_of_pthread_mutex_init
#define	PTHREAD_MUTEX_INIT_VALUE   PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
#define	pthread_mutex_lock   use_ast_mutex_lock_instead_of_pthread_mutex_lock
#define	pthread_mutex_t   use_ast_mutex_t_instead_of_pthread_mutex_t
#define	pthread_mutex_trylock   use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
#define	pthread_mutex_unlock   use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
#define	ROFFSET   ((lt->reentrancy > 0) ? (lt->reentrancy-1) : 0)
#define	SCOPED_AO2LOCK(varname, obj)   SCOPED_LOCK(varname, (obj), ao2_lock, ao2_unlock)
	scoped lock specialization for ao2 mutexes.
#define	SCOPED_AO2RDLOCK(varname, obj)   SCOPED_LOCK(varname, (obj), ao2_rdlock, ao2_unlock)
	scoped lock specialization for ao2 read locks.
#define	SCOPED_AO2WRLOCK(varname, obj)   SCOPED_LOCK(varname, (obj), ao2_wrlock, ao2_unlock)
	scoped lock specialization for ao2 write locks.
#define	SCOPED_CHANNELLOCK(varname, chan)   SCOPED_LOCK(varname, (chan), ast_channel_lock, ast_channel_unlock)
	scoped lock specialization for channels.
#define	SCOPED_LOCK(varname, lock, lockfunc, unlockfunc)    RAII_VAR(typeof((lock)), varname, ({lockfunc((lock)); (lock); }), unlockfunc)
	Scoped Locks.
#define	SCOPED_MUTEX(varname, lock)   SCOPED_LOCK(varname, (lock), ast_mutex_lock, ast_mutex_unlock)
	scoped lock specialization for mutexes
#define	SCOPED_RDLOCK(varname, lock)   SCOPED_LOCK(varname, (lock), ast_rwlock_rdlock, ast_rwlock_unlock)
	scoped lock specialization for read locks
#define	SCOPED_WRLOCK(varname, lock)   SCOPED_LOCK(varname, (lock), ast_rwlock_wrlock, ast_rwlock_unlock)
	scoped lock specialization for write locks

Typedefs
typedef pthread_cond_t	ast_cond_t
typedef struct ast_mutex_info	ast_mutex_t
typedef struct ast_rwlock_info	ast_rwlock_t

Functions
int	__ast_cond_broadcast (const char *filename, int lineno, const char *func, const char *cond_name, ast_cond_t *cond)
int	__ast_cond_destroy (const char *filename, int lineno, const char *func, const char *cond_name, ast_cond_t *cond)
int	__ast_cond_init (const char *filename, int lineno, const char *func, const char *cond_name, ast_cond_t *cond, pthread_condattr_t *cond_attr)
int	__ast_cond_signal (const char *filename, int lineno, const char *func, const char *cond_name, ast_cond_t *cond)
int	__ast_cond_timedwait (const char *filename, int lineno, const char *func, const char *cond_name, const char *mutex_name, ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
int	__ast_cond_wait (const char *filename, int lineno, const char *func, const char *cond_name, const char *mutex_name, ast_cond_t *cond, ast_mutex_t *t)
int	__ast_pthread_mutex_destroy (const char *filename, int lineno, const char *func, const char *mutex_name, ast_mutex_t *t)
int	__ast_pthread_mutex_init (int tracking, const char *filename, int lineno, const char *func, const char *mutex_name, ast_mutex_t *t)
int	__ast_pthread_mutex_lock (const char *filename, int lineno, const char *func, const char *mutex_name, ast_mutex_t *t)
int	__ast_pthread_mutex_trylock (const char *filename, int lineno, const char *func, const char *mutex_name, ast_mutex_t *t)
int	__ast_pthread_mutex_unlock (const char *filename, int lineno, const char *func, const char *mutex_name, ast_mutex_t *t)
int	__ast_rwlock_destroy (const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
int	__ast_rwlock_init (int tracking, const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
int	__ast_rwlock_rdlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_timedrdlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout)
int	__ast_rwlock_timedwrlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout)
int	__ast_rwlock_tryrdlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_trywrlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_unlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_wrlock (const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name)
#define	ast_atomic_add_fetch(ptr, val, memorder)   __atomic_add_fetch((ptr), (val), (memorder))
#define	ast_atomic_and_fetch(ptr, val, memorder)   __atomic_and_fetch((ptr), (val), (memorder))
int	ast_atomic_dec_and_test (volatile int *p)
	decrement *p by 1 and return true if the variable has reached 0.
#define	ast_atomic_fetch_add(ptr, val, memorder)   __atomic_fetch_add((ptr), (val), (memorder))
	Support for atomic instructions.
#define	ast_atomic_fetch_and(ptr, val, memorder)   __atomic_fetch_and((ptr), (val), (memorder))
#define	ast_atomic_fetch_or(ptr, val, memorder)   __atomic_fetch_or((ptr), (val), (memorder))
#define	ast_atomic_fetch_sub(ptr, val, memorder)   __atomic_fetch_sub((ptr), (val), (memorder))
#define	ast_atomic_fetch_xor(ptr, val, memorder)   __atomic_fetch_xor((ptr), (val), (memorder))
int	ast_atomic_fetchadd_int (volatile int *p, int v)
	Atomically add v to *p and return the previous value of *p.
#define	ast_atomic_flag_clear(ptr, val, memorder)   ast_atomic_fetch_and((ptr), ~(val), (memorder))
#define	ast_atomic_flag_set(ptr, val, memorder)   ast_atomic_fetch_or((ptr), (val), (memorder))
#define	ast_atomic_or_fetch(ptr, val, memorder)   __atomic_or_fetch((ptr), (val), (memorder))
#define	ast_atomic_sub_fetch(ptr, val, memorder)   __atomic_sub_fetch((ptr), (val), (memorder))
#define	ast_atomic_xor_fetch(ptr, val, memorder)   __atomic_xor_fetch((ptr), (val), (memorder))

Detailed Description

Asterisk locking-related definitions:

Magic number.

• ast_mutex_t, ast_rwlock_t and related functions;
• atomic arithmetic instructions;
• wrappers for channel locking.
• See Asterisk thread locking models

This is used to verify that a pointer is a valid astobj2 or ao2_weak reference.

Note

This field is constant after object creation. It shares a uint32_t with options and lockused.

Warning

Stealing bits for any additional writable fields would cause reentrancy issues if using bitfields. If any additional writable bits are required in the future we will need to put all bitfields into a single 'uint32_t flags' field and use atomic operations from to perform writes.

Definition in file lock.h.

Macro Definition Documentation

__AST_MUTEX_DEFINE

#define __AST_MUTEX_DEFINE	(		scope,
			mutex,
			init_val,
			track
	)		scope ast_mutex_t mutex = init_val

Definition at line 524 of file lock.h.

__AST_RWLOCK_DEFINE

#define __AST_RWLOCK_DEFINE	(		scope,
			rwlock,
			init_val,
			track
	)		scope ast_rwlock_t rwlock = init_val

Definition at line 547 of file lock.h.

__AST_RWLOCK_INIT_VALUE

#define __AST_RWLOCK_INIT_VALUE   PTHREAD_RWLOCK_INITIALIZER

Definition at line 91 of file lock.h.

AO2_DEADLOCK_AVOIDANCE

#define AO2_DEADLOCK_AVOIDANCE

(

obj

)

Value:

    ao2_unlock(obj); \
    usleep(1); \
    ao2_lock(obj);

Definition at line 476 of file lock.h.

       { \
        int __res; \
        if (!(__res = ast_mutex_unlock(lock))) { \
            usleep(1); \
            ast_mutex_lock(lock); \
        } else { \
            ast_log(LOG_WARNING, "Failed to unlock mutex '%s' (%s).  I will NOT try to relock. {{{ THIS IS A BUG. }}}\n", #lock, strerror(__res)); \
        } \
    } while (0)
 
#define DLA_UNLOCK(lock) ast_mutex_unlock(lock)
 
#define DLA_LOCK(lock) ast_mutex_lock(lock)
 
#endif /* !DEBUG_THREADS */
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
/*
 * If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope constructors
 * and destructors to create/destroy global mutexes.
 */
#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track)   \
    scope ast_mutex_t mutex = init_val;         \
static void  __attribute__((constructor)) init_##mutex(void)    \
{                               \
    if (track)                      \
        ast_mutex_init(&mutex);             \
    else                            \
        ast_mutex_init_notracking(&mutex);      \
}                               \
                                \
static void  __attribute__((destructor)) fini_##mutex(void) \
{                               \
    ast_mutex_destroy(&mutex);              \
}
#else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
/* By default, use static initialization of mutexes. */
#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track) scope ast_mutex_t mutex = init_val
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
#define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE, 1)
#define AST_MUTEX_DEFINE_STATIC_NOTRACKING(mutex) __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE_NOTRACKING, 0)
 
 
/* Statically declared read/write locks */
#ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) \
        scope ast_rwlock_t rwlock = init_val; \
static void  __attribute__((constructor)) init_##rwlock(void) \
{ \
    if (track) \
            ast_rwlock_init(&rwlock); \
    else \
        ast_rwlock_init_notracking(&rwlock); \
} \
static void  __attribute__((destructor)) fini_##rwlock(void) \
{ \
        ast_rwlock_destroy(&rwlock); \
}
#else
#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) scope ast_rwlock_t rwlock = init_val
#endif
 
#define AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE, 1)
#define AST_RWLOCK_DEFINE_STATIC_NOTRACKING(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE_NOTRACKING, 0)
 
/*!
 * \brief Scoped Locks
 *
 * Scoped locks provide a way to use RAII locks. In other words,
 * declaration of a scoped lock will automatically define and lock
 * the lock. When the lock goes out of scope, it will automatically
 * be unlocked.
 *
 * \code
 * int some_function(struct ast_channel *chan)
 * {
 *     SCOPED_LOCK(lock, chan, ast_channel_lock, ast_channel_unlock);
 *
 *     if (!strcmp(ast_channel_name(chan, "foo")) {
 *         return 0;
 *     }
 *
 *     return -1;
 * }
 * \endcode
 *
 * In the above example, neither return path requires explicit unlocking
 * of the channel.
 *
 * \note
 * Care should be taken when using SCOPED_LOCKS in conjunction with ao2 objects.
 * ao2 objects should be unlocked before they are unreffed. Since SCOPED_LOCK runs
 * once the variable goes out of scope, this can easily lead to situations where the
 * variable gets unlocked after it is unreffed.
 *
 * \param varname The unique name to give to the scoped lock. You are not likely to reference
 * this outside of the SCOPED_LOCK invocation.
 * \param lock The variable to lock. This can be anything that can be passed to a locking
 * or unlocking function.
 * \param lockfunc The function to call to lock the lock
 * \param unlockfunc The function to call to unlock the lock
 */
#define SCOPED_LOCK(varname, lock, lockfunc, unlockfunc) \
    RAII_VAR(typeof((lock)), varname, ({lockfunc((lock)); (lock); }), unlockfunc)
 
/*!
 * \brief scoped lock specialization for mutexes
 */
#define SCOPED_MUTEX(varname, lock) SCOPED_LOCK(varname, (lock), ast_mutex_lock, ast_mutex_unlock)
 
/*!
 * \brief scoped lock specialization for read locks
 */
#define SCOPED_RDLOCK(varname, lock) SCOPED_LOCK(varname, (lock), ast_rwlock_rdlock, ast_rwlock_unlock)
 
/*!
 * \brief scoped lock specialization for write locks
 */
#define SCOPED_WRLOCK(varname, lock) SCOPED_LOCK(varname, (lock), ast_rwlock_wrlock, ast_rwlock_unlock)
 
/*!
 * \brief scoped lock specialization for ao2 mutexes.
 */
#define SCOPED_AO2LOCK(varname, obj) SCOPED_LOCK(varname, (obj), ao2_lock, ao2_unlock)
 
/*!
 * \brief scoped lock specialization for ao2 read locks.
 */
#define SCOPED_AO2RDLOCK(varname, obj) SCOPED_LOCK(varname, (obj), ao2_rdlock, ao2_unlock)
 
/*!
 * \brief scoped lock specialization for ao2 write locks.
 */
#define SCOPED_AO2WRLOCK(varname, obj) SCOPED_LOCK(varname, (obj), ao2_wrlock, ao2_unlock)
 
/*!
 * \brief scoped lock specialization for channels.
 */
#define SCOPED_CHANNELLOCK(varname, chan) SCOPED_LOCK(varname, (chan), ast_channel_lock, ast_channel_unlock)
 
#ifndef __CYGWIN__  /* temporary disabled for cygwin */
#define pthread_mutex_t     use_ast_mutex_t_instead_of_pthread_mutex_t
#define pthread_cond_t      use_ast_cond_t_instead_of_pthread_cond_t
#endif
#define pthread_mutex_lock  use_ast_mutex_lock_instead_of_pthread_mutex_lock
#define pthread_mutex_unlock    use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
#define pthread_mutex_trylock   use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
#define pthread_mutex_init  use_ast_mutex_init_instead_of_pthread_mutex_init
#define pthread_mutex_destroy   use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
#define pthread_cond_init   use_ast_cond_init_instead_of_pthread_cond_init
#define pthread_cond_destroy    use_ast_cond_destroy_instead_of_pthread_cond_destroy
#define pthread_cond_signal use_ast_cond_signal_instead_of_pthread_cond_signal
#define pthread_cond_broadcast  use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
#define pthread_cond_wait   use_ast_cond_wait_instead_of_pthread_cond_wait
#define pthread_cond_timedwait  use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
 
#define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
 
#define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
 
#ifndef __linux__
#define pthread_create __use_ast_pthread_create_instead__
#endif
 
/*!
 * \brief Support for atomic instructions.
 *
 * These macros implement a uniform interface to use built-in atomic functionality.
 * If available __atomic built-ins are prefered.  Legacy __sync built-ins are used
 * as a fallback for older compilers.
 *
 * Detailed documentation can be found in the GCC manual, all API's are modeled after
 * the __atomic interfaces but using the namespace ast_atomic.
 *
 * The memorder argument is always ignored by legacy __sync functions.  Invalid
 * memorder arguments do not produce errors unless __atomic functions are supported
 * as the argument is erased by the preprocessor.
 *
 * \note ast_atomic_fetch_nand and ast_atomic_nand_fetch purposely do not exist.
 *       It's implementation was broken prior to gcc-4.4.
 *
 * @{
 */
 
#include "asterisk/inline_api.h"
 
#if defined(HAVE_C_ATOMICS)
/*! Atomic += */
#define ast_atomic_fetch_add(ptr, val, memorder)  __atomic_fetch_add((ptr), (val), (memorder))
#define ast_atomic_add_fetch(ptr, val, memorder)  __atomic_add_fetch((ptr), (val), (memorder))
 
/*! Atomic -= */
#define ast_atomic_fetch_sub(ptr, val, memorder)  __atomic_fetch_sub((ptr), (val), (memorder))
#define ast_atomic_sub_fetch(ptr, val, memorder)  __atomic_sub_fetch((ptr), (val), (memorder))
 
/*! Atomic &= */
#define ast_atomic_fetch_and(ptr, val, memorder)  __atomic_fetch_and((ptr), (val), (memorder))
#define ast_atomic_and_fetch(ptr, val, memorder)  __atomic_and_fetch((ptr), (val), (memorder))
 
/*! Atomic |= */
#define ast_atomic_fetch_or(ptr, val, memorder)   __atomic_fetch_or((ptr), (val), (memorder))
#define ast_atomic_or_fetch(ptr, val, memorder)   __atomic_or_fetch((ptr), (val), (memorder))
 
/*! Atomic xor = */
#define ast_atomic_fetch_xor(ptr, val, memorder)  __atomic_fetch_xor((ptr), (val), (memorder))
#define ast_atomic_xor_fetch(ptr, val, memorder)  __atomic_xor_fetch((ptr), (val), (memorder))
 
#if 0
/* Atomic compare and swap
 *
 * See comments near the __atomic implementation for why this is disabled.
 */
#define ast_atomic_compare_exchange_n(ptr, expected, desired, success_memorder, failure_memorder) \
    __atomic_compare_exchange_n((ptr), (expected), (desired), 0, success_memorder, failure_memorder)
 
#define ast_atomic_compare_exchange(ptr, expected, desired, success_memorder, failure_memorder) \
    __atomic_compare_exchange((ptr), (expected), (desired), 0, success_memorder, failure_memorder)
#endif
 
#elif defined(HAVE_GCC_ATOMICS)
/*! Atomic += */
#define ast_atomic_fetch_add(ptr, val, memorder)  __sync_fetch_and_add((ptr), (val))
#define ast_atomic_add_fetch(ptr, val, memorder)  __sync_add_and_fetch((ptr), (val))
 
/*! Atomic -= */
#define ast_atomic_fetch_sub(ptr, val, memorder)  __sync_fetch_and_sub((ptr), (val))
#define ast_atomic_sub_fetch(ptr, val, memorder)  __sync_sub_and_fetch((ptr), (val))
 
/*! Atomic &= */
#define ast_atomic_fetch_and(ptr, val, memorder)  __sync_fetch_and_and((ptr), (val))
#define ast_atomic_and_fetch(ptr, val, memorder)  __sync_and_and_fetch((ptr), (val))
 
/*! Atomic |= */
#define ast_atomic_fetch_or(ptr, val, memorder)  __sync_fetch_and_or((ptr), (val))
#define ast_atomic_or_fetch(ptr, val, memorder)  __sync_or_and_fetch((ptr), (val))
 
/*! Atomic xor = */
#define ast_atomic_fetch_xor(ptr, val, memorder)  __sync_fetch_and_xor((ptr), (val))
#define ast_atomic_xor_fetch(ptr, val, memorder)  __sync_xor_and_fetch((ptr), (val))
 
#if 0
/* Atomic compare and swap
 *
 * The \a expected argument is a pointer, I'm guessing __atomic built-ins
 * perform all memory reads/writes in a single atomic operation.  I don't
 * believe this is possible to exactly replicate using __sync built-ins.
 * Will need to determine potential use cases of this feature and write a
 * wrapper which provides consistant behavior between __sync and __atomic
 * implementations.
 */
#define ast_atomic_compare_exchange_n(ptr, expected, desired, success_memorder, failure_memorder) \
    __sync_bool_compare_and_swap((ptr), *(expected), (desired))
 
#define ast_atomic_compare_exchange(ptr, expected, desired, success_memorder, failure_memorder) \
    __sync_bool_compare_and_swap((ptr), *(expected), *(desired))
#endif
 
#else
#error "Atomics not available."
#endif
 
/*! Atomic flag set */
#define ast_atomic_flag_set(ptr, val, memorder)   ast_atomic_fetch_or((ptr), (val), (memorder))
 
/*! Atomic flag clear */
#define ast_atomic_flag_clear(ptr, val, memorder) ast_atomic_fetch_and((ptr), ~(val), (memorder))
 
/*!
 * \brief Atomically add v to *p and return the previous value of *p.
 *
 * This can be used to handle reference counts, and the return value
 * can be used to generate unique identifiers.
 */
AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
{
    return ast_atomic_fetch_add(p, v, __ATOMIC_RELAXED);
})
 
/*!
 * \brief decrement *p by 1 and return true if the variable has reached 0.
 *
 * Useful e.g. to check if a refcount has reached 0.
 */
AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
{
    return ast_atomic_sub_fetch(p, 1, __ATOMIC_RELAXED) == 0;
})
 
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
 
/*! @} */
 
#endif /* _ASTERISK_LOCK_H */

ast_atomic_add_fetch

#define ast_atomic_add_fetch	(		ptr,
			val,
			memorder
	)		__atomic_add_fetch((ptr), (val), (memorder))

Definition at line 677 of file lock.h.

ast_atomic_and_fetch

#define ast_atomic_and_fetch	(		ptr,
			val,
			memorder
	)		__atomic_and_fetch((ptr), (val), (memorder))

Definition at line 685 of file lock.h.

ast_atomic_fetch_add

#define ast_atomic_fetch_add	(		ptr,
			val,
			memorder
	)		__atomic_fetch_add((ptr), (val), (memorder))

Support for atomic instructions.

These macros implement a uniform interface to use built-in atomic functionality. If available __atomic built-ins are prefered. Legacy __sync built-ins are used as a fallback for older compilers.

Detailed documentation can be found in the GCC manual, all API's are modeled after the __atomic interfaces but using the namespace ast_atomic.

The memorder argument is always ignored by legacy __sync functions. Invalid memorder arguments do not produce errors unless __atomic functions are supported as the argument is erased by the preprocessor.

Note

ast_atomic_fetch_nand and ast_atomic_nand_fetch purposely do not exist. It's implementation was broken prior to gcc-4.4.

Atomic +=

Definition at line 676 of file lock.h.

ast_atomic_fetch_and

#define ast_atomic_fetch_and	(		ptr,
			val,
			memorder
	)		__atomic_fetch_and((ptr), (val), (memorder))

Atomic &=

Definition at line 684 of file lock.h.

ast_atomic_fetch_or

#define ast_atomic_fetch_or	(		ptr,
			val,
			memorder
	)		__atomic_fetch_or((ptr), (val), (memorder))

Atomic |=

Definition at line 688 of file lock.h.

ast_atomic_fetch_sub

#define ast_atomic_fetch_sub	(		ptr,
			val,
			memorder
	)		__atomic_fetch_sub((ptr), (val), (memorder))

Atomic -=

Definition at line 680 of file lock.h.

ast_atomic_fetch_xor

#define ast_atomic_fetch_xor	(		ptr,
			val,
			memorder
	)		__atomic_fetch_xor((ptr), (val), (memorder))

Atomic xor =

Definition at line 692 of file lock.h.

ast_atomic_flag_clear

#define ast_atomic_flag_clear	(		ptr,
			val,
			memorder
	)		ast_atomic_fetch_and((ptr), ~(val), (memorder))

Atomic flag clear

Definition at line 753 of file lock.h.

ast_atomic_flag_set

#define ast_atomic_flag_set	(		ptr,
			val,
			memorder
	)		ast_atomic_fetch_or((ptr), (val), (memorder))

Atomic flag set

Definition at line 750 of file lock.h.

ast_atomic_or_fetch

#define ast_atomic_or_fetch	(		ptr,
			val,
			memorder
	)		__atomic_or_fetch((ptr), (val), (memorder))

Definition at line 689 of file lock.h.

ast_atomic_sub_fetch

#define ast_atomic_sub_fetch	(		ptr,
			val,
			memorder
	)		__atomic_sub_fetch((ptr), (val), (memorder))

Definition at line 681 of file lock.h.

ast_atomic_xor_fetch

#define ast_atomic_xor_fetch	(		ptr,
			val,
			memorder
	)		__atomic_xor_fetch((ptr), (val), (memorder))

Definition at line 693 of file lock.h.

ast_cond_broadcast

#define ast_cond_broadcast

(

cond

)

__ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)

Definition at line 211 of file lock.h.

ast_cond_destroy

#define ast_cond_destroy

(

cond

)

__ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)

Definition at line 209 of file lock.h.

ast_cond_init

#define ast_cond_init	(		cond,
			attr
	)		__ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)

Definition at line 208 of file lock.h.

ast_cond_signal

#define ast_cond_signal

(

cond

)

__ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)

Definition at line 210 of file lock.h.

ast_cond_timedwait

#define ast_cond_timedwait	(		cond,
			mutex,
			time
	)		__ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)

Definition at line 213 of file lock.h.

ast_cond_wait

#define ast_cond_wait	(		cond,
			mutex
	)		__ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)

Definition at line 212 of file lock.h.

AST_LOCK_TRACK_INIT_VALUE

#define AST_LOCK_TRACK_INIT_VALUE   { { NULL }, { 0 }, 0, { NULL }, { 0 }, {{{ 0 }}}, PTHREAD_MUTEX_INIT_VALUE }

Definition at line 97 of file lock.h.

AST_MAX_REENTRANCY

#define AST_MAX_REENTRANCY   10

Definition at line 108 of file lock.h.

AST_MUTEX_DEFINE_STATIC

#define AST_MUTEX_DEFINE_STATIC

(

mutex

)

__AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE, 1)

Definition at line 527 of file lock.h.

AST_MUTEX_DEFINE_STATIC_NOTRACKING

#define AST_MUTEX_DEFINE_STATIC_NOTRACKING

(

mutex

)

__AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE_NOTRACKING, 0)

Definition at line 528 of file lock.h.

ast_mutex_destroy

#define ast_mutex_destroy

(

a

)

__ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)

Definition at line 195 of file lock.h.

ast_mutex_init

#define ast_mutex_init

(

pmutex

)

__ast_pthread_mutex_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)

Definition at line 193 of file lock.h.

ast_mutex_init_notracking

#define ast_mutex_init_notracking

(

pmutex

)

__ast_pthread_mutex_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)

Definition at line 194 of file lock.h.

AST_MUTEX_INIT_VALUE

#define AST_MUTEX_INIT_VALUE   { PTHREAD_MUTEX_INIT_VALUE, NULL, {1, 0} }

Definition at line 102 of file lock.h.

AST_MUTEX_INIT_VALUE_NOTRACKING

#define AST_MUTEX_INIT_VALUE_NOTRACKING   { PTHREAD_MUTEX_INIT_VALUE, NULL, {0, 0} }

Definition at line 103 of file lock.h.

AST_MUTEX_INITIALIZER

#define AST_MUTEX_INITIALIZER   __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__

Definition at line 644 of file lock.h.

AST_MUTEX_KIND

#define AST_MUTEX_KIND   PTHREAD_MUTEX_RECURSIVE_NP

Definition at line 84 of file lock.h.

ast_mutex_lock

#define ast_mutex_lock

(

a

)

__ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)

Definition at line 196 of file lock.h.

ast_mutex_trylock

#define ast_mutex_trylock

(

a

)

__ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)

Definition at line 198 of file lock.h.

ast_mutex_unlock

#define ast_mutex_unlock

(

a

)

__ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)

Definition at line 197 of file lock.h.

AST_PTHREADT_NULL

#define AST_PTHREADT_NULL   (pthread_t) -1

Definition at line 73 of file lock.h.

AST_PTHREADT_STOP

#define AST_PTHREADT_STOP   (pthread_t) -2

Definition at line 74 of file lock.h.

AST_RWLOCK_DEFINE_STATIC

#define AST_RWLOCK_DEFINE_STATIC

(

rwlock

)

__AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE, 1)

Definition at line 550 of file lock.h.

AST_RWLOCK_DEFINE_STATIC_NOTRACKING

#define AST_RWLOCK_DEFINE_STATIC_NOTRACKING

(

rwlock

)

__AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE_NOTRACKING, 0)

Definition at line 551 of file lock.h.

ast_rwlock_destroy

#define ast_rwlock_destroy

(

rwlock

)

__ast_rwlock_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)

Definition at line 240 of file lock.h.

ast_rwlock_init

#define ast_rwlock_init

(

rwlock

)

__ast_rwlock_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)

wrapper for rwlock with tracking enabled

Returns

0 on success, non zero for error

Since

1.6.1

Definition at line 231 of file lock.h.

ast_rwlock_init_notracking

#define ast_rwlock_init_notracking

(

rwlock

)

__ast_rwlock_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)

wrapper for ast_rwlock_init with tracking disabled

Returns

0 on success, non zero for error

Since

1.6.1

Definition at line 238 of file lock.h.

AST_RWLOCK_INIT_VALUE

#define AST_RWLOCK_INIT_VALUE   { __AST_RWLOCK_INIT_VALUE, NULL, {1, 0} }

Definition at line 105 of file lock.h.

AST_RWLOCK_INIT_VALUE_NOTRACKING

#define AST_RWLOCK_INIT_VALUE_NOTRACKING   { __AST_RWLOCK_INIT_VALUE, NULL, {0, 0} }

Definition at line 106 of file lock.h.

ast_rwlock_rdlock

#define ast_rwlock_rdlock

(

a

)

__ast_rwlock_rdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)

Definition at line 242 of file lock.h.

ast_rwlock_timedrdlock

#define ast_rwlock_timedrdlock	(		a,
			b
	)		__ast_rwlock_timedrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)

Definition at line 246 of file lock.h.

ast_rwlock_timedwrlock

#define ast_rwlock_timedwrlock	(		a,
			b
	)		__ast_rwlock_timedwrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)

Definition at line 247 of file lock.h.

ast_rwlock_tryrdlock

#define ast_rwlock_tryrdlock

(

a

)

__ast_rwlock_tryrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)

Definition at line 244 of file lock.h.

ast_rwlock_trywrlock

#define ast_rwlock_trywrlock

(

a

)

__ast_rwlock_trywrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)

Definition at line 245 of file lock.h.

ast_rwlock_unlock

#define ast_rwlock_unlock

(

a

)

__ast_rwlock_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)

Definition at line 241 of file lock.h.

ast_rwlock_wrlock

#define ast_rwlock_wrlock

(

a

)

__ast_rwlock_wrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)

Definition at line 243 of file lock.h.

CHANNEL_DEADLOCK_AVOIDANCE

#define CHANNEL_DEADLOCK_AVOIDANCE

(

chan

)

Value:

    ast_channel_unlock(chan); \
    usleep(1); \
    ast_channel_lock(chan);

Definition at line 481 of file lock.h.

DEADLOCK_AVOIDANCE

#define DEADLOCK_AVOIDANCE

(

lock

)

Definition at line 486 of file lock.h.

       { \
        int __res; \
        if (!(__res = ast_mutex_unlock(lock))) { \
            usleep(1); \
            ast_mutex_lock(lock); \
        } else { \
            ast_log(LOG_WARNING, "Failed to unlock mutex '%s' (%s).  I will NOT try to relock. {{{ THIS IS A BUG. }}}\n", #lock, strerror(__res)); \
        } \
    } while (0)

DLA_LOCK

#define DLA_LOCK

(

lock

)

ast_mutex_lock(lock)

Definition at line 499 of file lock.h.

DLA_UNLOCK

#define DLA_UNLOCK

(

lock

)

ast_mutex_unlock(lock)

Definition at line 497 of file lock.h.

gethostbyname

#define gethostbyname   __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__

Definition at line 646 of file lock.h.

pthread_cond_broadcast

#define pthread_cond_broadcast   use_ast_cond_broadcast_instead_of_pthread_cond_broadcast

Definition at line 640 of file lock.h.

pthread_cond_destroy

#define pthread_cond_destroy   use_ast_cond_destroy_instead_of_pthread_cond_destroy

Definition at line 638 of file lock.h.

pthread_cond_init

#define pthread_cond_init   use_ast_cond_init_instead_of_pthread_cond_init

Definition at line 637 of file lock.h.

pthread_cond_signal

#define pthread_cond_signal   use_ast_cond_signal_instead_of_pthread_cond_signal

Definition at line 639 of file lock.h.

pthread_cond_t

#define pthread_cond_t   use_ast_cond_t_instead_of_pthread_cond_t

Definition at line 630 of file lock.h.

pthread_cond_timedwait

#define pthread_cond_timedwait   use_ast_cond_timedwait_instead_of_pthread_cond_timedwait

Definition at line 642 of file lock.h.

pthread_cond_wait

#define pthread_cond_wait   use_ast_cond_wait_instead_of_pthread_cond_wait

Definition at line 641 of file lock.h.

pthread_create

#define pthread_create   __use_ast_pthread_create_instead__

Definition at line 649 of file lock.h.

pthread_mutex_destroy

#define pthread_mutex_destroy   use_ast_mutex_destroy_instead_of_pthread_mutex_destroy

Definition at line 636 of file lock.h.

pthread_mutex_init

#define pthread_mutex_init   use_ast_mutex_init_instead_of_pthread_mutex_init

Definition at line 635 of file lock.h.

PTHREAD_MUTEX_INIT_VALUE

#define PTHREAD_MUTEX_INIT_VALUE   PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP

Definition at line 83 of file lock.h.

pthread_mutex_lock

#define pthread_mutex_lock   use_ast_mutex_lock_instead_of_pthread_mutex_lock

Definition at line 632 of file lock.h.

pthread_mutex_t

#define pthread_mutex_t   use_ast_mutex_t_instead_of_pthread_mutex_t

Definition at line 629 of file lock.h.

pthread_mutex_trylock

#define pthread_mutex_trylock   use_ast_mutex_trylock_instead_of_pthread_mutex_trylock

Definition at line 634 of file lock.h.

pthread_mutex_unlock

#define pthread_mutex_unlock   use_ast_mutex_unlock_instead_of_pthread_mutex_unlock

Definition at line 633 of file lock.h.

ROFFSET

#define ROFFSET   ((lt->reentrancy > 0) ? (lt->reentrancy-1) : 0)

Definition at line 249 of file lock.h.

SCOPED_AO2LOCK

#define SCOPED_AO2LOCK	(		varname,
			obj
	)		SCOPED_LOCK(varname, (obj), ao2_lock, ao2_unlock)

scoped lock specialization for ao2 mutexes.

Definition at line 611 of file lock.h.

SCOPED_AO2RDLOCK

#define SCOPED_AO2RDLOCK	(		varname,
			obj
	)		SCOPED_LOCK(varname, (obj), ao2_rdlock, ao2_unlock)

scoped lock specialization for ao2 read locks.

Definition at line 616 of file lock.h.

SCOPED_AO2WRLOCK

#define SCOPED_AO2WRLOCK	(		varname,
			obj
	)		SCOPED_LOCK(varname, (obj), ao2_wrlock, ao2_unlock)

scoped lock specialization for ao2 write locks.

Definition at line 621 of file lock.h.

SCOPED_CHANNELLOCK

#define SCOPED_CHANNELLOCK	(		varname,
			chan
	)		SCOPED_LOCK(varname, (chan), ast_channel_lock, ast_channel_unlock)

scoped lock specialization for channels.

Definition at line 626 of file lock.h.

SCOPED_LOCK

#define SCOPED_LOCK	(		varname,
			lock,
			lockfunc,
			unlockfunc
	)		RAII_VAR(typeof((lock)), varname, ({lockfunc((lock)); (lock); }), unlockfunc)

Scoped Locks.

Scoped locks provide a way to use RAII locks. In other words, declaration of a scoped lock will automatically define and lock the lock. When the lock goes out of scope, it will automatically be unlocked.

int some_function(struct ast_channel *chan)
{
    SCOPED_LOCK(lock, chan, ast_channel_lock, ast_channel_unlock);
 
    if (!strcmp(ast_channel_name(chan, "foo")) {
        return 0;
    }
 
    return -1;
}

In the above example, neither return path requires explicit unlocking of the channel.

Note

Care should be taken when using SCOPED_LOCKS in conjunction with ao2 objects. ao2 objects should be unlocked before they are unreffed. Since SCOPED_LOCK runs once the variable goes out of scope, this can easily lead to situations where the variable gets unlocked after it is unreffed.

Parameters

varname	The unique name to give to the scoped lock. You are not likely to reference this outside of the SCOPED_LOCK invocation.
lock	The variable to lock. This can be anything that can be passed to a locking or unlocking function.
lockfunc	The function to call to lock the lock
unlockfunc	The function to call to unlock the lock

Definition at line 590 of file lock.h.

                                       {lockfunc((lock)); (lock); }), unlockfunc)

SCOPED_MUTEX

#define SCOPED_MUTEX	(		varname,
			lock
	)		SCOPED_LOCK(varname, (lock), ast_mutex_lock, ast_mutex_unlock)

scoped lock specialization for mutexes

Definition at line 596 of file lock.h.

SCOPED_RDLOCK

#define SCOPED_RDLOCK	(		varname,
			lock
	)		SCOPED_LOCK(varname, (lock), ast_rwlock_rdlock, ast_rwlock_unlock)

scoped lock specialization for read locks

Definition at line 601 of file lock.h.

SCOPED_WRLOCK

#define SCOPED_WRLOCK	(		varname,
			lock
	)		SCOPED_LOCK(varname, (lock), ast_rwlock_wrlock, ast_rwlock_unlock)

scoped lock specialization for write locks

Definition at line 606 of file lock.h.

Typedef Documentation

ast_cond_t

typedef pthread_cond_t ast_cond_t

Definition at line 185 of file lock.h.

ast_mutex_t

typedef struct ast_mutex_info ast_mutex_t

Definition at line 181 of file lock.h.

ast_rwlock_t

typedef struct ast_rwlock_info ast_rwlock_t

Definition at line 183 of file lock.h.

Function Documentation

__ast_cond_broadcast()

int __ast_cond_broadcast	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		ast_cond_t *	cond
	)

Definition at line 536 of file lock.c.

{
    return pthread_cond_broadcast(cond);
}

References cond, and pthread_cond_broadcast.

__ast_cond_destroy()

int __ast_cond_destroy	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		ast_cond_t *	cond
	)

Definition at line 542 of file lock.c.

{
    return pthread_cond_destroy(cond);
}

References cond, and pthread_cond_destroy.

__ast_cond_init()

int __ast_cond_init	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		ast_cond_t *	cond,
		pthread_condattr_t *	cond_attr
	)

Definition at line 524 of file lock.c.

{
    return pthread_cond_init(cond, cond_attr);
}

References cond, and pthread_cond_init.

__ast_cond_signal()

int __ast_cond_signal	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		ast_cond_t *	cond
	)

Definition at line 530 of file lock.c.

{
    return pthread_cond_signal(cond);
}

References cond, and pthread_cond_signal.

__ast_cond_timedwait()

int __ast_cond_timedwait	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		const char *	mutex_name,
		ast_cond_t *	cond,
		ast_mutex_t *	t,
		const struct timespec *	abstime
	)

Definition at line 636 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = NULL;
    struct ast_lock_track lt_orig;
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
        log_mutex_error(canlog, "%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
                   filename, lineno, func, mutex_name);
        DO_THREAD_CRASH;
        return EINVAL;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
    lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    if (lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy && (lt->thread_id[ROFFSET] != pthread_self())) {
            log_mutex_error(canlog, "%s line %d (%s): attempted wait using mutex '%s' without owning it!\n",
                       filename, lineno, func, mutex_name);
            log_mutex_error(canlog, "%s line %d (%s): '%s' was locked here.\n",
                       lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
            __dump_backtrace(&lt->backtrace[ROFFSET], canlog);
#endif
            DO_THREAD_CRASH;
        } else if (lt->reentrancy <= 0) {
            log_mutex_error(canlog, "%s line %d (%s): attempted wait using an unlocked mutex '%s'\n",
                       filename, lineno, func, mutex_name);
            DO_THREAD_CRASH;
        }
 
        /* Waiting on a condition completely suspends a recursive mutex,
         * even if it's been recursively locked multiple times. Make a
         * copy of the lock tracking, and reset reentrancy to zero */
        lt_orig = *lt;
        lt->reentrancy = 0;
        ast_reentrancy_unlock(lt);
 
        ast_suspend_lock_info(t);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_cond_timedwait(cond, &t->mutex, abstime);
 
#ifdef DEBUG_THREADS
    if (res && (res != ETIMEDOUT)) {
        log_mutex_error(canlog, "%s line %d (%s): Error waiting on condition mutex '%s'\n",
                   filename, lineno, func, strerror(res));
        DO_THREAD_CRASH;
    } else if (lt) {
        restore_lock_tracking(lt, &lt_orig);
        ast_restore_lock_info(t);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_lock_track::backtrace, cond, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, NULL, pthread_cond_timedwait, pthread_mutex_t, ast_lock_track::reentrancy, ROFFSET, and ast_lock_track::thread_id.

__ast_cond_wait()

int __ast_cond_wait	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	cond_name,
		const char *	mutex_name,
		ast_cond_t *	cond,
		ast_mutex_t *	t
	)

Definition at line 571 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = NULL;
    struct ast_lock_track lt_orig;
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
        log_mutex_error(canlog, "%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
                   filename, lineno, func, mutex_name);
        DO_THREAD_CRASH;
        return EINVAL;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
    lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    if (lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy && (lt->thread_id[ROFFSET] != pthread_self())) {
            log_mutex_error(canlog, "%s line %d (%s): attempted wait using mutex '%s' without owning it!\n",
                       filename, lineno, func, mutex_name);
            log_mutex_error(canlog, "%s line %d (%s): '%s' was locked here.\n",
                       lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
            __dump_backtrace(&lt->backtrace[ROFFSET], canlog);
#endif
            DO_THREAD_CRASH;
        } else if (lt->reentrancy <= 0) {
            log_mutex_error(canlog, "%s line %d (%s): attempted wait using an unlocked mutex '%s'\n",
                       filename, lineno, func, mutex_name);
            DO_THREAD_CRASH;
        }
 
        /* Waiting on a condition completely suspends a recursive mutex,
         * even if it's been recursively locked multiple times. Make a
         * copy of the lock tracking, and reset reentrancy to zero */
        lt_orig = *lt;
        lt->reentrancy = 0;
        ast_reentrancy_unlock(lt);
 
        ast_suspend_lock_info(t);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_cond_wait(cond, &t->mutex);
 
#ifdef DEBUG_THREADS
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error waiting on condition mutex '%s'\n",
                   filename, lineno, func, strerror(res));
        DO_THREAD_CRASH;
    } else if (lt) {
        restore_lock_tracking(lt, &lt_orig);
        ast_restore_lock_info(t);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_lock_track::backtrace, cond, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, NULL, pthread_cond_wait, pthread_mutex_t, ast_lock_track::reentrancy, ROFFSET, and ast_lock_track::thread_id.

__ast_pthread_mutex_destroy()

int __ast_pthread_mutex_destroy	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	mutex_name,
		ast_mutex_t *	t
	)

Definition at line 177 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 1);
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
        /* Don't try to uninitialize an uninitialized mutex
         * This may have no effect on linux
         * but it always generates a core on *BSD when
         * linked with libpthread.
         * This is not an error condition if the mutex is created on the fly.
         */
        log_mutex_error(canlog, "%s line %d (%s): NOTICE: mutex '%s' is uninitialized.\n",
                   filename, lineno, func, mutex_name);
        DO_THREAD_CRASH;
        res = EINVAL;
        goto lt_cleanup;
    }
#endif
 
    res = pthread_mutex_trylock(&t->mutex);
    switch (res) {
    case 0:
        pthread_mutex_unlock(&t->mutex);
        break;
    case EINVAL:
        log_mutex_error(canlog, "%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
                  filename, lineno, func, mutex_name);
        break;
    case EBUSY:
        log_mutex_error(canlog, "%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
                   filename, lineno, func, mutex_name);
        if (lt) {
            ast_reentrancy_lock(lt);
            log_mutex_error(canlog, "%s line %d (%s): Error: '%s' was locked here.\n",
                    lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
            __dump_backtrace(&lt->backtrace[ROFFSET], canlog);
#endif
            ast_reentrancy_unlock(lt);
        }
        break;
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_mutex_destroy(&t->mutex);
 
#ifdef DEBUG_THREADS
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error destroying mutex %s: %s\n",
                   filename, lineno, func, mutex_name, strerror(res));
    }
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
lt_cleanup:
#endif
    if (lt) {
        ast_reentrancy_lock(lt);
        lt->file[0] = filename;
        lt->lineno[0] = lineno;
        lt->func[0] = func;
        lt->reentrancy = 0;
        lt->thread_id[0] = 0;
#ifdef HAVE_BKTR
        memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
#endif
        ast_reentrancy_unlock(lt);
        delete_reentrancy_cs(&t->track);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, pthread_mutex_destroy, pthread_mutex_t, pthread_mutex_trylock, pthread_mutex_unlock, ast_lock_track::reentrancy, ROFFSET, and ast_lock_track::thread_id.

__ast_pthread_mutex_init()

int __ast_pthread_mutex_init	(	int	tracking,
		const char *	filename,
		int	lineno,
		const char *	func,
		const char *	mutex_name,
		ast_mutex_t *	t
	)

Definition at line 145 of file lock.c.

{
    int res;
    pthread_mutexattr_t  attr;
 
#if defined(DEBUG_THREADS) && defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && \
    defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->mutex) != ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
        int canlog = tracking && strcmp(filename, "logger.c");
 
        log_mutex_error(canlog, "%s line %d (%s): NOTICE: mutex '%s' is already initialized.\n",
                   filename, lineno, func, mutex_name);
        DO_THREAD_CRASH;
        return EBUSY;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
#if defined(DEBUG_THREADS) || defined(DETECT_DEADLOCKS)
    t->track = NULL;
    t->flags.tracking = tracking;
    t->flags.setup = 0;
#endif /* DEBUG_THREADS */
 
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
    res = pthread_mutex_init(&t->mutex, &attr);
    pthread_mutexattr_destroy(&attr);
 
    return res;
}

References AST_MUTEX_KIND, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, NULL, pthread_mutex_init, and pthread_mutex_t.

__ast_pthread_mutex_lock()

int __ast_pthread_mutex_lock	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	mutex_name,
		ast_mutex_t *	t
	)

Definition at line 255 of file lock.c.

{
    int res;
 
#if defined(DETECT_DEADLOCKS) || defined(DEBUG_THREADS)
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
#endif
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
#if defined(DETECT_DEADLOCKS)
    {
        time_t seconds = time(NULL);
        time_t wait_time, reported_wait = 0;
        do {
#ifdef  HAVE_MTX_PROFILE
            ast_mark(mtx_prof, 1);
#endif
            res = pthread_mutex_trylock(&t->mutex);
#ifdef  HAVE_MTX_PROFILE
            ast_mark(mtx_prof, 0);
#endif
            if (res == EBUSY) {
                wait_time = time(NULL) - seconds;
                if (wait_time > reported_wait && (wait_time % 5) == 0) {
                    log_mutex_error(canlog, "%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
                               filename, lineno, func, (int) wait_time, mutex_name);
#ifdef DEBUG_THREADS
                    if (lt) {
                        ast_reentrancy_lock(lt);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[lt->reentrancy], canlog);
#endif
                        log_mutex_error(canlog, "%s line %d (%s): '%s' was locked here.\n",
                                   lt->file[ROFFSET], lt->lineno[ROFFSET],
                                   lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[ROFFSET], canlog);
#endif
                        ast_reentrancy_unlock(lt);
                    }
#endif
                    reported_wait = wait_time;
                    if ((int) wait_time < 10) { /* Only emit an event when a deadlock starts, not every 5 seconds */
                        /*** DOCUMENTATION
                            <managerEvent language="en_US" name="DeadlockStart">
                                <managerEventInstance class="EVENT_FLAG_SYSTEM">
                                    <since>
                                        <version>16.29.0</version>
                                        <version>18.15.0</version>
                                        <version>19.7.0</version>
                                    </since>
                                    <synopsis>Raised when a probable deadlock has started.
                                    Delivery of this event is attempted but not guaranteed,
                                                                        and could fail for example if the manager itself is deadlocked.
                                                                        </synopsis>
                                        <syntax>
                                            <parameter name="Mutex">
                                                <para>The mutex involved in the deadlock.</para>
                                            </parameter>
                                        </syntax>
                                </managerEventInstance>
                            </managerEvent>
                        ***/
                        manager_event(EVENT_FLAG_SYSTEM, "DeadlockStart",
                            "Mutex: %s\r\n",
                            mutex_name);
                    }
                }
                usleep(200);
            }
        } while (res == EBUSY);
    }
#else /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
#ifdef  HAVE_MTX_PROFILE
    ast_mark(mtx_prof, 1);
    res = pthread_mutex_trylock(&t->mutex);
    ast_mark(mtx_prof, 0);
    if (res)
#endif
    res = pthread_mutex_lock(&t->mutex);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
 
#ifdef DEBUG_THREADS
    if (lt && !res) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = lineno;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        } else {
            log_mutex_error(canlog, "%s line %d (%s): '%s' really deep reentrancy!\n",
                               filename, lineno, func, mutex_name);
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            ast_reentrancy_lock(lt);
            bt = &lt->backtrace[lt->reentrancy-1];
            ast_reentrancy_unlock(lt);
        } else {
            bt = NULL;
        }
#endif
        ast_remove_lock_info(t, bt);
    }
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error obtaining mutex: %s\n",
                   filename, lineno, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, ast_mark(), AST_MAX_REENTRANCY, AST_MUTEX, ast_lock_track::backtrace, EVENT_FLAG_SYSTEM, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, manager_event, ast_mutex_info::mutex, NULL, pthread_mutex_lock, pthread_mutex_trylock, ast_lock_track::reentrancy, ROFFSET, and ast_lock_track::thread_id.

Referenced by __ao2_lock().

__ast_pthread_mutex_trylock()

int __ast_pthread_mutex_trylock	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	mutex_name,
		ast_mutex_t *	t
	)

Definition at line 398 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_mutex_trylock(&t->mutex);
 
#ifdef DEBUG_THREADS
    if (lt && !res) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = lineno;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        } else {
            log_mutex_error(canlog, "%s line %d (%s): '%s' really deep reentrancy!\n",
                       filename, lineno, func, mutex_name);
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
        ast_mark_lock_failed(t);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, ast_mark_lock_failed(), AST_MAX_REENTRANCY, AST_MUTEX, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, NULL, pthread_mutex_trylock, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_trylock().

__ast_pthread_mutex_unlock()

int __ast_pthread_mutex_unlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	mutex_name,
		ast_mutex_t *	t
	)

Definition at line 453 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = NULL;
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
    struct ast_bt *bt = NULL;
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
        log_mutex_error(canlog, "%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
                   filename, lineno, func, mutex_name);
        DO_THREAD_CRASH;
        return EINVAL;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
    lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    if (lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy && (lt->thread_id[ROFFSET] != pthread_self())) {
            log_mutex_error(canlog, "%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
                       filename, lineno, func, mutex_name);
            log_mutex_error(canlog, "%s line %d (%s): '%s' was locked here.\n",
                       lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
            __dump_backtrace(&lt->backtrace[ROFFSET], canlog);
#endif
            DO_THREAD_CRASH;
        }
 
        if (--lt->reentrancy < 0) {
            log_mutex_error(canlog, "%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
                       filename, lineno, func, mutex_name);
            lt->reentrancy = 0;
        }
 
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = NULL;
            lt->lineno[lt->reentrancy] = 0;
            lt->func[lt->reentrancy] = NULL;
            lt->thread_id[lt->reentrancy] = 0;
        }
 
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            bt = &lt->backtrace[lt->reentrancy - 1];
        }
#endif
        ast_reentrancy_unlock(lt);
 
        ast_remove_lock_info(t, bt);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_mutex_unlock(&t->mutex);
 
#ifdef DEBUG_THREADS
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error releasing mutex: %s\n",
                   filename, lineno, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References AST_MAX_REENTRANCY, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_mutex_info::mutex, NULL, pthread_mutex_t, pthread_mutex_unlock, ast_lock_track::reentrancy, ROFFSET, and ast_lock_track::thread_id.

Referenced by __ao2_unlock().

__ast_rwlock_destroy()

int __ast_rwlock_destroy	(	const char *	filename,
		int	lineno,
		const char *	func,
		const char *	rwlock_name,
		ast_rwlock_t *	t
	)

Definition at line 735 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 1);
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if (t->lock == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
        log_mutex_error(canlog, "%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
                   filename, lineno, func, rwlock_name);
        DO_THREAD_CRASH;
        res = EINVAL;
        goto lt_cleanup;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
#endif /* DEBUG_THREADS */
 
    res = pthread_rwlock_destroy(&t->lock);
 
#ifdef DEBUG_THREADS
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error destroying rwlock %s: %s\n",
                filename, lineno, func, rwlock_name, strerror(res));
    }
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
lt_cleanup:
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
    if (lt) {
        ast_reentrancy_lock(lt);
        lt->file[0] = filename;
        lt->lineno[0] = lineno;
        lt->func[0] = func;
        lt->reentrancy = 0;
        lt->thread_id[0] = 0;
#ifdef HAVE_BKTR
        memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
#endif
        ast_reentrancy_unlock(lt);
        delete_reentrancy_cs(&t->track);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References __AST_RWLOCK_INIT_VALUE, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

__ast_rwlock_init()

int __ast_rwlock_init	(	int	tracking,
		const char *	filename,
		int	lineno,
		const char *	func,
		const char *	rwlock_name,
		ast_rwlock_t *	t
	)

Definition at line 701 of file lock.c.

{
    int res;
    pthread_rwlockattr_t attr;
 
#if defined(DEBUG_THREADS) && defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && \
    defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if (t->lock != ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
        int canlog = tracking && strcmp(filename, "logger.c");
 
        log_mutex_error(canlog, "%s line %d (%s): Warning: rwlock '%s' is already initialized.\n",
                filename, lineno, func, rwlock_name);
        DO_THREAD_CRASH;
        return EBUSY;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
#if defined(DEBUG_THREADS) || defined(DETECT_DEADLOCKS)
    t->track = NULL;
    t->flags.tracking = tracking;
    t->flags.setup = 0;
#endif /* DEBUG_THREADS */
 
    pthread_rwlockattr_init(&attr);
#ifdef HAVE_PTHREAD_RWLOCK_PREFER_WRITER_NP
    pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);
#endif
    res = pthread_rwlock_init(&t->lock, &attr);
    pthread_rwlockattr_destroy(&attr);
 
    return res;
}

References __AST_RWLOCK_INIT_VALUE, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, and NULL.

__ast_rwlock_rdlock()

int __ast_rwlock_rdlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name
	)

Definition at line 853 of file lock.c.

{
    int res;
 
#if defined(DEBUG_THREADS) || defined(DETECT_DEADLOCKS)
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
#endif
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
#if defined(DETECT_DEADLOCKS)
    {
        time_t seconds = time(NULL);
        time_t wait_time, reported_wait = 0;
        do {
            res = pthread_rwlock_tryrdlock(&t->lock);
            if (res == EBUSY) {
                wait_time = time(NULL) - seconds;
                if (wait_time > reported_wait && (wait_time % 5) == 0) {
                    log_mutex_error(canlog, "%s line %d (%s): Deadlock? waited %d sec for readlock '%s'?\n",
                        filename, line, func, (int)wait_time, name);
#ifdef DEBUG_THREADS
                    if (lt) {
                        ast_reentrancy_lock(lt);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[lt->reentrancy], canlog);
#endif
                        log_mutex_error(canlog, "%s line %d (%s): '%s' was locked  here.\n",
                                lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
                                lt->func[lt->reentrancy-1], name);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[lt->reentrancy-1], canlog);
#endif
                        ast_reentrancy_unlock(lt);
                    }
#endif
                    reported_wait = wait_time;
                }
                usleep(200);
            }
        } while (res == EBUSY);
    }
#else /* !DETECT_DEADLOCKS */
    res = pthread_rwlock_rdlock(&t->lock);
#endif /* !DETECT_DEADLOCKS */
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            ast_reentrancy_lock(lt);
            bt = &lt->backtrace[lt->reentrancy-1];
            ast_reentrancy_unlock(lt);
        } else {
            bt = NULL;
        }
#endif
        ast_remove_lock_info(t, bt);
    }
 
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error obtaining read lock: %s\n",
                filename, line, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, AST_MAX_REENTRANCY, AST_RDLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_global_obj_ref(), __ao2_lock(), and __ast_heap_rdlock().

__ast_rwlock_timedrdlock()

int __ast_rwlock_timedrdlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name,
		const struct timespec *	abs_timeout
	)

Definition at line 1060 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
    res = pthread_rwlock_timedrdlock(&t->lock, abs_timeout);
#else
    do {
        struct timeval _now;
        for (;;) {
            if (!(res = pthread_rwlock_tryrdlock(&t->lock))) {
                break;
            }
            _now = ast_tvnow();
            if (_now.tv_sec > abs_timeout->tv_sec || (_now.tv_sec == abs_timeout->tv_sec && _now.tv_usec * 1000 > abs_timeout->tv_nsec)) {
                break;
            }
            usleep(1);
        }
    } while (0);
#endif
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            ast_reentrancy_lock(lt);
            bt = &lt->backtrace[lt->reentrancy-1];
            ast_reentrancy_unlock(lt);
        } else {
            bt = NULL;
        }
#endif
        ast_remove_lock_info(t, bt);
    }
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error obtaining read lock: %s\n",
                filename, line, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, AST_MAX_REENTRANCY, ast_tvnow(), AST_WRLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

__ast_rwlock_timedwrlock()

int __ast_rwlock_timedwrlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name,
		const struct timespec *	abs_timeout
	)

Definition at line 1142 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
    res = pthread_rwlock_timedwrlock(&t->lock, abs_timeout);
#else
    do {
        struct timeval _now;
        for (;;) {
            if (!(res = pthread_rwlock_trywrlock(&t->lock))) {
                break;
            }
            _now = ast_tvnow();
            if (_now.tv_sec > abs_timeout->tv_sec || (_now.tv_sec == abs_timeout->tv_sec && _now.tv_usec * 1000 > abs_timeout->tv_nsec)) {
                break;
            }
            usleep(1);
        }
    } while (0);
#endif
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            ast_reentrancy_lock(lt);
            bt = &lt->backtrace[lt->reentrancy-1];
            ast_reentrancy_unlock(lt);
        } else {
            bt = NULL;
        }
#endif
        ast_remove_lock_info(t, bt);
    }
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error obtaining read lock: %s\n",
                filename, line, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, AST_MAX_REENTRANCY, ast_tvnow(), AST_WRLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

__ast_rwlock_tryrdlock()

int __ast_rwlock_tryrdlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name
	)

Definition at line 1224 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_rwlock_tryrdlock(&t->lock);
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
        ast_mark_lock_failed(t);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, ast_mark_lock_failed(), AST_MAX_REENTRANCY, AST_RDLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_trylock().

__ast_rwlock_trywrlock()

int __ast_rwlock_trywrlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name
	)

Definition at line 1274 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_rwlock_trywrlock(&t->lock);
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
        ast_mark_lock_failed(t);
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, ast_mark_lock_failed(), AST_MAX_REENTRANCY, AST_WRLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_trylock().

__ast_rwlock_unlock()

int __ast_rwlock_unlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name
	)

Definition at line 782 of file lock.c.

{
    int res;
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = NULL;
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
    struct ast_bt *bt = NULL;
    int lock_found = 0;
 
#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
    if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
        log_mutex_error(canlog, "%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
                   filename, line, func, name);
        DO_THREAD_CRASH;
        return EINVAL;
    }
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
    lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    if (lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy) {
            int i;
            pthread_t self = pthread_self();
            for (i = lt->reentrancy - 1; i >= 0; --i) {
                if (lt->thread_id[i] == self) {
                    lock_found = 1;
                    if (i != lt->reentrancy - 1) {
                        lt->file[i] = lt->file[lt->reentrancy - 1];
                        lt->lineno[i] = lt->lineno[lt->reentrancy - 1];
                        lt->func[i] = lt->func[lt->reentrancy - 1];
                        lt->thread_id[i] = lt->thread_id[lt->reentrancy - 1];
                    }
#ifdef HAVE_BKTR
                    bt = &lt->backtrace[i];
#endif
                    lt->file[lt->reentrancy - 1] = NULL;
                    lt->lineno[lt->reentrancy - 1] = 0;
                    lt->func[lt->reentrancy - 1] = NULL;
                    lt->thread_id[lt->reentrancy - 1] = AST_PTHREADT_NULL;
                    break;
                }
            }
        }
 
        if (lock_found && --lt->reentrancy < 0) {
            log_mutex_error(canlog, "%s line %d (%s): rwlock '%s' freed more times than we've locked!\n",
                    filename, line, func, name);
            lt->reentrancy = 0;
        }
 
        ast_reentrancy_unlock(lt);
 
        ast_remove_lock_info(t, bt);
    }
#endif /* DEBUG_THREADS */
 
    res = pthread_rwlock_unlock(&t->lock);
 
#ifdef DEBUG_THREADS
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error releasing rwlock: %s\n",
                filename, line, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References __AST_RWLOCK_INIT_VALUE, AST_PTHREADT_NULL, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_global_obj_ref(), __ao2_global_obj_replace(), __ao2_unlock(), and __ast_heap_unlock().

__ast_rwlock_wrlock()

int __ast_rwlock_wrlock	(	const char *	filename,
		int	lineno,
		const char *	func,
		ast_rwlock_t *	t,
		const char *	name
	)

Definition at line 957 of file lock.c.

{
    int res;
 
#if defined(DEBUG_THREADS) || defined(DETECT_DEADLOCKS)
    int canlog = t->flags.tracking && strcmp(filename, "logger.c");
#endif
 
#ifdef DEBUG_THREADS
    struct ast_lock_track *lt = ast_get_reentrancy(&t->track, &t->flags, 0);
    struct ast_bt *bt = NULL;
 
    if (lt) {
#ifdef HAVE_BKTR
        struct ast_bt tmp;
 
        /* The implementation of backtrace() may have its own locks.
         * Capture the backtrace outside of the reentrancy lock to
         * avoid deadlocks. See ASTERISK-22455. */
        ast_bt_get_addresses(&tmp);
 
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->backtrace[lt->reentrancy] = tmp;
            bt = &lt->backtrace[lt->reentrancy];
        }
        ast_reentrancy_unlock(lt);
#endif
        ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt);
    }
#endif /* DEBUG_THREADS */
 
#ifdef DETECT_DEADLOCKS
    {
        time_t seconds = time(NULL);
        time_t wait_time, reported_wait = 0;
        do {
            res = pthread_rwlock_trywrlock(&t->lock);
            if (res == EBUSY) {
                wait_time = time(NULL) - seconds;
                if (wait_time > reported_wait && (wait_time % 5) == 0) {
                    log_mutex_error(canlog, "%s line %d (%s): Deadlock? waited %d sec for writelock '%s'?\n",
                        filename, line, func, (int)wait_time, name);
#ifdef DEBUG_THREADS
                    if (lt) {
                        ast_reentrancy_lock(lt);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[lt->reentrancy], canlog);
#endif
                        log_mutex_error(canlog, "%s line %d (%s): '%s' was locked  here.\n",
                                lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
                                lt->func[lt->reentrancy-1], name);
#ifdef HAVE_BKTR
                        __dump_backtrace(&lt->backtrace[lt->reentrancy-1], canlog);
#endif
                        ast_reentrancy_unlock(lt);
                    }
#endif
                    reported_wait = wait_time;
                }
                usleep(200);
            }
        } while (res == EBUSY);
    }
#else /* !DETECT_DEADLOCKS */
    res = pthread_rwlock_wrlock(&t->lock);
#endif /* !DETECT_DEADLOCKS */
 
#ifdef DEBUG_THREADS
    if (!res && lt) {
        ast_reentrancy_lock(lt);
        if (lt->reentrancy < AST_MAX_REENTRANCY) {
            lt->file[lt->reentrancy] = filename;
            lt->lineno[lt->reentrancy] = line;
            lt->func[lt->reentrancy] = func;
            lt->thread_id[lt->reentrancy] = pthread_self();
            lt->reentrancy++;
        }
        ast_reentrancy_unlock(lt);
        ast_mark_lock_acquired(t);
    } else if (lt) {
#ifdef HAVE_BKTR
        if (lt->reentrancy) {
            ast_reentrancy_lock(lt);
            bt = &lt->backtrace[lt->reentrancy-1];
            ast_reentrancy_unlock(lt);
        } else {
            bt = NULL;
        }
#endif
        ast_remove_lock_info(t, bt);
    }
    if (res) {
        log_mutex_error(canlog, "%s line %d (%s): Error obtaining write lock: %s\n",
                filename, line, func, strerror(res));
        DO_THREAD_CRASH;
    }
#endif /* DEBUG_THREADS */
 
    return res;
}

References ast_bt_get_addresses, AST_MAX_REENTRANCY, AST_WRLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, name, NULL, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ao2_global_obj_replace(), __ao2_lock(), and __ast_heap_wrlock().

ast_atomic_dec_and_test()

int ast_atomic_dec_and_test ( volatile int *  p )

inline

decrement *p by 1 and return true if the variable has reached 0.

Useful e.g. to check if a refcount has reached 0.

Definition at line 774 of file lock.h.

Referenced by dispose_conf(), iax2_process_thread_cleanup(), run_station(), and sla_station_exec().

ast_atomic_fetchadd_int()

int ast_atomic_fetchadd_int ( volatile int *  p, int  v  )

inline

Atomically add v to *p and return the previous value of *p.

This can be used to handle reference counts, and the return value can be used to generate unique identifiers.

Definition at line 764 of file lock.h.

Referenced by __ao2_link(), __ao2_lock(), __ao2_ref(), __ao2_trylock(), __ao2_unlock(), __ast_channel_alloc_ap(), __ast_channel_internal_alloc_with_initializers(), __ast_module_ref(), __ast_module_unref(), __ast_module_user_add(), __ast_module_user_hangup_all(), __ast_module_user_remove(), __container_unlink_node_debug(), __manager_event_sessions_va(), acf_odbc_read(), action_login(), admin_exec(), advance_event(), ao2_container_count(), append_event(), ast_bridge_interval_hook(), ast_channel_destructor(), ast_channel_internal_setup_topics(), ast_cli_command_full(), ast_create_callid(), ast_odbc_execute_sql(), ast_odbc_prepare(), ast_odbc_prepare_and_execute(), ast_odbc_smart_execute(), ast_sip_schedule_task(), ast_taskprocessor_seq_num(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), ast_undestroyed_channels(), ast_unreal_new_channels(), authenticate_verify(), bridge_channel_handle_interval(), bridge_channel_queue_action_data_sync(), build_conf(), cc_device_monitor_init(), cc_extension_monitor_init(), cc_interfaces_datastore_init(), cdr_object_alloc(), chan_pjsip_new(), container_destruct(), dahdi_destroy(), dahdi_request(), dahdi_translate(), destroy_session(), dial_append_common(), dispatch_message(), dns_query_set_callback(), dundi_query_read(), efficiency_task(), efficiency_task(), enum_query_read(), fax_session_new(), fax_session_release(), fax_session_reserve(), find_idle_thread(), find_load_queue_rt_friendly(), find_session(), find_transcoders(), generate_msg_id(), generic_fax_exec(), grab_last(), hash_ao2_container_init(), hash_test_grow(), hash_test_grow(), hash_test_lookup(), hash_test_lookup(), hook_read(), ht_delete(), ht_new(), httpd_helper_thread(), iax2_destroy_helper(), iax2_process_thread(), iax_frame_free(), iax_frame_new(), inprocess_count(), internal_ao2_alloc(), internal_stasis_subscribe(), pjsip_history_entry_alloc(), publish_msg(), pubsub_on_rx_publish_request(), rb_ao2_container_init(), rec_request(), receivefax_exec(), reload_single_queue(), run_station(), sendfax_exec(), serializer_efficiency_task(), serializer_efficiency_task(), session_destructor(), session_do(), sip_create_publication(), sla_add_trunk_to_station(), sla_handle_hold_event(), sla_station_exec(), smdi_msg_retrieve_read(), spandsp_fax_switch_to_t38(), stasis_app_control_snoop(), stasis_caching_topic_create(), stasis_cp_all_create(), stasis_message_type_create(), transport_create(), try_merge_optimize_out(), try_swap_optimize_out(), update_stats(), and worker_thread_alloc().