Remove ABI differences that occured when compiling with DEBUG_THREADS.
authorJason Parker <jparker@digium.com>
Thu, 22 Apr 2010 19:08:01 +0000 (19:08 +0000)
committerJason Parker <jparker@digium.com>
Thu, 22 Apr 2010 19:08:01 +0000 (19:08 +0000)
"Bad Things" would happen if Asterisk was compiled with DEBUG_THREADS, but a
loaded module was not (or vice versa).  This also immensely simplifies the
lock code, since there are no longer 2 separate versions of them.

Review: https://reviewboard.asterisk.org/r/508/

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@258557 65c4cc65-6c06-0410-ace0-fbb531ad65f3

include/asterisk/astobj2.h
include/asterisk/heap.h
include/asterisk/lock.h
include/asterisk/res_odbc.h
main/astobj2.c
main/heap.c
main/lock.c [new file with mode: 0644]
res/res_odbc.c

index 1727978..323acb4 100644 (file)
@@ -472,12 +472,8 @@ int __ao2_ref(void *o, int delta);
  * \param a A pointer to the object we want to lock.
  * \return 0 on success, other values on error.
  */
-#ifndef DEBUG_THREADS
-int ao2_lock(void *a);
-#else
-#define ao2_lock(a) __ao2_lock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 int __ao2_lock(void *a, const char *file, const char *func, int line, const char *var);
-#endif
+#define ao2_lock(a) __ao2_lock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 
 /*! \brief
  * Unlock an object.
@@ -485,12 +481,8 @@ int __ao2_lock(void *a, const char *file, const char *func, int line, const char
  * \param a A pointer to the object we want unlock.
  * \return 0 on success, other values on error.
  */
-#ifndef DEBUG_THREADS
-int ao2_unlock(void *a);
-#else
-#define ao2_unlock(a) __ao2_unlock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 int __ao2_unlock(void *a, const char *file, const char *func, int line, const char *var);
-#endif
+#define ao2_unlock(a) __ao2_unlock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 
 /*! \brief
  * Try locking-- (don't block if fail)
@@ -498,12 +490,8 @@ int __ao2_unlock(void *a, const char *file, const char *func, int line, const ch
  * \param a A pointer to the object we want to lock.
  * \return 0 on success, other values on error.
  */
-#ifndef DEBUG_THREADS
-int ao2_trylock(void *a);
-#else
-#define ao2_trylock(a) __ao2_trylock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 int __ao2_trylock(void *a, const char *file, const char *func, int line, const char *var);
-#endif
+#define ao2_trylock(a) __ao2_trylock(a, __FILE__, __PRETTY_FUNCTION__, __LINE__, #a)
 
 /*!
  * \brief Return the lock address of an object
index 6bf97b4..86f4e3d 100644 (file)
@@ -209,8 +209,6 @@ void *ast_heap_peek(struct ast_heap *h, unsigned int index);
  */
 size_t ast_heap_size(struct ast_heap *h);
 
-#ifndef DEBUG_THREADS
-
 /*!
  * \brief Write-Lock a heap
  *
@@ -223,7 +221,7 @@ size_t ast_heap_size(struct ast_heap *h);
  * \return see the documentation for pthread_rwlock_wrlock()
  * \since 1.6.1
  */
-int ast_heap_wrlock(struct ast_heap *h);
+int __ast_heap_wrlock(struct ast_heap *h, const char *file, const char *func, int line);
 
 /*!
  * \brief Read-Lock a heap
@@ -237,7 +235,7 @@ int ast_heap_wrlock(struct ast_heap *h);
  * \return see the documentation for pthread_rwlock_rdlock()
  * \since 1.6.1
  */
-int ast_heap_rdlock(struct ast_heap *h);
+int __ast_heap_rdlock(struct ast_heap *h, const char *file, const char *func, int line);
 
 /*!
  * \brief Unlock a heap
@@ -247,18 +245,11 @@ int ast_heap_rdlock(struct ast_heap *h);
  * \return see the documentation for pthread_rwlock_unlock()
  * \since 1.6.1
  */
-int ast_heap_unlock(struct ast_heap *h);
-
-#else /* DEBUG_THREADS */
+int __ast_heap_unlock(struct ast_heap *h, const char *file, const char *func, int line);
 
 #define ast_heap_wrlock(h) __ast_heap_wrlock(h, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-int __ast_heap_wrlock(struct ast_heap *h, const char *file, const char *func, int line);
 #define ast_heap_rdlock(h) __ast_heap_rdlock(h, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-int __ast_heap_rdlock(struct ast_heap *h, const char *file, const char *func, int line);
 #define ast_heap_unlock(h) __ast_heap_unlock(h, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-int __ast_heap_unlock(struct ast_heap *h, const char *file, const char *func, int line);
-
-#endif /* DEBUG_THREADS */
 
 /*!
  * \brief Verify that a heap has been properly constructed
index ea0be94..5c42d1e 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 1999 - 2006, Digium, Inc.
+ * Copyright (C) 1999 - 2010, Digium, Inc.
  *
  * Mark Spencer <markster@digium.com>
  *
 
 #include "asterisk/logger.h"
 
-/* internal macro to profile mutexes. Only computes the delay on
- * non-blocking calls.
- */
-#ifndef        HAVE_MTX_PROFILE
-#define        __MTX_PROF(a)   return pthread_mutex_lock((a))
-#else
-#define        __MTX_PROF(a)   do {                    \
-       int i;                                  \
-       /* profile only non-blocking events */  \
-       ast_mark(mtx_prof, 1);                  \
-       i = pthread_mutex_trylock((a));         \
-       ast_mark(mtx_prof, 0);                  \
-       if (!i)                                 \
-               return i;                       \
-       else                                    \
-               return pthread_mutex_lock((a)); \
-       } while (0)
-#endif /* HAVE_MTX_PROFILE */
-
 #define AST_PTHREADT_NULL (pthread_t) -1
 #define AST_PTHREADT_STOP (pthread_t) -2
 
 #define AST_MUTEX_KIND                 PTHREAD_MUTEX_RECURSIVE
 #endif /* PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP */
 
-/*
- * Definition of ast_mutex_t, ast_cont_d and related functions with/without debugging
- * (search for DEBUG_THREADS to find the start/end of the sections).
- *
- * The non-debug code contains just wrappers for the corresponding pthread functions.
- * The debug code tracks usage and tries to identify deadlock situations.
- */
-#ifdef DEBUG_THREADS
-
-#define __ast_mutex_logger(...)  do { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); } while (0)
-
-#ifdef THREAD_CRASH
-#define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
-#else
-#define DO_THREAD_CRASH do { } while (0)
-#endif
-
-#include <errno.h>
+#ifdef HAVE_PTHREAD_RWLOCK_INITIALIZER
+#define __AST_RWLOCK_INIT_VALUE                PTHREAD_RWLOCK_INITIALIZER
+#else  /* HAVE_PTHREAD_RWLOCK_INITIALIZER */
+#define __AST_RWLOCK_INIT_VALUE                {0}
+#endif /* HAVE_PTHREAD_RWLOCK_INITIALIZER */
 
 #ifdef HAVE_BKTR
 #define AST_LOCK_TRACK_INIT_VALUE { { NULL }, { 0 }, 0, { NULL }, { 0 }, {{{ 0 }}}, PTHREAD_MUTEX_INIT_VALUE }
-
 #else
 #define AST_LOCK_TRACK_INIT_VALUE { { NULL }, { 0 }, 0, { NULL }, { 0 }, PTHREAD_MUTEX_INIT_VALUE }
 #endif
 #define AST_MUTEX_INIT_VALUE { AST_LOCK_TRACK_INIT_VALUE, 1, PTHREAD_MUTEX_INIT_VALUE }
 #define AST_MUTEX_INIT_VALUE_NOTRACKING { AST_LOCK_TRACK_INIT_VALUE, 0, PTHREAD_MUTEX_INIT_VALUE }
 
+#define AST_RWLOCK_INIT_VALUE { AST_LOCK_TRACK_INIT_VALUE, 1, __AST_RWLOCK_INIT_VALUE }
+#define AST_RWLOCK_INIT_VALUE_NOTRACKING { AST_LOCK_TRACK_INIT_VALUE, 0, __AST_RWLOCK_INIT_VALUE }
+
 #define AST_MAX_REENTRANCY 10
 
 struct ast_channel;
@@ -142,6 +112,11 @@ struct ast_lock_track {
        pthread_mutex_t reentr_mutex;
 };
 
+/*! \brief Structure for mutex and tracking information.
+ *
+ * We have tracking information in this structure regardless of DEBUG_THREADS being enabled.
+ * The information will just be ignored in the core if a module does not request it..
+ */
 struct ast_mutex_info {
        /*! Track which thread holds this mutex */
        struct ast_lock_track track;
@@ -149,10 +124,100 @@ struct ast_mutex_info {
        pthread_mutex_t mutex;
 };
 
+/*! \brief Structure for rwlock and tracking information.
+ *
+ * We have tracking information in this structure regardless of DEBUG_THREADS being enabled.
+ * The information will just be ignored in the core if a module does not request it..
+ */
+struct ast_rwlock_info {
+       /*! Track which thread holds this lock */
+       struct ast_lock_track track;
+       unsigned int tracking:1;
+       pthread_rwlock_t lock;
+};
+
 typedef struct ast_mutex_info ast_mutex_t;
 
+typedef struct ast_rwlock_info ast_rwlock_t;
+
 typedef pthread_cond_t ast_cond_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_destroy(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);
+
+#define ast_mutex_init(pmutex)            __ast_pthread_mutex_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
+#define ast_mutex_init_notracking(pmutex) __ast_pthread_mutex_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
+#define ast_mutex_destroy(a)              __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
+#define ast_mutex_lock(a)                 __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
+#define ast_mutex_unlock(a)               __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
+#define ast_mutex_trylock(a)              __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
+
+
+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_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_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_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);
+
+#define ast_cond_init(cond, attr)             __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
+#define ast_cond_destroy(cond)                __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
+#define ast_cond_signal(cond)                 __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
+#define ast_cond_broadcast(cond)              __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
+#define ast_cond_wait(cond, mutex)            __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
+#define ast_cond_timedwait(cond, mutex, time) __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
+
+
+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_destroy(const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t);
+int __ast_rwlock_unlock(ast_rwlock_t *t, const char *name, const char *filename, int line, const char *func);
+int __ast_rwlock_rdlock(ast_rwlock_t *t, const char *name, const char *filename, int line, const char *func);
+int __ast_rwlock_wrlock(ast_rwlock_t *t, const char *name, const char *filename, int line, const char *func);
+int __ast_rwlock_timedrdlock(ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout, const char *filename, int line, const char *func);
+int __ast_rwlock_timedwrlock(ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout, const char *filename, int line, const char *func);
+int __ast_rwlock_tryrdlock(ast_rwlock_t *t, const char *name, const char *filename, int line, const char *func);
+int __ast_rwlock_trywrlock(ast_rwlock_t *t, const char *name, const char *filename, int line, const char *func);
+
+/*!
+ * \brief wrapper for rwlock with tracking enabled
+ * \return 0 on success, non zero for error
+ * \since 1.6.1
+ */
+#define ast_rwlock_init(rwlock)            __ast_rwlock_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
+
+/*!
+ * \brief wrapper for ast_rwlock_init with tracking disabled
+ * \return 0 on success, non zero for error
+ * \since 1.6.1
+ */
+#define ast_rwlock_init_notracking(rwlock) __ast_rwlock_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
+
+#define ast_rwlock_destroy(rwlock)         __ast_rwlock_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
+#define ast_rwlock_unlock(a)               __ast_rwlock_unlock(a, #a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_rdlock(a)               __ast_rwlock_rdlock(a, #a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_wrlock(a)               __ast_rwlock_wrlock(a, #a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_tryrdlock(a)            __ast_rwlock_tryrdlock(a, #a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_trywrlock(a)            __ast_rwlock_trywrlock(a, #a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_timedrdlock(a, b)       __ast_rwlock_timedrdlock(a, #a, b, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#define ast_rwlock_timedwrlock(a, b)       __ast_rwlock_timedwrlock(a, #a, b, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+
+#define        ROFFSET ((lt->reentrancy > 0) ? (lt->reentrancy-1) : 0)
+
+#ifdef DEBUG_THREADS
+
+#define __ast_mutex_logger(...)  do { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); } while (0)
+
+#ifdef THREAD_CRASH
+#define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
+#else
+#define DO_THREAD_CRASH do { } while (0)
+#endif
+
+#include <errno.h>
+
 enum ast_lock_type {
        AST_MUTEX,
        AST_RDLOCK,
@@ -374,1562 +439,97 @@ static inline void delete_reentrancy_cs(struct ast_lock_track *lt)
        pthread_mutex_destroy(&lt->reentr_mutex);
 }
 
-static inline int __ast_pthread_mutex_init(int tracking, const char *filename, int lineno, const char *func,
-                                               const char *mutex_name, ast_mutex_t *t)
-{
-       int res;
-       pthread_mutexattr_t  attr;
-
-#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 = strcmp(filename, "logger.c") & track;
-               __ast_mutex_logger("%s line %d (%s): NOTICE: mutex '%s' is already initialized.\n",
-                                  filename, lineno, func, mutex_name);
-               DO_THREAD_CRASH;
-*/
-               return 0;
-       }
-
-#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
-
-       ast_reentrancy_init(&t->track);
-       t->tracking = tracking;
-
-       pthread_mutexattr_init(&attr);
-       pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
-
-       res = pthread_mutex_init(&t->mutex, &attr);
-       pthread_mutexattr_destroy(&attr);
-       return res;
-}
-
-#define ast_mutex_init(pmutex) __ast_pthread_mutex_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
-#define ast_mutex_init_notracking(pmutex) \
-       __ast_pthread_mutex_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
-
-#define        ROFFSET ((lt->reentrancy > 0) ? (lt->reentrancy-1) : 0)
-static inline int __ast_pthread_mutex_destroy(const char *filename, int lineno, const char *func,
-                                               const char *mutex_name, ast_mutex_t *t)
-{
-       int res;
-       struct ast_lock_track *lt;
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-
-#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 non initialized mutex
-                * This may no effect on linux
-                * And always ganerate core on *BSD with
-                * linked libpthread
-                * This not error condition if the mutex created on the fly.
-                */
-               __ast_mutex_logger("%s line %d (%s): NOTICE: mutex '%s' is uninitialized.\n",
-                                  filename, lineno, func, mutex_name);
-               return 0;
-       }
-#endif
-
-       lt = &t->track;
-
-       res = pthread_mutex_trylock(&t->mutex);
-       switch (res) {
-       case 0:
-               pthread_mutex_unlock(&t->mutex);
-               break;
-       case EINVAL:
-               __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
-                                 filename, lineno, func, mutex_name);
-               break;
-       case EBUSY:
-               __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
-                                  filename, lineno, func, mutex_name);
-               ast_reentrancy_lock(lt);
-               __ast_mutex_logger("%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;
-       }
-
-
-       if ((res = pthread_mutex_destroy(&t->mutex))) {
-               __ast_mutex_logger("%s line %d (%s): Error destroying mutex %s: %s\n",
-                                  filename, lineno, func, mutex_name, strerror(res));
-       }
-       ast_reentrancy_lock(lt);
-       lt->file[0] = filename;
-       lt->lineno[0] = lineno;
-       lt->func[0] = func;
-       lt->reentrancy = 0;
-       lt->thread[0] = 0;
-#ifdef HAVE_BKTR
-       memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
-#endif
-       ast_reentrancy_unlock(lt);
-       delete_reentrancy_cs(lt);
+#else /* !DEBUG_THREADS */
 
-       return res;
-}
+#define        CHANNEL_DEADLOCK_AVOIDANCE(chan) \
+       ast_channel_unlock(chan); \
+       usleep(1); \
+       ast_channel_lock(chan);
 
-static inline int __ast_pthread_mutex_lock(const char *filename, int lineno, const char *func,
-                                           const char* mutex_name, ast_mutex_t *t)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-#ifdef HAVE_BKTR
-       struct ast_bt *bt = NULL;
-#endif
+#define        DEADLOCK_AVOIDANCE(lock) \
+       ast_mutex_unlock(lock); \
+       usleep(1); \
+       ast_mutex_lock(lock);
 
-#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 */
+#define DLA_UNLOCK(lock) ast_mutex_unlock(lock)
 
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
+#define DLA_LOCK(lock) ast_mutex_lock(lock)
 
-#ifdef 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) {
-                                       __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
-                                                          filename, lineno, func, (int) wait_time, mutex_name);
-                                       ast_reentrancy_lock(lt);
-#ifdef HAVE_BKTR
-                                       __dump_backtrace(&lt->backtrace[lt->reentrancy], canlog);
-#endif
-                                       __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(&lt->backtrace[ROFFSET], canlog);
-#endif
-                                       ast_reentrancy_unlock(lt);
-                                       reported_wait = wait_time;
-                               }
-                               usleep(200);
-                       }
-               } while (res == EBUSY);
-       }
-#else
-#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 */
-
-       if (!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 {
-#ifdef HAVE_BKTR
-               if (lt->reentrancy) {
-                       ast_reentrancy_lock(lt);
-                       bt = &lt->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
-               __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
-                                  filename, lineno, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
+#endif /* !DEBUG_THREADS */
 
-       return res;
+#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
+/*
+ * If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope constructors
+ * and destructors to create/destroy global mutexes.
+ */
+#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track)      \
+       scope ast_mutex_t mutex = init_val;                     \
+static void  __attribute__((constructor)) init_##mutex(void)   \
+{                                                              \
+       if (track)                                              \
+               ast_mutex_init(&mutex);                         \
+       else                                                    \
+               ast_mutex_init_notracking(&mutex);              \
+}                                                              \
+                                                               \
+static void  __attribute__((destructor)) fini_##mutex(void)    \
+{                                                              \
+       ast_mutex_destroy(&mutex);                              \
 }
-
-static inline int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func,
-                                              const char* mutex_name, ast_mutex_t *t)
-{
-       int res;
-       struct ast_lock_track *lt= &t->track;
-       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;
-               }
-       }
+#else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
+/* By default, use static initialization of mutexes. */
+#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track) scope ast_mutex_t mutex = init_val
 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
+#define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE, 1)
+#define AST_MUTEX_DEFINE_STATIC_NOTRACKING(mutex) __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE_NOTRACKING, 0)
 
-       if (!(res = pthread_mutex_trylock(&t->mutex))) {
-               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);
-       }
 
-       return res;
+/* Statically declared read/write locks */
+#ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
+#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) \
+        scope ast_rwlock_t rwlock = init_val; \
+static void  __attribute__((constructor)) init_##rwlock(void) \
+{ \
+       if (track) \
+               ast_rwlock_init(&rwlock); \
+       else \
+               ast_rwlock_init_notracking(&rwlock); \
+} \
+static void  __attribute__((destructor)) fini_##rwlock(void) \
+{ \
+        ast_rwlock_destroy(&rwlock); \
 }
-
-static inline int __ast_pthread_mutex_unlock(const char *filename, int lineno, const char *func,
-                                            const char *mutex_name, ast_mutex_t *t)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       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 */
-
-       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(&lt->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 = &lt->backtrace[lt->reentrancy - 1];
-       }
-#endif
-       ast_reentrancy_unlock(lt);
-
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_remove_lock_info(t, bt);
 #else
-               ast_remove_lock_info(t);
-#endif
-       }
-
-       if ((res = pthread_mutex_unlock(&t->mutex))) {
-               __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n",
-                                  filename, lineno, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-
-       return res;
-}
-
-static inline 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)
-{
-       return pthread_cond_init(cond, cond_attr);
-}
-
-static inline int __ast_cond_signal(const char *filename, int lineno, const char *func,
-                                   const char *cond_name, ast_cond_t *cond)
-{
-       return pthread_cond_signal(cond);
-}
-
-static inline int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
-                                      const char *cond_name, ast_cond_t *cond)
-{
-       return pthread_cond_broadcast(cond);
-}
-
-static inline int __ast_cond_destroy(const char *filename, int lineno, const char *func,
-                                    const char *cond_name, ast_cond_t *cond)
-{
-       return pthread_cond_destroy(cond);
-}
-
-static inline 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 res;
-       struct ast_lock_track *lt= &t->track;
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-#ifdef HAVE_BKTR
-       struct ast_bt *bt = NULL;
+#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) scope ast_rwlock_t rwlock = init_val
 #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 */
+#define AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE, 1)
+#define AST_RWLOCK_DEFINE_STATIC_NOTRACKING(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE_NOTRACKING, 0)
 
-       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(&lt->backtrace[ROFFSET], canlog);
+#ifndef __CYGWIN__     /* temporary disabled for cygwin */
+#define pthread_mutex_t                use_ast_mutex_t_instead_of_pthread_mutex_t
+#define pthread_cond_t         use_ast_cond_t_instead_of_pthread_cond_t
 #endif
-               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;
-       }
+#define pthread_mutex_lock     use_ast_mutex_lock_instead_of_pthread_mutex_lock
+#define pthread_mutex_unlock   use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
+#define pthread_mutex_trylock  use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
+#define pthread_mutex_init     use_ast_mutex_init_instead_of_pthread_mutex_init
+#define pthread_mutex_destroy  use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
+#define pthread_cond_init      use_ast_cond_init_instead_of_pthread_cond_init
+#define pthread_cond_destroy   use_ast_cond_destroy_instead_of_pthread_cond_destroy
+#define pthread_cond_signal    use_ast_cond_signal_instead_of_pthread_cond_signal
+#define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
+#define pthread_cond_wait      use_ast_cond_wait_instead_of_pthread_cond_wait
+#define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
 
-#ifdef HAVE_BKTR
-       if (lt->reentrancy) {
-               bt = &lt->backtrace[lt->reentrancy - 1];
-       }
-#endif
-       ast_reentrancy_unlock(lt);
+#define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
 
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_remove_lock_info(t, bt);
-#else
-               ast_remove_lock_info(t);
-#endif
-       }
+#define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
 
-       if ((res = pthread_cond_wait(cond, &t->mutex))) {
-               __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
-                                  filename, lineno, func, strerror(res));
-               DO_THREAD_CRASH;
-       } else {
-               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(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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);
-
-               if (t->tracking) {
-#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);
+#ifndef __linux__
+#define pthread_create __use_ast_pthread_create_instead__
 #endif
-               }
-       }
-
-       return res;
-}
-
-static inline 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;
-       struct ast_lock_track *lt = &t->track;
-       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 */
-
-       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(&lt->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 = &lt->backtrace[lt->reentrancy - 1];
-       }
-#endif
-       ast_reentrancy_unlock(lt);
-
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_remove_lock_info(t, bt);
-#else
-               ast_remove_lock_info(t);
-#endif
-       }
-
-       if ((res = pthread_cond_timedwait(cond, &t->mutex, abstime)) && (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 {
-               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(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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);
-
-               if (t->tracking) {
-#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
-               }
-       }
-
-       return res;
-}
-
-#define ast_mutex_destroy(a)                   __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
-#define ast_mutex_lock(a)                      __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
-#define ast_mutex_unlock(a)                    __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
-#define ast_mutex_trylock(a)                   __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
-#define ast_cond_init(cond, attr)              __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
-#define ast_cond_destroy(cond)                 __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
-#define ast_cond_signal(cond)                  __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
-#define ast_cond_broadcast(cond)               __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
-#define ast_cond_wait(cond, mutex)             __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
-#define ast_cond_timedwait(cond, mutex, time)  __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
-
-struct ast_rwlock_info {
-       /*! Track which thread holds this lock */
-       struct ast_lock_track track;
-       unsigned int tracking:1;
-       pthread_rwlock_t lock;
-};
-
-typedef struct ast_rwlock_info ast_rwlock_t;
-
-/*!
- * \brief wrapper for rwlock with tracking enabled
- * \return 0 on success, non zero for error
- * \since 1.6.1
- */
-#define ast_rwlock_init(rwlock) __ast_rwlock_init(1, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
-
-/*!
- * \brief wrapper for ast_rwlock_init with tracking disabled
- * \return 0 on success, non zero for error
- * \since 1.6.1
- */
-#define ast_rwlock_init_notracking(rwlock) __ast_rwlock_init(0, __FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
-
-#define ast_rwlock_destroy(rwlock)     __ast_rwlock_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #rwlock, rwlock)
-#define ast_rwlock_unlock(a)           _ast_rwlock_unlock(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-#define ast_rwlock_rdlock(a)           _ast_rwlock_rdlock(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-#define ast_rwlock_wrlock(a)           _ast_rwlock_wrlock(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-#define ast_rwlock_tryrdlock(a)                _ast_rwlock_tryrdlock(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-#define ast_rwlock_trywrlock(a) _ast_rwlock_trywrlock(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-
-
-#ifdef HAVE_PTHREAD_RWLOCK_INITIALIZER
-#define __AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER
-#else  /* HAVE_PTHREAD_RWLOCK_INITIALIZER */
-#define __AST_RWLOCK_INIT_VALUE {0}
-#endif /* HAVE_PTHREAD_RWLOCK_INITIALIZER */
-
-#define AST_RWLOCK_INIT_VALUE \
-       { AST_LOCK_TRACK_INIT_VALUE, 1, __AST_RWLOCK_INIT_VALUE }
-#define AST_RWLOCK_INIT_VALUE_NOTRACKING \
-       { AST_LOCK_TRACK_INIT_VALUE, 0, __AST_RWLOCK_INIT_VALUE }
-
-static inline int __ast_rwlock_init(int tracking, const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
-{
-       int res;
-       struct ast_lock_track *lt= &t->track;
-       pthread_rwlockattr_t attr;
-
-#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-
-       if (t->lock != ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
-               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is already initialized.\n",
-                               filename, lineno, func, rwlock_name);
-               return 0;
-       }
-#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
-
-       ast_reentrancy_init(lt);
-       t->tracking = tracking;
-       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;
-}
-
-static inline int __ast_rwlock_destroy(const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-
-#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
-       if (t->lock == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
-               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
-                                  filename, lineno, func, rwlock_name);
-               return 0;
-       }
-#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
-
-       if ((res = pthread_rwlock_destroy(&t->lock))) {
-               __ast_mutex_logger("%s line %d (%s): Error destroying rwlock %s: %s\n",
-                               filename, lineno, func, rwlock_name, strerror(res));
-       }
-       ast_reentrancy_lock(lt);
-       lt->file[0] = filename;
-       lt->lineno[0] = lineno;
-       lt->func[0] = func;
-       lt->reentrancy = 0;
-       lt->thread[0] = 0;
-#ifdef HAVE_BKTR
-       memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
-#endif
-       ast_reentrancy_unlock(lt);
-       delete_reentrancy_cs(lt);
-
-       return res;
-}
-
-static inline int _ast_rwlock_unlock(ast_rwlock_t *t, const char *name,
-       const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-#ifdef HAVE_BKTR
-       struct ast_bt *bt = NULL;
-#endif
-       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)) {
-               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
-                                  filename, line, func, name);
-               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 */
-
-       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[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[i] = lt->thread[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[lt->reentrancy - 1] = AST_PTHREADT_NULL;
-                               break;
-                       }
-               }
-       }
-
-       if (lock_found && --lt->reentrancy < 0) {
-               __ast_mutex_logger("%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);
-
-       if (t->tracking) {
-#ifdef HAVE_BKTR
-               ast_remove_lock_info(t, bt);
-#else
-               ast_remove_lock_info(t);
-#endif
-       }
-
-       if ((res = pthread_rwlock_unlock(&t->lock))) {
-               __ast_mutex_logger("%s line %d (%s): Error releasing rwlock: %s\n",
-                               filename, line, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-
-       return res;
-}
-
-static inline int _ast_rwlock_rdlock(ast_rwlock_t *t, const char *name,
-       const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->backtrace[lt->reentrancy];
-               }
-               ast_reentrancy_unlock(lt);
-               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
-#else
-               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t);
-#endif
-       }
-
-#ifdef 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) {
-                                       __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for readlock '%s'?\n",
-                                               filename, line, func, (int)wait_time, name);
-                                       ast_reentrancy_lock(lt);
-#ifdef HAVE_BKTR
-                                       __dump_backtrace(&lt->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(&lt->backtrace[lt->reentrancy-1], canlog);
-#endif
-                                       ast_reentrancy_unlock(lt);
-                                       reported_wait = wait_time;
-                               }
-                               usleep(200);
-                       }
-               } while (res == EBUSY);
-       }
-#else /* !DETECT_DEADLOCKS */
-       res = pthread_rwlock_rdlock(&t->lock);
-#endif /* !DETECT_DEADLOCKS */
-
-       if (!res) {
-               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 {
-#ifdef HAVE_BKTR
-               if (lt->reentrancy) {
-                       ast_reentrancy_lock(lt);
-                       bt = &lt->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
-               __ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
-                               filename, line, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-       return res;
-}
-
-static inline int _ast_rwlock_wrlock(ast_rwlock_t *t, const char *name,
-       const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
-#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) {
-                                       __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for writelock '%s'?\n",
-                                               filename, line, func, (int)wait_time, name);
-                                       ast_reentrancy_lock(lt);
-#ifdef HAVE_BKTR
-                                       __dump_backtrace(&lt->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(&lt->backtrace[lt->reentrancy-1], canlog);
-#endif
-                                       ast_reentrancy_unlock(lt);
-                                       reported_wait = wait_time;
-                               }
-                               usleep(200);
-                       }
-               } while (res == EBUSY);
-       }
-#else /* !DETECT_DEADLOCKS */
-       res = pthread_rwlock_wrlock(&t->lock);
-#endif /* !DETECT_DEADLOCKS */
-
-       if (!res) {
-               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 {
-#ifdef HAVE_BKTR
-               if (lt->reentrancy) {
-                       ast_reentrancy_lock(lt);
-                       bt = &lt->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
-               __ast_mutex_logger("%s line %d (%s): Error obtaining write lock: %s\n",
-                               filename, line, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-       return res;
-}
-
-#define ast_rwlock_timedrdlock(a, b) \
-       _ast_rwlock_timedrdlock(a, # a, b, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-
-static inline int _ast_rwlock_timedrdlock(ast_rwlock_t *t, const char *name,
-       const struct timespec *abs_timeout, const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
-#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
-       res = pthread_rwlock_timedrdlock(&t->lock, abs_timeout);
-#else
-       do {
-               struct timeval _start = ast_tvnow(), _diff;
-               for (;;) {
-                       if (!(res = pthread_rwlock_tryrdlock(&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
-       if (!res) {
-               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 {
-#ifdef HAVE_BKTR
-               if (lt->reentrancy) {
-                       ast_reentrancy_lock(lt);
-                       bt = &lt->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
-               __ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
-                               filename, line, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-       return res;
-}
-
-#define ast_rwlock_timedwrlock(a, b) \
-       _ast_rwlock_timedwrlock(a, # a, b, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-
-static inline int _ast_rwlock_timedwrlock(ast_rwlock_t *t, const char *name,
-       const struct timespec *abs_timeout, const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
-#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
-       if (!res) {
-               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 {
-#ifdef HAVE_BKTR
-               if (lt->reentrancy) {
-                       ast_reentrancy_lock(lt);
-                       bt = &lt->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
-               __ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
-                               filename, line, func, strerror(res));
-               DO_THREAD_CRASH;
-       }
-       return res;
-}
-
-static inline int _ast_rwlock_tryrdlock(ast_rwlock_t *t, const char *name,
-       const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt = &t->track;
-#ifdef HAVE_BKTR
-       struct ast_bt *bt = NULL;
-#endif
-#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->backtrace[lt->reentrancy];
-               }
-               ast_reentrancy_unlock(lt);
-               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
-#else
-               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t);
-#endif
-       }
-
-       if (!(res = pthread_rwlock_tryrdlock(&t->lock))) {
-               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) {
-               ast_mark_lock_failed(t);
-       }
-       return res;
-}
-
-static inline int _ast_rwlock_trywrlock(ast_rwlock_t *t, const char *name,
-       const char *filename, int line, const char *func)
-{
-       int res;
-       struct ast_lock_track *lt= &t->track;
-#ifdef HAVE_BKTR
-       struct ast_bt *bt = NULL;
-#endif
-#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
-       int canlog = strcmp(filename, "logger.c") & t->tracking;
-
-       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) {
-#ifdef HAVE_BKTR
-               ast_reentrancy_lock(lt);
-               if (lt->reentrancy != AST_MAX_REENTRANCY) {
-                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
-                       bt = &lt->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
-       }
-
-       if (!(res = pthread_rwlock_trywrlock(&t->lock))) {
-               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) {
-               ast_mark_lock_failed(t);
-       }
-       return res;
-}
-
-#else /* !DEBUG_THREADS */
-
-#define        CHANNEL_DEADLOCK_AVOIDANCE(chan) \
-       ast_channel_unlock(chan); \
-       usleep(1); \
-       ast_channel_lock(chan);
-
-#define        DEADLOCK_AVOIDANCE(lock) \
-       ast_mutex_unlock(lock); \
-       usleep(1); \
-       ast_mutex_lock(lock);
-
-#define DLA_UNLOCK(lock)       ast_mutex_unlock(lock)
-
-#define DLA_LOCK(lock) ast_mutex_lock(lock)
-
-typedef pthread_mutex_t ast_mutex_t;
-
-#define AST_MUTEX_INIT_VALUE                   ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
-#define AST_MUTEX_INIT_VALUE_NOTRACKING                ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
-
-#define ast_mutex_init_notracking(m)           ast_mutex_init(m)
-
-static inline int ast_mutex_init(ast_mutex_t *pmutex)
-{
-       int res;
-       pthread_mutexattr_t attr;
-
-       pthread_mutexattr_init(&attr);
-       pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
-
-       res = pthread_mutex_init(pmutex, &attr);
-       pthread_mutexattr_destroy(&attr);
-       return res;
-}
-
-#define ast_pthread_mutex_init(pmutex,a) pthread_mutex_init(pmutex,a)
-
-static inline int ast_mutex_unlock(ast_mutex_t *pmutex)
-{
-       return pthread_mutex_unlock(pmutex);
-}
-
-static inline int ast_mutex_destroy(ast_mutex_t *pmutex)
-{
-       return pthread_mutex_destroy(pmutex);
-}
-
-static inline int ast_mutex_lock(ast_mutex_t *pmutex)
-{
-       __MTX_PROF(pmutex);
-}
-
-static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
-{
-       return pthread_mutex_trylock(pmutex);
-}
-
-typedef pthread_cond_t ast_cond_t;
-
-static inline int ast_cond_init(ast_cond_t *cond, pthread_condattr_t *cond_attr)
-{
-       return pthread_cond_init(cond, cond_attr);
-}
-
-static inline int ast_cond_signal(ast_cond_t *cond)
-{
-       return pthread_cond_signal(cond);
-}
-
-static inline int ast_cond_broadcast(ast_cond_t *cond)
-{
-       return pthread_cond_broadcast(cond);
-}
-
-static inline int ast_cond_destroy(ast_cond_t *cond)
-{
-       return pthread_cond_destroy(cond);
-}
-
-static inline int ast_cond_wait(ast_cond_t *cond, ast_mutex_t *t)
-{
-       return pthread_cond_wait(cond, t);
-}
-
-static inline int ast_cond_timedwait(ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
-{
-       return pthread_cond_timedwait(cond, t, abstime);
-}
-
-
-typedef pthread_rwlock_t ast_rwlock_t;
-
-#ifdef HAVE_PTHREAD_RWLOCK_INITIALIZER
-#define AST_RWLOCK_INIT_VALUE PTHREAD_RWLOCK_INITIALIZER
-#else
-#define AST_RWLOCK_INIT_VALUE { 0 }
-#endif
-
-#define ast_rwlock_init_notracking(a) ast_rwlock_init(a)
-
-static inline int ast_rwlock_init(ast_rwlock_t *prwlock)
-{
-       int res;
-       pthread_rwlockattr_t attr;
-
-       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(prwlock, &attr);
-       pthread_rwlockattr_destroy(&attr);
-       return res;
-}
-
-static inline int ast_rwlock_destroy(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_destroy(prwlock);
-}
-
-static inline int ast_rwlock_unlock(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_unlock(prwlock);
-}
-
-static inline int ast_rwlock_rdlock(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_rdlock(prwlock);
-}
-
-static inline int ast_rwlock_timedrdlock(ast_rwlock_t *prwlock, const struct timespec *abs_timeout)
-{
-       int res;
-#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
-       res = pthread_rwlock_timedrdlock(prwlock, abs_timeout);
-#else
-       struct timeval _start = ast_tvnow(), _diff;
-       for (;;) {
-               if (!(res = pthread_rwlock_tryrdlock(prwlock))) {
-                       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);
-       }
-#endif
-       return res;
-}
-
-static inline int ast_rwlock_tryrdlock(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_tryrdlock(prwlock);
-}
-
-static inline int ast_rwlock_wrlock(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_wrlock(prwlock);
-}
-
-static inline int ast_rwlock_timedwrlock(ast_rwlock_t *prwlock, const struct timespec *abs_timeout)
-{
-       int res;
-#ifdef HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
-       res = pthread_rwlock_timedwrlock(prwlock, abs_timeout);
-#else
-       do {
-               struct timeval _start = ast_tvnow(), _diff;
-               for (;;) {
-                       if (!(res = pthread_rwlock_trywrlock(prwlock))) {
-                               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
-       return res;
-}
-
-static inline int ast_rwlock_trywrlock(ast_rwlock_t *prwlock)
-{
-       return pthread_rwlock_trywrlock(prwlock);
-}
-
-#endif /* !DEBUG_THREADS */
-
-#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
-/*
- * If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope constructors
- * and destructors to create/destroy global mutexes.
- */
-#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track)      \
-       scope ast_mutex_t mutex = init_val;                     \
-static void  __attribute__((constructor)) init_##mutex(void)   \
-{                                                              \
-       if (track)                                              \
-               ast_mutex_init(&mutex);                         \
-       else                                                    \
-               ast_mutex_init_notracking(&mutex);              \
-}                                                              \
-                                                               \
-static void  __attribute__((destructor)) fini_##mutex(void)    \
-{                                                              \
-       ast_mutex_destroy(&mutex);                              \
-}
-#else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
-/* By default, use static initialization of mutexes. */
-#define __AST_MUTEX_DEFINE(scope, mutex, init_val, track)      scope ast_mutex_t mutex = init_val
-#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
-
-#ifndef __CYGWIN__     /* temporary disabled for cygwin */
-#define pthread_mutex_t                use_ast_mutex_t_instead_of_pthread_mutex_t
-#define pthread_cond_t         use_ast_cond_t_instead_of_pthread_cond_t
-#endif
-#define pthread_mutex_lock     use_ast_mutex_lock_instead_of_pthread_mutex_lock
-#define pthread_mutex_unlock   use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
-#define pthread_mutex_trylock  use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
-#define pthread_mutex_init     use_ast_mutex_init_instead_of_pthread_mutex_init
-#define pthread_mutex_destroy  use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
-#define pthread_cond_init      use_ast_cond_init_instead_of_pthread_cond_init
-#define pthread_cond_destroy   use_ast_cond_destroy_instead_of_pthread_cond_destroy
-#define pthread_cond_signal    use_ast_cond_signal_instead_of_pthread_cond_signal
-#define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
-#define pthread_cond_wait      use_ast_cond_wait_instead_of_pthread_cond_wait
-#define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
-
-#define AST_MUTEX_DEFINE_STATIC(mutex)                 __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE, 1)
-#define AST_MUTEX_DEFINE_STATIC_NOTRACKING(mutex)      __AST_MUTEX_DEFINE(static, mutex, AST_MUTEX_INIT_VALUE_NOTRACKING, 0)
-
-#define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
-
-#define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
-
-#ifndef __linux__
-#define pthread_create __use_ast_pthread_create_instead__
-#endif
-
-/* Statically declared read/write locks */
-
-#ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
-#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) \
-        scope ast_rwlock_t rwlock = init_val; \
-static void  __attribute__((constructor)) init_##rwlock(void) \
-{ \
-       if (track) \
-               ast_rwlock_init(&rwlock); \
-       else \
-               ast_rwlock_init_notracking(&rwlock); \
-} \
-static void  __attribute__((destructor)) fini_##rwlock(void) \
-{ \
-        ast_rwlock_destroy(&rwlock); \
-}
-#else
-#define __AST_RWLOCK_DEFINE(scope, rwlock, init_val, track) \
-        scope ast_rwlock_t rwlock = init_val
-#endif
-
-#define AST_RWLOCK_DEFINE_STATIC(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE, 1)
-#define AST_RWLOCK_DEFINE_STATIC_NOTRACKING(rwlock) __AST_RWLOCK_DEFINE(static, rwlock, AST_RWLOCK_INIT_VALUE_NOTRACKING, 0)
 
 /*
  * Support for atomic instructions.
index 1de1626..2bca417 100644 (file)
@@ -111,19 +111,11 @@ int ast_odbc_smart_execute(struct odbc_obj *obj, SQLHSTMT stmt) __attribute__((d
  * thread which requests it.  Note that all connections should be released
  * when the thread is done by calling odbc_release_obj(), below.
  */
-#ifdef DEBUG_THREADS
 struct odbc_obj *_ast_odbc_request_obj2(const char *name, struct ast_flags flags, const char *file, const char *function, int lineno);
-#define ast_odbc_request_obj2(a, b)    _ast_odbc_request_obj2(a, b, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#else
-struct odbc_obj *ast_odbc_request_obj2(const char *name, struct ast_flags flags);
-#endif
-
-#ifdef DEBUG_THREADS
 struct odbc_obj *_ast_odbc_request_obj(const char *name, int check, const char *file, const char *function, int lineno);
+
+#define ast_odbc_request_obj2(a, b)    _ast_odbc_request_obj2(a, b, __FILE__, __PRETTY_FUNCTION__, __LINE__)
 #define ast_odbc_request_obj(a, b)     _ast_odbc_request_obj(a, b, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#else
-struct odbc_obj *ast_odbc_request_obj(const char *name, int check);
-#endif
 
 /*!
  * \brief Retrieve a stored ODBC object, if a transaction has been started.
index 40efd0f..2533953 100644 (file)
@@ -143,11 +143,7 @@ static void *internal_ao2_callback(struct ao2_container *c,
                                   char *tag, char *file, int line, const char *funcname);
 static void *internal_ao2_iterator_next(struct ao2_iterator *a, struct bucket_list **q);
 
-#ifndef DEBUG_THREADS
-int ao2_lock(void *user_data)
-#else
 int __ao2_lock(void *user_data, const char *file, const char *func, int line, const char *var)
-#endif
 {
        struct astobj2 *p = INTERNAL_OBJ(user_data);
 
@@ -158,18 +154,10 @@ int __ao2_lock(void *user_data, const char *file, const char *func, int line, co
        ast_atomic_fetchadd_int(&ao2.total_locked, 1);
 #endif
 
-#ifndef DEBUG_THREADS
-       return ast_mutex_lock(&p->priv_data.lock);
-#else
        return __ast_pthread_mutex_lock(file, line, func, var, &p->priv_data.lock);
-#endif
 }
 
-#ifndef DEBUG_THREADS
-int ao2_unlock(void *user_data)
-#else
 int __ao2_unlock(void *user_data, const char *file, const char *func, int line, const char *var)
-#endif
 {
        struct astobj2 *p = INTERNAL_OBJ(user_data);
 
@@ -180,29 +168,17 @@ int __ao2_unlock(void *user_data, const char *file, const char *func, int line,
        ast_atomic_fetchadd_int(&ao2.total_locked, -1);
 #endif
 
-#ifndef DEBUG_THREADS
-       return ast_mutex_unlock(&p->priv_data.lock);
-#else
        return __ast_pthread_mutex_unlock(file, line, func, var, &p->priv_data.lock);
-#endif
 }
 
-#ifndef DEBUG_THREADS
-int ao2_trylock(void *user_data)
-#else
 int __ao2_trylock(void *user_data, const char *file, const char *func, int line, const char *var)
-#endif
 {
        struct astobj2 *p = INTERNAL_OBJ(user_data);
        int ret;
        
        if (p == NULL)
                return -1;
-#ifndef DEBUG_THREADS
-       ret = ast_mutex_trylock(&p->priv_data.lock);
-#else
        ret = __ast_pthread_mutex_trylock(file, line, func, var, &p->priv_data.lock);
-#endif
 
 #ifdef AO2_DEBUG
        if (!ret)
index ace5bc8..30fb4e4 100644 (file)
@@ -302,38 +302,17 @@ size_t ast_heap_size(struct ast_heap *h)
        return h->cur_len;
 }
 
-#ifndef DEBUG_THREADS
-
-int ast_heap_wrlock(struct ast_heap *h)
-{
-       return ast_rwlock_wrlock(&h->lock);
-}
-
-int ast_heap_rdlock(struct ast_heap *h)
-{
-       return ast_rwlock_rdlock(&h->lock);
-}
-
-int ast_heap_unlock(struct ast_heap *h)
-{
-       return ast_rwlock_unlock(&h->lock);
-}
-
-#else /* DEBUG_THREADS */
-
 int __ast_heap_wrlock(struct ast_heap *h, const char *file, const char *func, int line)
 {
-       return _ast_rwlock_wrlock(&h->lock, "&h->lock", file, line, func);
+       return __ast_rwlock_wrlock(&h->lock, "&h->lock", file, line, func);
 }
 
 int __ast_heap_rdlock(struct ast_heap *h, const char *file, const char *func, int line)
 {
-       return _ast_rwlock_rdlock(&h->lock, "&h->lock", file, line, func);
+       return __ast_rwlock_rdlock(&h->lock, "&h->lock", file, line, func);
 }
 
 int __ast_heap_unlock(struct ast_heap *h, const char *file, const char *func, int line)
 {
-       return _ast_rwlock_unlock(&h->lock, "&h->lock", file, line, func);
+       return __ast_rwlock_unlock(&h->lock, "&h->lock", file, line, func);
 }
-
-#endif /* DEBUG_THREADS */
diff --git a/main/lock.c b/main/lock.c
new file mode 100644 (file)
index 0000000..e592599
--- /dev/null
@@ -0,0 +1,1371 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2010, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief General Asterisk locking.
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/lock.h"
+
+/* Allow direct use of pthread_mutex_* / pthread_cond_* */
+#undef pthread_mutex_init
+#undef pthread_mutex_destroy
+#undef pthread_mutex_lock
+#undef pthread_mutex_trylock
+#undef pthread_mutex_unlock
+#undef pthread_cond_init
+#undef pthread_cond_signal
+#undef pthread_cond_broadcast
+#undef pthread_cond_destroy
+#undef pthread_cond_wait
+#undef pthread_cond_timedwait
+
+int __ast_pthread_mutex_init(int tracking, const char *filename, int lineno, const char *func,
+                                               const char *mutex_name, ast_mutex_t *t)
+{
+       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 = strcmp(filename, "logger.c") & track;
+               __ast_mutex_logger("%s line %d (%s): NOTICE: mutex '%s' is already initialized.\n",
+                                  filename, lineno, func, mutex_name);
+               DO_THREAD_CRASH;
+*/
+               return 0;
+       }
+
+#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+
+       ast_reentrancy_init(&t->track);
+       t->tracking = tracking;
+#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;
+}
+
+int __ast_pthread_mutex_destroy(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;
+
+#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 non initialized mutex
+                * This may no effect on linux
+                * And always ganerate core on *BSD with
+                * linked libpthread
+                * This not error condition if the mutex created on the fly.
+                */
+               __ast_mutex_logger("%s line %d (%s): NOTICE: mutex '%s' is uninitialized.\n",
+                                  filename, lineno, func, mutex_name);
+               return 0;
+       }
+#endif
+
+       lt = &t->track;
+
+       res = pthread_mutex_trylock(&t->mutex);
+       switch (res) {
+       case 0:
+               pthread_mutex_unlock(&t->mutex);
+               break;
+       case EINVAL:
+               __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
+                                 filename, lineno, func, mutex_name);
+               break;
+       case EBUSY:
+               __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
+                                  filename, lineno, func, mutex_name);
+               ast_reentrancy_lock(lt);
+               __ast_mutex_logger("%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) {
+               __ast_mutex_logger("%s line %d (%s): Error destroying mutex %s: %s\n",
+                                  filename, lineno, func, mutex_name, strerror(res));
+       }
+       ast_reentrancy_lock(lt);
+       lt->file[0] = filename;
+       lt->lineno[0] = lineno;
+       lt->func[0] = func;
+       lt->reentrancy = 0;
+       lt->thread[0] = 0;
+#ifdef HAVE_BKTR
+       memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
+#endif
+       ast_reentrancy_unlock(lt);
+       delete_reentrancy_cs(lt);
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
+
+int __ast_pthread_mutex_lock(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 = &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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 */
+
+#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) {
+                                       __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
+                                                          filename, lineno, func, (int) wait_time, mutex_name);
+                                       ast_reentrancy_lock(lt);
+#ifdef HAVE_BKTR
+                                       __dump_backtrace(&lt->backtrace[lt->reentrancy], canlog);
+#endif
+                                       __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(&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 (!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 {
+#ifdef HAVE_BKTR
+               if (lt->reentrancy) {
+                       ast_reentrancy_lock(lt);
+                       bt = &lt->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
+               __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
+                                  filename, lineno, 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= &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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 (!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_pthread_mutex_unlock(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 = &t->track;
+       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 */
+
+       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(&lt->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 = &lt->backtrace[lt->reentrancy - 1];
+       }
+#endif
+       ast_reentrancy_unlock(lt);
+
+       if (t->tracking) {
+#ifdef HAVE_BKTR
+               ast_remove_lock_info(t, bt);
+#else
+               ast_remove_lock_info(t);
+#endif
+       }
+#endif /* DEBUG_THREADS */
+
+       res = pthread_mutex_unlock(&t->mutex);
+
+#ifdef DEBUG_THREADS
+       if (res) {
+               __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n",
+                                  filename, lineno, func, strerror(res));
+               DO_THREAD_CRASH;
+       }
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
+
+
+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)
+{
+       return pthread_cond_init(cond, cond_attr);
+}
+
+int __ast_cond_signal(const char *filename, int lineno, const char *func,
+                                   const char *cond_name, ast_cond_t *cond)
+{
+       return pthread_cond_signal(cond);
+}
+
+int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
+                                      const char *cond_name, ast_cond_t *cond)
+{
+       return pthread_cond_broadcast(cond);
+}
+
+int __ast_cond_destroy(const char *filename, int lineno, const char *func,
+                                    const char *cond_name, ast_cond_t *cond)
+{
+       return pthread_cond_destroy(cond);
+}
+
+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 res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt= &t->track;
+       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 */
+
+       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(&lt->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 = &lt->backtrace[lt->reentrancy - 1];
+       }
+#endif
+       ast_reentrancy_unlock(lt);
+
+       if (t->tracking) {
+#ifdef HAVE_BKTR
+               ast_remove_lock_info(t, bt);
+#else
+               ast_remove_lock_info(t);
+#endif
+       }
+#endif /* DEBUG_THREADS */
+
+       res = pthread_cond_wait(cond, &t->mutex);
+
+#ifdef DEBUG_THREADS
+       if (res) {
+               __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
+                                  filename, lineno, func, strerror(res));
+               DO_THREAD_CRASH;
+       } else {
+               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(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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);
+
+               if (t->tracking) {
+#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_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 = &t->track;
+       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 */
+
+       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(&lt->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 = &lt->backtrace[lt->reentrancy - 1];
+       }
+#endif
+       ast_reentrancy_unlock(lt);
+
+       if (t->tracking) {
+#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 {
+               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(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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);
+
+               if (t->tracking) {
+#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_rwlock_init(int tracking, const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
+{
+       int res;
+       pthread_rwlockattr_t attr;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt= &t->track;
+
+#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
+        int canlog = strcmp(filename, "logger.c") & t->tracking;
+
+       if (t->lock != ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
+               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is already initialized.\n",
+                               filename, lineno, func, rwlock_name);
+               return 0;
+       }
+#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+
+       ast_reentrancy_init(lt);
+       t->tracking = tracking;
+#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;
+}
+
+int __ast_rwlock_destroy(const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       int canlog = strcmp(filename, "logger.c") & t->tracking;
+
+#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
+       if (t->lock == ((pthread_rwlock_t) __AST_RWLOCK_INIT_VALUE)) {
+               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
+                                  filename, lineno, func, rwlock_name);
+               return 0;
+       }
+#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+
+#endif /* DEBUG_THREADS */
+
+       res = pthread_rwlock_destroy(&t->lock);
+
+#ifdef DEBUG_THREADS
+       if (res) {
+               __ast_mutex_logger("%s line %d (%s): Error destroying rwlock %s: %s\n",
+                               filename, lineno, func, rwlock_name, strerror(res));
+       }
+       ast_reentrancy_lock(lt);
+       lt->file[0] = filename;
+       lt->lineno[0] = lineno;
+       lt->func[0] = func;
+       lt->reentrancy = 0;
+       lt->thread[0] = 0;
+#ifdef HAVE_BKTR
+       memset(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
+#endif
+       ast_reentrancy_unlock(lt);
+       delete_reentrancy_cs(lt);
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
+
+int __ast_rwlock_unlock(ast_rwlock_t *t, const char *name,
+       const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       int canlog = strcmp(filename, "logger.c") & t->tracking;
+#ifdef HAVE_BKTR
+       struct ast_bt *bt = NULL;
+#endif
+       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)) {
+               __ast_mutex_logger("%s line %d (%s): Warning: rwlock '%s' is uninitialized.\n",
+                                  filename, line, func, name);
+               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 */
+
+       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[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[i] = lt->thread[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[lt->reentrancy - 1] = AST_PTHREADT_NULL;
+                               break;
+                       }
+               }
+       }
+
+       if (lock_found && --lt->reentrancy < 0) {
+               __ast_mutex_logger("%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);
+
+       if (t->tracking) {
+#ifdef HAVE_BKTR
+               ast_remove_lock_info(t, bt);
+#else
+               ast_remove_lock_info(t);
+#endif
+       }
+#endif /* DEBUG_THREADS */
+
+       res = pthread_rwlock_unlock(&t->lock);
+
+#ifdef DEBUG_THREADS
+       if (res) {
+               __ast_mutex_logger("%s line %d (%s): Error releasing rwlock: %s\n",
+                               filename, line, func, strerror(res));
+               DO_THREAD_CRASH;
+       }
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
+
+int __ast_rwlock_rdlock(ast_rwlock_t *t, const char *name,
+       const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->backtrace[lt->reentrancy];
+               }
+               ast_reentrancy_unlock(lt);
+               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
+#else
+               ast_store_lock_info(AST_RDLOCK, 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_tryrdlock(&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 readlock '%s'?\n",
+                                               filename, line, func, (int)wait_time, name);
+                                       ast_reentrancy_lock(lt);
+#ifdef HAVE_BKTR
+                                       __dump_backtrace(&lt->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(&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) {
+               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 {
+#ifdef HAVE_BKTR
+               if (lt->reentrancy) {
+                       ast_reentrancy_lock(lt);
+                       bt = &lt->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
+               __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(ast_rwlock_t *t, const char *name,
+       const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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);
+                                       ast_reentrancy_lock(lt);
+#ifdef HAVE_BKTR
+                                       __dump_backtrace(&lt->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(&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) {
+               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 {
+#ifdef HAVE_BKTR
+               if (lt->reentrancy) {
+                       ast_reentrancy_lock(lt);
+                       bt = &lt->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
+               __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_rwlock_timedrdlock(ast_rwlock_t *t, const char *name,
+       const struct timespec *abs_timeout, const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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_timedrdlock(&t->lock, abs_timeout);
+#else
+       do {
+               struct timeval _start = ast_tvnow(), _diff;
+               for (;;) {
+                       if (!(res = pthread_rwlock_tryrdlock(&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) {
+               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 {
+#ifdef HAVE_BKTR
+               if (lt->reentrancy) {
+                       ast_reentrancy_lock(lt);
+                       bt = &lt->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
+               __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_timedwrlock(ast_rwlock_t *t, const char *name,
+       const struct timespec *abs_timeout, const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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) {
+               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 {
+#ifdef HAVE_BKTR
+               if (lt->reentrancy) {
+                       ast_reentrancy_lock(lt);
+                       bt = &lt->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
+               __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_tryrdlock(ast_rwlock_t *t, const char *name,
+       const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt = &t->track;
+#ifdef HAVE_BKTR
+       struct ast_bt *bt = NULL;
+#endif
+#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
+       int canlog = strcmp(filename, "logger.c") & t->tracking;
+
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->backtrace[lt->reentrancy];
+               }
+               ast_reentrancy_unlock(lt);
+               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t, bt);
+#else
+               ast_store_lock_info(AST_RDLOCK, filename, line, func, name, t);
+#endif
+       }
+#endif /* DEBUG_THREADS */
+
+       res = pthread_rwlock_tryrdlock(&t->lock);
+
+#ifdef DEBUG_THREADS
+       if (!res) {
+               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) {
+               ast_mark_lock_failed(t);
+       }
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
+
+int __ast_rwlock_trywrlock(ast_rwlock_t *t, const char *name,
+       const char *filename, int line, const char *func)
+{
+       int res;
+
+#ifdef DEBUG_THREADS
+       struct ast_lock_track *lt= &t->track;
+#ifdef HAVE_BKTR
+       struct ast_bt *bt = NULL;
+#endif
+#if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) && defined(CAN_COMPARE_MUTEX_TO_INIT_VALUE)
+       int canlog = strcmp(filename, "logger.c") & t->tracking;
+
+       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) {
+#ifdef HAVE_BKTR
+               ast_reentrancy_lock(lt);
+               if (lt->reentrancy != AST_MAX_REENTRANCY) {
+                       ast_bt_get_addresses(&lt->backtrace[lt->reentrancy]);
+                       bt = &lt->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) {
+               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) {
+               ast_mark_lock_failed(t);
+       }
+#endif /* DEBUG_THREADS */
+
+       return res;
+}
index 9498cc5..1859f76 100644 (file)
@@ -1150,11 +1150,7 @@ static int aoro2_obj_cb(void *vobj, void *arg, int flags)
        return 0;
 }
 
-#ifdef DEBUG_THREADS
 struct odbc_obj *_ast_odbc_request_obj2(const char *name, struct ast_flags flags, const char *file, const char *function, int lineno)
-#else
-struct odbc_obj *ast_odbc_request_obj2(const char *name, struct ast_flags flags)
-#endif
 {
        struct odbc_obj *obj = NULL;
        struct odbc_class *class;
@@ -1325,18 +1321,10 @@ struct odbc_obj *ast_odbc_request_obj2(const char *name, struct ast_flags flags)
        return obj;
 }
 
-#ifdef DEBUG_THREADS
 struct odbc_obj *_ast_odbc_request_obj(const char *name, int check, const char *file, const char *function, int lineno)
-#else
-struct odbc_obj *ast_odbc_request_obj(const char *name, int check)
-#endif
 {
        struct ast_flags flags = { check ? RES_ODBC_SANITY_CHECK : 0 };
-#ifdef DEBUG_THREADS
        return _ast_odbc_request_obj2(name, flags, file, function, lineno);
-#else
-       return ast_odbc_request_obj2(name, flags);
-#endif
 }
 
 struct odbc_obj *ast_odbc_retrieve_transaction_obj(struct ast_channel *chan, const char *objname)