[asterisk-commits] tilghman: branch tilghman/issue18194 r303461 - in /team/tilghman/issue18194: ...

SVN commits to the Asterisk project asterisk-commits at lists.digium.com
Mon Jan 24 04:29:08 CST 2011 

Author: tilghman
Date: Mon Jan 24 04:29:04 2011
New Revision: 303461

URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=303461
Log:
Ensure that the reentrancy lock exists in each place where we try to use it.

Modified:
    team/tilghman/issue18194/include/asterisk/lock.h
    team/tilghman/issue18194/main/lock.c

Modified: team/tilghman/issue18194/include/asterisk/lock.h
URL: http://svnview.digium.com/svn/asterisk/team/tilghman/issue18194/include/asterisk/lock.h?view=diff&rev=303461&r1=303460&r2=303461
==============================================================================
--- team/tilghman/issue18194/include/asterisk/lock.h (original)
+++ team/tilghman/issue18194/include/asterisk/lock.h Mon Jan 24 04:29:04 2011
@@ -436,10 +436,15 @@
 	pthread_mutex_unlock(&lt->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;
@@ -459,9 +464,15 @@
 	pthread_mutexattr_destroy(&reentr_attr);
 }
 
-static inline void delete_reentrancy_cs(struct ast_lock_track *lt)
-{
-	pthread_mutex_destroy(&lt->reentr_mutex);
+static inline void delete_reentrancy_cs(struct ast_lock_track **plt)
+{
+	struct ast_lock_track *lt;
+	if (*plt) {
+		lt = *plt;
+		pthread_mutex_destroy(&lt->reentr_mutex);
+		ast_free(lt);
+		*plt = NULL;
+	}
 }
 
 #else /* !DEBUG_THREADS */

Modified: team/tilghman/issue18194/main/lock.c
URL: http://svnview.digium.com/svn/asterisk/team/tilghman/issue18194/main/lock.c?view=diff&rev=303461&r1=303460&r2=303461
==============================================================================
--- team/tilghman/issue18194/main/lock.c (original)
+++ team/tilghman/issue18194/main/lock.c Mon Jan 24 04:29:04 2011
@@ -61,8 +61,7 @@
 
 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
-	ast_reentrancy_init(t->track);
-	t->track = (t->tracking = tracking) ? ast_calloc(1, sizeof(*(t->track))) : NULL;
+	ast_reentrancy_init(&t->track);
 #endif /* DEBUG_THREADS */
 
 	pthread_mutexattr_init(&attr);
@@ -96,6 +95,9 @@
 	}
 #endif
 
+	if (t->tracking && !t->track) {
+		ast_reentrancy_init(&t->track);
+	}
 	lt = t->track;
 
 	res = pthread_mutex_trylock(&t->mutex);
@@ -110,13 +112,15 @@
 	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);
+		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(&lt->backtrace[ROFFSET], canlog);
+#endif
+			ast_reentrancy_unlock(lt);
+		}
 		break;
 	}
 #endif /* DEBUG_THREADS */
@@ -128,19 +132,19 @@
 		__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);
-	ast_free(t->track);
-	t->track = NULL;
+	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(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
+#endif
+		ast_reentrancy_unlock(lt);
+		delete_reentrancy_cs(&t->track);
+	}
 #endif /* DEBUG_THREADS */
 
 	return res;
@@ -152,7 +156,7 @@
 	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;
@@ -173,6 +177,11 @@
 	}
 #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);
@@ -233,7 +242,7 @@
 #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;
@@ -249,7 +258,7 @@
 		if (t->tracking) {
 			ast_mark_lock_acquired(t);
 		}
-	} else {
+	} else if (t->tracking) {
 #ifdef HAVE_BKTR
 		if (lt->reentrancy) {
 			ast_reentrancy_lock(lt);
@@ -258,14 +267,12 @@
 		} else {
 			bt = NULL;
 		}
-		if (t->tracking) {
-			ast_remove_lock_info(t, bt);
-		}
-#else
-		if (t->tracking) {
-			ast_remove_lock_info(t);
-		}
-#endif
+		ast_remove_lock_info(t, bt);
+#else
+		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;
@@ -281,7 +288,7 @@
 	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;
@@ -302,6 +309,11 @@
 	}
 #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);
@@ -320,7 +332,7 @@
 	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;
@@ -350,7 +362,7 @@
 	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;
@@ -369,39 +381,44 @@
 	}
 #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 && !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(&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);
+
 #ifdef HAVE_BKTR
 		ast_remove_lock_info(t, bt);
 #else
@@ -455,7 +472,7 @@
 	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;
@@ -474,39 +491,44 @@
 	}
 #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",
+	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(&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);
-		__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) {
+			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);
+
 #ifdef HAVE_BKTR
 		ast_remove_lock_info(t, bt);
 #else
@@ -522,7 +544,7 @@
 		__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;
@@ -540,13 +562,11 @@
 		}
 		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
-		}
+#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 */
 
@@ -560,7 +580,7 @@
 	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;
@@ -579,38 +599,43 @@
 	}
 #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 && !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(&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);
+
 #ifdef HAVE_BKTR
 		ast_remove_lock_info(t, bt);
 #else
@@ -626,7 +651,7 @@
 		__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;
@@ -644,13 +669,11 @@
 		}
 		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
-		}
+#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 */
 
@@ -663,10 +686,9 @@
 	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 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",
@@ -675,8 +697,9 @@
 	}
 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 
-	ast_reentrancy_init(lt);
-	t->track = (t->tracking = tracking) ? ast_calloc(1, sizeof(*(t->track))) : NULL;
+	if ((t->tracking = tracking)) {
+		ast_reentrancy_init(&t->track);
+	}
 #endif /* DEBUG_THREADS */
 
 	pthread_rwlockattr_init(&attr);
@@ -715,17 +738,19 @@
 		__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);
+	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(&lt->backtrace[0], 0, sizeof(lt->backtrace[0]));
+#endif
+		ast_reentrancy_unlock(lt);
+		delete_reentrancy_cs(&t->track);
+	}
 #endif /* DEBUG_THREADS */
 
 	return res;
@@ -736,7 +761,7 @@
 	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;
@@ -757,40 +782,45 @@
 	}
 #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 = &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;
 				}
-#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) {
+
+		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);
+
 #ifdef HAVE_BKTR
 		ast_remove_lock_info(t, bt);
 #else
@@ -817,7 +847,7 @@
 	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;
@@ -837,6 +867,11 @@
 		}
 	}
 #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
@@ -864,17 +899,19 @@
 				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);
+					if (t->tracking) {
+						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);
@@ -886,7 +923,7 @@
 #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;
@@ -899,7 +936,7 @@
 		if (t->tracking) {
 			ast_mark_lock_acquired(t);
 		}
-	} else {
+	} else if (t->tracking) {
 #ifdef HAVE_BKTR
 		if (lt->reentrancy) {
 			ast_reentrancy_lock(lt);
@@ -908,14 +945,13 @@
 		} else {
 			bt = NULL;
 		}
-		if (t->tracking) {
-			ast_remove_lock_info(t, bt);
-		}
-#else
-		if (t->tracking) {
-			ast_remove_lock_info(t);
-		}
-#endif
+		ast_remove_lock_info(t, bt);
+#else
+		ast_remove_lock_info(t);
+#endif
+	}
+
+	if (res) {
 		__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
 				filename, line, func, strerror(res));
 		DO_THREAD_CRASH;
@@ -930,7 +966,7 @@
 	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;
@@ -950,6 +986,11 @@
 		}
 	}
 #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
@@ -977,17 +1018,19 @@
 				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);
+					if (t->tracking) {
+						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);
@@ -999,7 +1042,7 @@
 #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;
@@ -1012,7 +1055,7 @@
 		if (t->tracking) {
 			ast_mark_lock_acquired(t);
 		}
-	} else {
+	} else if (t->tracking) {
 #ifdef HAVE_BKTR
 		if (lt->reentrancy) {
 			ast_reentrancy_lock(lt);
@@ -1029,6 +1072,8 @@
 			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;
@@ -1044,7 +1089,7 @@
 	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;
@@ -1064,6 +1109,11 @@
 		}
 	}
 #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
@@ -1099,7 +1149,7 @@
 #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;
@@ -1112,7 +1162,7 @@
 		if (t->tracking) {
 			ast_mark_lock_acquired(t);
 		}
-	} else {
+	} else if (t->tracking) {
 #ifdef HAVE_BKTR
 		if (lt->reentrancy) {
 			ast_reentrancy_lock(lt);
@@ -1121,14 +1171,12 @@
 		} else {
 			bt = NULL;
 		}
-		if (t->tracking) {
-			ast_remove_lock_info(t, bt);
-		}
-#else
-		if (t->tracking) {
-			ast_remove_lock_info(t);
-		}
-#endif
+		ast_remove_lock_info(t, bt);
+#else
+		ast_remove_lock_info(t);
+#endif
+	}
+	if (res) {
 		__ast_mutex_logger("%s line %d (%s): Error obtaining read lock: %s\n",
 				filename, line, func, strerror(res));
 		DO_THREAD_CRASH;
@@ -1144,7 +1192,7 @@
 	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;
@@ -1164,6 +1212,11 @@
 		}
 	}
 #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
@@ -1199,7 +1252,7 @@
 #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;
@@ -1212,7 +1265,7 @@
 		if (t->tracking) {
 			ast_mark_lock_acquired(t);
 		}
-	} else {
+	} else if (t->tracking) {
 #ifdef HAVE_BKTR
 		if (lt->reentrancy) {
 			ast_reentrancy_lock(lt);
@@ -1229,6 +1282,8 @@
 			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;
@@ -1243,7 +1298,7 @@
 	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
@@ -1264,6 +1319,11 @@
 	}
 #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);
@@ -1282,7 +1342,7 @@
 	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;
@@ -1308,7 +1368,7 @@
 	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
@@ -1329,6 +1389,11 @@
 	}
 #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);
@@ -1347,7 +1412,7 @@
 	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;
@@ -1357,9 +1422,7 @@
 			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);
 	}

More information about the asterisk-commits mailing list