#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_MUTEX_INIT_VALUE { PTHREAD_MUTEX_INIT_VALUE, NULL, 1 }
+#define AST_MUTEX_INIT_VALUE_NOTRACKING { PTHREAD_MUTEX_INIT_VALUE, NULL, 0 }
-#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_RWLOCK_INIT_VALUE { __AST_RWLOCK_INIT_VALUE, NULL, 1 }
+#define AST_RWLOCK_INIT_VALUE_NOTRACKING { __AST_RWLOCK_INIT_VALUE, NULL, 0 }
#define AST_MAX_REENTRANCY 10
* The information will just be ignored in the core if a module does not request it..
*/
struct ast_mutex_info {
+ pthread_mutex_t mutex;
/*! Track which thread holds this mutex */
- struct ast_lock_track track;
+ struct ast_lock_track *track;
unsigned int tracking:1;
- pthread_mutex_t mutex;
};
/*! \brief Structure for rwlock and tracking information.
* The information will just be ignored in the core if a module does not request it..
*/
struct ast_rwlock_info {
+ pthread_rwlock_t lock;
/*! Track which thread holds this lock */
- struct ast_lock_track track;
+ struct ast_lock_track *track;
unsigned int tracking:1;
- pthread_rwlock_t lock;
};
typedef struct ast_mutex_info ast_mutex_t;
int __ast_rwlock_init(int tracking, const char *filename, int lineno, const char *func, const char *rwlock_name, ast_rwlock_t *t);
int __ast_rwlock_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);
+int __ast_rwlock_unlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name);
+int __ast_rwlock_rdlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name);
+int __ast_rwlock_wrlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name);
+int __ast_rwlock_timedrdlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout);
+int __ast_rwlock_timedwrlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name, const struct timespec *abs_timeout);
+int __ast_rwlock_tryrdlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name);
+int __ast_rwlock_trywrlock(const char *filename, int lineno, const char *func, ast_rwlock_t *t, const char *name);
/*!
* \brief wrapper for rwlock with tracking enabled
#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 ast_rwlock_unlock(a) __ast_rwlock_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
+#define ast_rwlock_rdlock(a) __ast_rwlock_rdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
+#define ast_rwlock_wrlock(a) __ast_rwlock_wrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
+#define ast_rwlock_tryrdlock(a) __ast_rwlock_tryrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
+#define ast_rwlock_trywrlock(a) __ast_rwlock_trywrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a)
+#define ast_rwlock_timedrdlock(a, b) __ast_rwlock_timedrdlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)
+#define ast_rwlock_timedwrlock(a, b) __ast_rwlock_timedwrlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, #a, b)
#define ROFFSET ((lt->reentrancy > 0) ? (lt->reentrancy-1) : 0)
pthread_mutex_unlock(<->reentr_mutex);
}
-static inline void ast_reentrancy_init(struct ast_lock_track *lt)
+static inline void ast_reentrancy_init(struct ast_lock_track **plt)
{
int i;
pthread_mutexattr_t reentr_attr;
+ struct ast_lock_track *lt = *plt;
+
+ if (!lt) {
+ lt = *plt = (struct ast_lock_track *) ast_calloc(1, sizeof(*lt));
+ }
for (i = 0; i < AST_MAX_REENTRANCY; i++) {
lt->file[i] = NULL;
pthread_mutexattr_destroy(&reentr_attr);
}
-static inline void delete_reentrancy_cs(struct ast_lock_track *lt)
+static inline void delete_reentrancy_cs(struct ast_lock_track **plt)
{
- pthread_mutex_destroy(<->reentr_mutex);
+ struct ast_lock_track *lt;
+ if (*plt) {
+ lt = *plt;
+ pthread_mutex_destroy(<->reentr_mutex);
+ ast_free(lt);
+ *plt = NULL;
+ }
}
#else /* !DEBUG_THREADS */
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
ast_reentrancy_init(&t->track);
- t->tracking = tracking;
#endif /* DEBUG_THREADS */
pthread_mutexattr_init(&attr);
}
#endif
- lt = &t->track;
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
res = pthread_mutex_trylock(&t->mutex);
switch (res) {
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);
+ if (t->tracking) {
+ 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(<->backtrace[ROFFSET], canlog);
+ __dump_backtrace(<->backtrace[ROFFSET], canlog);
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
+ }
break;
}
#endif /* DEBUG_THREADS */
__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;
+ if (t->tracking) {
+ 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(<->backtrace[0], 0, sizeof(lt->backtrace[0]));
+ memset(<->backtrace[0], 0, sizeof(lt->backtrace[0]));
#endif
- ast_reentrancy_unlock(lt);
- delete_reentrancy_cs(lt);
+ ast_reentrancy_unlock(lt);
+ delete_reentrancy_cs(&t->track);
+ }
#endif /* DEBUG_THREADS */
return res;
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
#ifdef DEBUG_THREADS
- if (!res) {
+ if (t->tracking && !res) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
if (t->tracking) {
ast_mark_lock_acquired(t);
}
- } else {
+ } else if (t->tracking) {
#ifdef HAVE_BKTR
if (lt->reentrancy) {
ast_reentrancy_lock(lt);
} else {
bt = NULL;
}
- if (t->tracking) {
- ast_remove_lock_info(t, bt);
- }
+ ast_remove_lock_info(t, bt);
#else
- if (t->tracking) {
- ast_remove_lock_info(t);
- }
+ ast_remove_lock_info(t);
#endif
+ }
+ if (res) {
__ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
filename, lineno, func, strerror(res));
DO_THREAD_CRASH;
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt= &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
res = pthread_mutex_trylock(&t->mutex);
#ifdef DEBUG_THREADS
- if (!res) {
+ if (t->tracking && !res) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#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);
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
+ if (t->tracking) {
+ ast_reentrancy_lock(lt);
+ if (lt->reentrancy && (lt->thread[ROFFSET] != pthread_self())) {
+ __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
+ filename, lineno, func, mutex_name);
+ __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
+ lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[ROFFSET], canlog);
+ __dump_backtrace(<->backtrace[ROFFSET], canlog);
#endif
- DO_THREAD_CRASH;
- }
+ 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 < 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;
- }
+ if (lt->reentrancy < AST_MAX_REENTRANCY) {
+ lt->file[lt->reentrancy] = NULL;
+ lt->lineno[lt->reentrancy] = 0;
+ lt->func[lt->reentrancy] = NULL;
+ lt->thread[lt->reentrancy] = 0;
+ }
#ifdef HAVE_BKTR
- if (lt->reentrancy) {
- bt = <->backtrace[lt->reentrancy - 1];
- }
+ if (lt->reentrancy) {
+ bt = <->backtrace[lt->reentrancy - 1];
+ }
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
ast_remove_lock_info(t, bt);
#else
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt= &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#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);
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
+ if (t->tracking) {
+ ast_reentrancy_lock(lt);
+ if (lt->reentrancy && (lt->thread[ROFFSET] != pthread_self())) {
+ __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
+ filename, lineno, func, mutex_name);
+ __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
+ lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[ROFFSET], canlog);
+ __dump_backtrace(<->backtrace[ROFFSET], canlog);
#endif
- DO_THREAD_CRASH;
- }
+ DO_THREAD_CRASH;
+ }
- if (--lt->reentrancy < 0) {
- __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
+ 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;
- }
+ 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;
- }
+ if (lt->reentrancy < AST_MAX_REENTRANCY) {
+ lt->file[lt->reentrancy] = NULL;
+ lt->lineno[lt->reentrancy] = 0;
+ lt->func[lt->reentrancy] = NULL;
+ lt->thread[lt->reentrancy] = 0;
+ }
#ifdef HAVE_BKTR
- if (lt->reentrancy) {
- bt = <->backtrace[lt->reentrancy - 1];
- }
+ if (lt->reentrancy) {
+ bt = <->backtrace[lt->reentrancy - 1];
+ }
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
ast_remove_lock_info(t, bt);
#else
__ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
filename, lineno, func, strerror(res));
DO_THREAD_CRASH;
- } else {
+ } else if (t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
}
ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
- ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt);
+ 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);
+ ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t);
#endif
- }
}
#endif /* DEBUG_THREADS */
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#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);
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
+ if (t->tracking) {
+ ast_reentrancy_lock(lt);
+ if (lt->reentrancy && (lt->thread[ROFFSET] != pthread_self())) {
+ __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
+ filename, lineno, func, mutex_name);
+ __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
+ lt->file[ROFFSET], lt->lineno[ROFFSET], lt->func[ROFFSET], mutex_name);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[ROFFSET], canlog);
+ __dump_backtrace(<->backtrace[ROFFSET], canlog);
#endif
- DO_THREAD_CRASH;
- }
+ 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 < 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;
- }
+ if (lt->reentrancy < AST_MAX_REENTRANCY) {
+ lt->file[lt->reentrancy] = NULL;
+ lt->lineno[lt->reentrancy] = 0;
+ lt->func[lt->reentrancy] = NULL;
+ lt->thread[lt->reentrancy] = 0;
+ }
#ifdef HAVE_BKTR
- if (lt->reentrancy) {
- bt = <->backtrace[lt->reentrancy - 1];
- }
+ if (lt->reentrancy) {
+ bt = <->backtrace[lt->reentrancy - 1];
+ }
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
ast_remove_lock_info(t, bt);
#else
__ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
filename, lineno, func, strerror(res));
DO_THREAD_CRASH;
- } else {
+ } else if (t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
}
ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
- ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t, bt);
+ 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);
+ ast_store_lock_info(AST_MUTEX, filename, lineno, func, mutex_name, t);
#endif
- }
}
#endif /* DEBUG_THREADS */
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;
+ 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",
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
- ast_reentrancy_init(lt);
- t->tracking = tracking;
+ if ((t->tracking = tracking)) {
+ ast_reentrancy_init(&t->track);
+ }
#endif /* DEBUG_THREADS */
pthread_rwlockattr_init(&attr);
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ 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)
__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;
+ if (t->tracking) {
+ 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(<->backtrace[0], 0, sizeof(lt->backtrace[0]));
+ memset(<->backtrace[0], 0, sizeof(lt->backtrace[0]));
#endif
- ast_reentrancy_unlock(lt);
- delete_reentrancy_cs(lt);
+ ast_reentrancy_unlock(lt);
+ delete_reentrancy_cs(&t->track);
+ }
#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 __ast_rwlock_unlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#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];
- }
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
+ if (t->tracking) {
+ 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 = <->backtrace[i];
+ bt = <->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;
+ 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;
- }
+ 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);
+ ast_reentrancy_unlock(lt);
- if (t->tracking) {
#ifdef HAVE_BKTR
ast_remove_lock_info(t, bt);
#else
return res;
}
-int __ast_rwlock_rdlock(ast_rwlock_t *t, const char *name,
- const char *filename, int line, const char *func)
+int __ast_rwlock_rdlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
if (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);
+ if (t->tracking) {
+ ast_reentrancy_lock(lt);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[lt->reentrancy], canlog);
+ __dump_backtrace(<->backtrace[lt->reentrancy], canlog);
#endif
- __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
- lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
- lt->func[lt->reentrancy-1], name);
+ __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
+ lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
+ lt->func[lt->reentrancy-1], name);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[lt->reentrancy-1], canlog);
+ __dump_backtrace(<->backtrace[lt->reentrancy-1], canlog);
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
+ }
reported_wait = wait_time;
}
usleep(200);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
if (t->tracking) {
ast_mark_lock_acquired(t);
}
- } else {
+ } else if (t->tracking) {
#ifdef HAVE_BKTR
if (lt->reentrancy) {
ast_reentrancy_lock(lt);
} else {
bt = NULL;
}
- if (t->tracking) {
- ast_remove_lock_info(t, bt);
- }
+ ast_remove_lock_info(t, bt);
#else
- if (t->tracking) {
- ast_remove_lock_info(t);
- }
+ ast_remove_lock_info(t);
#endif
+ }
+
+ if (res) {
__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
filename, line, func, strerror(res));
DO_THREAD_CRASH;
return res;
}
-int __ast_rwlock_wrlock(ast_rwlock_t *t, const char *name,
- const char *filename, int line, const char *func)
+int __ast_rwlock_wrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
if (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);
+ if (t->tracking) {
+ ast_reentrancy_lock(lt);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[lt->reentrancy], canlog);
+ __dump_backtrace(<->backtrace[lt->reentrancy], canlog);
#endif
- __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
- lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
- lt->func[lt->reentrancy-1], name);
+ __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
+ lt->file[lt->reentrancy-1], lt->lineno[lt->reentrancy-1],
+ lt->func[lt->reentrancy-1], name);
#ifdef HAVE_BKTR
- __dump_backtrace(<->backtrace[lt->reentrancy-1], canlog);
+ __dump_backtrace(<->backtrace[lt->reentrancy-1], canlog);
#endif
- ast_reentrancy_unlock(lt);
+ ast_reentrancy_unlock(lt);
+ }
reported_wait = wait_time;
}
usleep(200);
#endif /* !DETECT_DEADLOCKS || !DEBUG_THREADS */
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
if (t->tracking) {
ast_mark_lock_acquired(t);
}
- } else {
+ } else if (t->tracking) {
#ifdef HAVE_BKTR
if (lt->reentrancy) {
ast_reentrancy_lock(lt);
ast_remove_lock_info(t);
}
#endif
+ }
+ if (res) {
__ast_mutex_logger("%s line %d (%s): Error obtaining write lock: %s\n",
filename, line, func, strerror(res));
DO_THREAD_CRASH;
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 __ast_rwlock_timedrdlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name,
+ const struct timespec *abs_timeout)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
#endif
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
if (t->tracking) {
ast_mark_lock_acquired(t);
}
- } else {
+ } else if (t->tracking) {
#ifdef HAVE_BKTR
if (lt->reentrancy) {
ast_reentrancy_lock(lt);
} else {
bt = NULL;
}
- if (t->tracking) {
- ast_remove_lock_info(t, bt);
- }
+ ast_remove_lock_info(t, bt);
#else
- if (t->tracking) {
- ast_remove_lock_info(t);
- }
+ ast_remove_lock_info(t);
#endif
+ }
+ if (res) {
__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
filename, line, func, strerror(res));
DO_THREAD_CRASH;
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 __ast_rwlock_timedwrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name,
+ const struct timespec *abs_timeout)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
int canlog = strcmp(filename, "logger.c") & t->tracking;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
#endif
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
if (t->tracking) {
ast_mark_lock_acquired(t);
}
- } else {
+ } else if (t->tracking) {
#ifdef HAVE_BKTR
if (lt->reentrancy) {
ast_reentrancy_lock(lt);
ast_remove_lock_info(t);
}
#endif
+ }
+ if (res) {
__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
filename, line, func, strerror(res));
DO_THREAD_CRASH;
return res;
}
-int __ast_rwlock_tryrdlock(ast_rwlock_t *t, const char *name,
- const char *filename, int line, const char *func)
+int __ast_rwlock_tryrdlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt = &t->track;
+ struct ast_lock_track *lt;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
#endif
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
res = pthread_rwlock_tryrdlock(&t->lock);
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
return res;
}
-int __ast_rwlock_trywrlock(ast_rwlock_t *t, const char *name,
- const char *filename, int line, const char *func)
+int __ast_rwlock_trywrlock(const char *filename, int line, const char *func, ast_rwlock_t *t, const char *name)
{
int res;
#ifdef DEBUG_THREADS
- struct ast_lock_track *lt= &t->track;
+ struct ast_lock_track *lt;
#ifdef HAVE_BKTR
struct ast_bt *bt = NULL;
#endif
}
#endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
+ if (t->tracking && !t->track) {
+ ast_reentrancy_init(&t->track);
+ }
+ lt = t->track;
+
if (t->tracking) {
#ifdef HAVE_BKTR
ast_reentrancy_lock(lt);
res = pthread_rwlock_trywrlock(&t->lock);
#ifdef DEBUG_THREADS
- if (!res) {
+ if (!res && t->tracking) {
ast_reentrancy_lock(lt);
if (lt->reentrancy < AST_MAX_REENTRANCY) {
lt->file[lt->reentrancy] = filename;
lt->reentrancy++;
}
ast_reentrancy_unlock(lt);
- if (t->tracking) {
- ast_mark_lock_acquired(t);
- }
+ ast_mark_lock_acquired(t);
} else if (t->tracking) {
ast_mark_lock_failed(t);
}