lock.c File Reference

General Asterisk locking. More...

#include "asterisk.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"

Include dependency graph for lock.c:

Go to the source code of this file.

Macros
#define	log_mutex_error(canlog, ...)

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 line, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_timedrdlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout)
int	__ast_rwlock_timedwrlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout)
int	__ast_rwlock_tryrdlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_trywrlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_unlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
int	__ast_rwlock_wrlock (const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
static void	__dump_backtrace (struct ast_bt *bt, int canlog)
static struct ast_lock_track *	ast_get_reentrancy (struct ast_lock_track **plt, struct ast_lock_track_flags *flags, int no_setup)
static void	delete_reentrancy_cs (struct ast_lock_track **plt)
static void	restore_lock_tracking (struct ast_lock_track *lt, struct ast_lock_track *lt_saved)

Variables
static ast_mutex_t	reentrancy_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

Detailed Description

General Asterisk locking.

Definition in file lock.c.

Macro Definition Documentation

log_mutex_error

#define log_mutex_error	(		canlog,
			...
	)

Definition at line 57 of file lock.c.

Referenced by __ast_cond_timedwait(), __ast_cond_wait(), __ast_pthread_mutex_destroy(), __ast_pthread_mutex_init(), __ast_pthread_mutex_lock(), __ast_pthread_mutex_trylock(), __ast_pthread_mutex_unlock(), __ast_rwlock_destroy(), __ast_rwlock_init(), __ast_rwlock_rdlock(), __ast_rwlock_timedrdlock(), __ast_rwlock_timedwrlock(), __ast_rwlock_unlock(), __ast_rwlock_wrlock(), and __dump_backtrace().

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 504 of file lock.c.

References pthread_cond_broadcast.

{
 return pthread_cond_broadcast(cond);
}

__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 510 of file lock.c.

References pthread_cond_destroy.

{
 return pthread_cond_destroy(cond);
}

__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 492 of file lock.c.

References pthread_cond_init.

{
 return pthread_cond_init(cond, cond_attr);
}

__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 498 of file lock.c.

References pthread_cond_signal.

{
 return pthread_cond_signal(cond);
}

__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 604 of file lock.c.

References __dump_backtrace(), ast_get_reentrancy(), ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_restore_lock_info(), ast_suspend_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_cond_timedwait, pthread_mutex_t, ast_lock_track::reentrancy, restore_lock_tracking(), ROFFSET, ast_lock_track::thread_id, ast_mutex_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__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 539 of file lock.c.

References __dump_backtrace(), ast_get_reentrancy(), ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_restore_lock_info(), ast_suspend_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_cond_wait, pthread_mutex_t, ast_lock_track::reentrancy, restore_lock_tracking(), ROFFSET, ast_lock_track::thread_id, ast_mutex_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__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 175 of file lock.c.

References __dump_backtrace(), ast_get_reentrancy(), ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_lock_track::backtrace, delete_reentrancy_cs(), DO_THREAD_CRASH, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, pthread_mutex_destroy, pthread_mutex_t, pthread_mutex_trylock, pthread_mutex_unlock, ast_lock_track::reentrancy, ROFFSET, ast_lock_track::thread_id, ast_mutex_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__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 144 of file lock.c.

References AST_MUTEX_KIND, DO_THREAD_CRASH, ast_mutex_info::flags, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_mutex_init, pthread_mutex_t, ast_lock_track_flags::setup, ast_mutex_info::track, and ast_lock_track_flags::tracking.

{
 int res;
 pthread_mutexattr_t attr;

#ifdef DEBUG_THREADS
#if 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 */

 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;
}

__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 253 of file lock.c.

References __dump_backtrace(), ast_bt_get_addresses, ast_get_reentrancy(), ast_mark(), ast_mark_lock_acquired(), AST_MAX_REENTRANCY, AST_MUTEX, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_store_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_mutex_lock, pthread_mutex_trylock, ast_lock_track::reentrancy, ROFFSET, ast_lock_track::thread_id, tmp(), ast_mutex_info::track, and ast_lock_track_flags::tracking.

Referenced by __ao2_lock().

{
 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 */

#if defined(DETECT_DEADLOCKS) && defined(DEBUG_THREADS)
 {
 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);
 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);
 }
 reported_wait = wait_time;
 }
 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;
}

__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 366 of file lock.c.

References ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), ast_mark_lock_failed(), AST_MAX_REENTRANCY, AST_MUTEX, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_store_lock_info(), ast_lock_track::backtrace, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_mutex_trylock, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), ast_mutex_info::track, and ast_lock_track_flags::tracking.

Referenced by __ao2_trylock().

{
 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;
}

__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 421 of file lock.c.

References __dump_backtrace(), ast_get_reentrancy(), AST_MAX_REENTRANCY, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_mutex_info::flags, ast_lock_track::func, ast_lock_track::lineno, log_mutex_error, ast_mutex_info::mutex, NULL, pthread_mutex_t, pthread_mutex_unlock, ast_lock_track::reentrancy, ROFFSET, ast_lock_track::thread_id, ast_mutex_info::track, and ast_lock_track_flags::tracking.

Referenced by __ao2_unlock().

{
 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;
}

__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 701 of file lock.c.

References __AST_RWLOCK_INIT_VALUE, ast_get_reentrancy(), ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_lock_track::backtrace, delete_reentrancy_cs(), DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, ast_lock_track::reentrancy, ast_lock_track::thread_id, ast_rwlock_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__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 669 of file lock.c.

References __AST_RWLOCK_INIT_VALUE, DO_THREAD_CRASH, ast_rwlock_info::flags, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track_flags::setup, ast_rwlock_info::track, and ast_lock_track_flags::tracking.

{
 int res;
 pthread_rwlockattr_t attr;

#ifdef DEBUG_THREADS
#if 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 */

 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;
}

__ast_rwlock_rdlock()

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

Definition at line 819 of file lock.c.

References __dump_backtrace(), ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), AST_MAX_REENTRANCY, AST_RDLOCK, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_store_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), ast_rwlock_info::track, and ast_lock_track_flags::tracking.

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

{
 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_RDLOCK, filename, line, func, name, t, bt);
 }
#endif /* DEBUG_THREADS */

#if defined(DETECT_DEADLOCKS) && defined(DEBUG_THREADS)
 {
 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);
 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);
 }
 reported_wait = wait_time;
 }
 usleep(200);
 }
 } while (res == EBUSY);
 }
#else /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
 res = pthread_rwlock_rdlock(&t->lock);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */

#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;
}

__ast_rwlock_timedrdlock()

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

Definition at line 1014 of file lock.c.

References ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), AST_MAX_REENTRANCY, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_store_lock_info(), ast_tvnow(), AST_WRLOCK, ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), ast_rwlock_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__ast_rwlock_timedwrlock()

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

Definition at line 1096 of file lock.c.

References ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), AST_MAX_REENTRANCY, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_store_lock_info(), ast_tvnow(), AST_WRLOCK, ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), ast_rwlock_info::track, and ast_lock_track_flags::tracking.

{
 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;
}

__ast_rwlock_tryrdlock()

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

Definition at line 1178 of file lock.c.

References ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), ast_mark_lock_failed(), AST_MAX_REENTRANCY, AST_RDLOCK, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_store_lock_info(), ast_lock_track::backtrace, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), and ast_rwlock_info::track.

Referenced by __ao2_trylock().

{
 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;
}

__ast_rwlock_trywrlock()

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

Definition at line 1228 of file lock.c.

References ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), ast_mark_lock_failed(), AST_MAX_REENTRANCY, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_store_lock_info(), AST_WRLOCK, ast_lock_track::backtrace, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), and ast_rwlock_info::track.

Referenced by __ao2_trylock().

{
 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;
}

__ast_rwlock_unlock()

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

Definition at line 748 of file lock.c.

References __AST_RWLOCK_INIT_VALUE, ast_get_reentrancy(), AST_PTHREADT_NULL, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, ast_rwlock_info::track, and ast_lock_track_flags::tracking.

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

{
 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;
}

__ast_rwlock_wrlock()

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

Definition at line 917 of file lock.c.

References __dump_backtrace(), ast_bt_get_addresses, ast_get_reentrancy(), ast_mark_lock_acquired(), AST_MAX_REENTRANCY, ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_remove_lock_info(), ast_store_lock_info(), AST_WRLOCK, ast_lock_track::backtrace, DO_THREAD_CRASH, ast_lock_track::file, ast_rwlock_info::flags, ast_lock_track::func, ast_lock_track::lineno, ast_rwlock_info::lock, log_mutex_error, NULL, ast_lock_track::reentrancy, ast_lock_track::thread_id, tmp(), ast_rwlock_info::track, and ast_lock_track_flags::tracking.

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

{
 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 */

#if defined(DETECT_DEADLOCKS) && defined(DEBUG_THREADS)
 {
 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);
 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);
 }
 reported_wait = wait_time;
 }
 usleep(200);
 }
 } while (res == EBUSY);
 }
#else /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
 res = pthread_rwlock_wrlock(&t->lock);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */

#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;
}

__dump_backtrace()

static void __dump_backtrace ( struct ast_bt *  bt, int  canlog  )

static

Definition at line 68 of file lock.c.

References ast_bt::addresses, ast_std_free(), log_mutex_error, and ast_bt::num_frames.

Referenced by __ast_cond_timedwait(), __ast_cond_wait(), __ast_pthread_mutex_destroy(), __ast_pthread_mutex_lock(), __ast_pthread_mutex_unlock(), __ast_rwlock_rdlock(), and __ast_rwlock_wrlock().

{
 char **strings;
 ssize_t i;

 strings = backtrace_symbols(bt->addresses, bt->num_frames);

 for (i = 0; i < bt->num_frames; i++) {
 log_mutex_error(canlog, "%s\n", strings[i]);
 }

 ast_std_free(strings);
}

ast_get_reentrancy()

static struct ast_lock_track* ast_get_reentrancy ( struct ast_lock_track **  plt, struct ast_lock_track_flags *  flags, int  no_setup  )

static

Definition at line 86 of file lock.c.

References AST_MUTEX_KIND, ast_std_calloc(), ast_mutex_info::mutex, NULL, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock, ast_lock_track::reentr_mutex, reentrancy_lock, ast_lock_track_flags::setup, and ast_lock_track_flags::tracking.

Referenced by __ast_cond_timedwait(), __ast_cond_wait(), __ast_pthread_mutex_destroy(), __ast_pthread_mutex_lock(), __ast_pthread_mutex_trylock(), __ast_pthread_mutex_unlock(), __ast_rwlock_destroy(), __ast_rwlock_rdlock(), __ast_rwlock_timedrdlock(), __ast_rwlock_timedwrlock(), __ast_rwlock_tryrdlock(), __ast_rwlock_trywrlock(), __ast_rwlock_unlock(), and __ast_rwlock_wrlock().

{
 pthread_mutexattr_t reentr_attr;
 struct ast_lock_track *lt;

 if (!flags->tracking || flags->setup) {
 return *plt;
 }

 pthread_mutex_lock(&reentrancy_lock.mutex);

 if (*plt) {
 pthread_mutex_unlock(&reentrancy_lock.mutex);
 return *plt;
 }

 if (no_setup) {
 pthread_mutex_unlock(&reentrancy_lock.mutex);
 return NULL;
 }

 lt = *plt = ast_std_calloc(1, sizeof(*lt));
 if (!lt) {
 fprintf(stderr, "%s: Failed to allocate lock tracking\n", __func__);
#if defined(DO_CRASH) || defined(THREAD_CRASH)
 abort();
#else
 pthread_mutex_unlock(&reentrancy_lock.mutex);
 return NULL;
#endif
 }

 pthread_mutexattr_init(&reentr_attr);
 pthread_mutexattr_settype(&reentr_attr, AST_MUTEX_KIND);
 pthread_mutex_init(&lt->reentr_mutex, &reentr_attr);
 pthread_mutexattr_destroy(&reentr_attr);

 flags->setup = 1;
 pthread_mutex_unlock(&reentrancy_lock.mutex);
 return lt;
}

delete_reentrancy_cs()

static void delete_reentrancy_cs ( struct ast_lock_track **  plt )

inlinestatic

Definition at line 129 of file lock.c.

References ast_std_free(), NULL, pthread_mutex_destroy, and ast_lock_track::reentr_mutex.

Referenced by __ast_pthread_mutex_destroy(), and __ast_rwlock_destroy().

{
 struct ast_lock_track *lt;

 if (*plt) {
 lt = *plt;
 *plt = NULL;

 pthread_mutex_destroy(&lt->reentr_mutex);
 ast_std_free(lt);
 }
}

restore_lock_tracking()

static void restore_lock_tracking ( struct ast_lock_track *  lt, struct ast_lock_track *  lt_saved  )

static

Definition at line 517 of file lock.c.

References ast_reentrancy_lock(), ast_reentrancy_unlock(), ast_lock_track::backtrace, ast_lock_track::file, ast_lock_track::func, ast_lock_track::lineno, ast_lock_track::reentrancy, and ast_lock_track::thread_id.

Referenced by __ast_cond_timedwait(), and __ast_cond_wait().

{
 ast_reentrancy_lock(lt);

 /*
 * The following code must match the struct ast_lock_track
 * definition with the explicit exception of the reentr_mutex
 * member.
 */
 memcpy(lt->file, lt_saved->file, sizeof(lt->file));
 memcpy(lt->lineno, lt_saved->lineno, sizeof(lt->lineno));
 lt->reentrancy = lt_saved->reentrancy;
 memcpy(lt->func, lt_saved->func, sizeof(lt->func));
 memcpy(lt->thread_id, lt_saved->thread_id, sizeof(lt->thread_id));
#ifdef HAVE_BKTR
 memcpy(lt->backtrace, lt_saved->backtrace, sizeof(lt->backtrace));
#endif

 ast_reentrancy_unlock(lt);
}

Variable Documentation

reentrancy_lock

ast_mutex_t reentrancy_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 84 of file lock.c.

Referenced by ast_get_reentrancy().