int __ast_rwlock_trywrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt = NULL; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif if (t->tracking) { lt = ast_get_reentrancy(&t->track); } 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 = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #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[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; }
struct ast_bt *__ast_bt_create(void) { struct ast_bt *bt = ast_std_calloc(1, sizeof(*bt)); if (!bt) { return NULL; } bt->alloced = 1; ast_bt_get_addresses(bt); return bt; }
int __ast_rwlock_wrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt; int canlog = strcmp(filename, "logger.c") & t->tracking; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE) if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) { /* Don't warn abount uninitialized lock. * Simple try to initialize it. * May be not needed in linux system. */ res = __ast_rwlock_init(t->tracking, filename, line, func, name, t); if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) { __ast_mutex_logger("%s line %d (%s): Error: rwlock '%s' is uninitialized and unable to initialize.\n", filename, line, func, name); return res; } } #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */ if (t->tracking && !t->track) { ast_reentrancy_init(&t->track); } lt = t->track; if (t->tracking) { #ifdef HAVE_BKTR ast_reentrancy_lock(lt); if (lt->reentrancy != AST_MAX_REENTRANCY) { ast_bt_get_addresses(<->backtrace[lt->reentrancy]); bt = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #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) { __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for writelock '%s'?\n", filename, line, func, (int)wait_time, name); if (t->tracking) { ast_reentrancy_lock(lt); #ifdef HAVE_BKTR __dump_backtrace(<->backtrace[lt->reentrancy], canlog); #endif __ast_mutex_logger("%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(<->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 && t->tracking) { 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[lt->reentrancy] = pthread_self(); lt->reentrancy++; } ast_reentrancy_unlock(lt); if (t->tracking) { ast_mark_lock_acquired(t); } } else if (t->tracking) { #ifdef HAVE_BKTR if (lt->reentrancy) { ast_reentrancy_lock(lt); bt = <->backtrace[lt->reentrancy-1]; ast_reentrancy_unlock(lt); } else { bt = NULL; } if (t->tracking) { ast_remove_lock_info(t, bt); } #else if (t->tracking) { ast_remove_lock_info(t); } #endif } if (res) { __ast_mutex_logger("%s line %d (%s): Error obtaining write lock: %s\n", filename, line, func, strerror(res)); DO_THREAD_CRASH; } #endif /* DEBUG_THREADS */ return res; }
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 res; #ifdef DEBUG_THREADS struct ast_lock_track *lt; int canlog = strcmp(filename, "logger.c") & t->tracking; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE) if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) { __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n", filename, lineno, func, mutex_name); res = __ast_pthread_mutex_init(t->tracking, filename, lineno, func, mutex_name, t); if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) { __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized and unable to initialize.\n", filename, lineno, func, mutex_name); } return res; } #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */ if (t->tracking && !t->track) { ast_reentrancy_init(&t->track); } lt = t->track; if (t->tracking) { ast_reentrancy_lock(lt); if (lt->reentrancy && (lt->thread[ROFFSET] != pthread_self())) { __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n", filename, lineno, func, mutex_name); __ast_mutex_logger("%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(<->backtrace[ROFFSET], canlog); #endif DO_THREAD_CRASH; } if (--lt->reentrancy < 0) { __ast_mutex_logger("%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[lt->reentrancy] = 0; } #ifdef HAVE_BKTR if (lt->reentrancy) { bt = <->backtrace[lt->reentrancy - 1]; } #endif ast_reentrancy_unlock(lt); #ifdef HAVE_BKTR ast_remove_lock_info(t, bt); #else ast_remove_lock_info(t); #endif } #endif /* DEBUG_THREADS */ res = pthread_cond_timedwait(cond, &t->mutex, abstime); #ifdef DEBUG_THREADS if (res && (res != ETIMEDOUT)) { __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", filename, lineno, func, strerror(res)); DO_THREAD_CRASH; } else if (t->tracking) { 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[lt->reentrancy] = pthread_self(); #ifdef HAVE_BKTR ast_bt_get_addresses(<->backtrace[lt->reentrancy]); bt = <->backtrace[lt->reentrancy]; #endif lt->reentrancy++; } else { __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n", filename, lineno, func, mutex_name); } ast_reentrancy_unlock(lt); #ifdef HAVE_BKTR ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt); #else ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t); #endif } #endif /* DEBUG_THREADS */ return res; }
int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func, const char* mutex_name, ast_mutex_t *t) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt; int canlog = strcmp(filename, "logger.c") & t->tracking; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif #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 warn abount uninitialized mutex. * Simple try to initialize it. * May be not needed in linux system. */ res = __ast_pthread_mutex_init(t->tracking, filename, lineno, func, mutex_name, t); if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) { __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized and unable to initialize.\n", filename, lineno, func, mutex_name); return res; } } #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */ if (t->tracking && !t->track) { ast_reentrancy_init(&t->track); } lt = t->track; if (t->tracking) { #ifdef HAVE_BKTR ast_reentrancy_lock(lt); if (lt->reentrancy != AST_MAX_REENTRANCY) { ast_bt_get_addresses(<->backtrace[lt->reentrancy]); bt = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt); #else ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t); #endif } #endif /* DEBUG_THREADS */ res = pthread_mutex_trylock(&t->mutex); #ifdef DEBUG_THREADS if (t->tracking && !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[lt->reentrancy] = pthread_self(); lt->reentrancy++; } else { __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n", filename, lineno, func, mutex_name); } ast_reentrancy_unlock(lt); if (t->tracking) { ast_mark_lock_acquired(t); } } else if (t->tracking) { ast_mark_lock_failed(t); } #endif /* DEBUG_THREADS */ return res; }
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 res; #ifdef DEBUG_THREADS struct ast_lock_track *lt; int canlog = strcmp(filename, "logger.c") & t->tracking; #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE) if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) { /* Don't warn abount uninitialized lock. * Simple try to initialize it. * May be not needed in linux system. */ res = __ast_rwlock_init(t->tracking, filename, line, func, name, t); if ((t->lock) == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) { __ast_mutex_logger("%s line %d (%s): Error: rwlock '%s' is uninitialized and unable to initialize.\n", filename, line, func, name); return res; } } #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */ if (t->tracking && !t->track) { ast_reentrancy_init(&t->track); } lt = t->track; if (t->tracking) { #ifdef HAVE_BKTR ast_reentrancy_lock(lt); if (lt->reentrancy != AST_MAX_REENTRANCY) { ast_bt_get_addresses(<->backtrace[lt->reentrancy]); bt = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #endif /* DEBUG_THREADS */ #ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK res = pthread_rwlock_timedwrlock(&t->lock, abs_timeout); #else do { struct timeval _start = ast_tvnow(), _diff; for (;;) { if (!(res = pthread_rwlock_trywrlock(&t->lock))) { break; } _diff = ast_tvsub(ast_tvnow(), _start); if (_diff.tv_sec > abs_timeout->tv_sec || (_diff.tv_sec == abs_timeout->tv_sec && _diff.tv_usec * 1000 > abs_timeout->tv_nsec)) { break; } usleep(1); } } while (0); #endif #ifdef DEBUG_THREADS if (!res && t->tracking) { 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[lt->reentrancy] = pthread_self(); lt->reentrancy++; } ast_reentrancy_unlock(lt); if (t->tracking) { ast_mark_lock_acquired(t); } } else if (t->tracking) { #ifdef HAVE_BKTR if (lt->reentrancy) { ast_reentrancy_lock(lt); bt = <->backtrace[lt->reentrancy-1]; ast_reentrancy_unlock(lt); } else { bt = NULL; } if (t->tracking) { ast_remove_lock_info(t, bt); } #else if (t->tracking) { ast_remove_lock_info(t); } #endif } if (res) { __ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n", filename, line, func, strerror(res)); DO_THREAD_CRASH; } #endif /* DEBUG_THREADS */ return res; }
int __ast_rwlock_wrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt = NULL; int canlog = t->tracking && strcmp(filename, "logger.c"); #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif if (t->tracking) { lt = ast_get_reentrancy(&t->track); } 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 = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #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) { __ast_mutex_logger("%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(<->backtrace[lt->reentrancy], canlog); #endif __ast_mutex_logger("%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(<->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[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 = <->backtrace[lt->reentrancy-1]; ast_reentrancy_unlock(lt); } else { bt = NULL; } ast_remove_lock_info(t, bt); #else ast_remove_lock_info(t); #endif } if (res) { __ast_mutex_logger("%s line %d (%s): Error obtaining write lock: %s\n", filename, line, func, strerror(res)); DO_THREAD_CRASH; } #endif /* DEBUG_THREADS */ return res; }
int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func, const char* mutex_name, ast_mutex_t *t) { int res; #ifdef DEBUG_THREADS struct ast_lock_track *lt = NULL; int canlog = t->tracking && strcmp(filename, "logger.c"); #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif if (t->tracking) { lt = ast_get_reentrancy(&t->track); } 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 = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt); #else ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t); #endif } #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[lt->reentrancy] = pthread_self(); lt->reentrancy++; } else { __ast_mutex_logger("%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; }
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 res; #ifdef DEBUG_THREADS struct ast_lock_track *lt = NULL; int canlog = t->tracking && strcmp(filename, "logger.c"); #ifdef HAVE_BKTR struct ast_bt *bt = NULL; #endif if (t->tracking) { lt = ast_get_reentrancy(&t->track); } 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 = <->backtrace[lt->reentrancy]; } ast_reentrancy_unlock(lt); ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t, bt); #else ast_store_lock_info(AST_WRLOCK, filename, line, func, name, t); #endif } #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[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 = <->backtrace[lt->reentrancy-1]; ast_reentrancy_unlock(lt); } else { bt = NULL; } ast_remove_lock_info(t, bt); #else ast_remove_lock_info(t); #endif } if (res) { __ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n", filename, line, func, strerror(res)); DO_THREAD_CRASH; } #endif /* DEBUG_THREADS */ return res; }