lock.c File Reference

General Asterisk locking. More...

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

Include dependency graph for lock.c:

Go to the source code of this file.

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)

Detailed Description

General Asterisk locking.

Definition in file lock.c.

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	line,
		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	line,
		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	line,
		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	line,
		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	line,
		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	line,
		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	line,
		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().