f some sp, some stupid missing code, more docs

Author: TheBlueMatt

lightning/src/debug_sync.rs

@@ -16,7 +16,7 @@ use std::sync::RwLockWriteGuard as StdRwLockWriteGuard;
 use std::sync::Condvar as StdCondvar;
 
 #[cfg(feature = "backtrace")]
-use {prelude::HashMap, backtrace::Backtrace, std::sync::Once};
+use {prelude::{HashMap, hash_map}, backtrace::Backtrace, std::sync::Once};
 
 #[cfg(not(feature = "backtrace"))]
 struct Backtrace{}
@@ -111,6 +111,9 @@ impl LockMetadata {
 			let sync_mutex_constr_regex = regex::Regex::new(r"lightning.*debug_sync.*new").unwrap();
 			let mut found_debug_sync = false;
 			for frame in backtrace.frames() {
+				// If a constructor was inlined we should take the frame in which it was inlined
+				// (as its specific to the callsite), thus we look at the last available symbol,
+				// which the `backtrace` docs say will be the caller.
 				let symbol_name = frame.symbols().last().unwrap().name().unwrap().as_str().unwrap();
 				if !sync_mutex_constr_regex.is_match(symbol_name) {
 					if found_debug_sync {
@@ -126,11 +129,21 @@ impl LockMetadata {
 			}
 		}
 
-		Arc::new(LockMetadata {
+		let res = Arc::new(LockMetadata {
 			locked_before: StdMutex::new(HashSet::new()),
 			lock_idx,
 			lock_construction_bt: backtrace,
-		})
+		});
+
+		#[cfg(feature = "backtrace")]
+		{
+			let mut locks = unsafe { LOCKS.as_ref() }.unwrap().lock().unwrap();
+			match locks.entry(lock_idx) {
+				hash_map::Entry::Occupied(e) => return Arc::clone(e.get()),
+				hash_map::Entry::Vacant(e) => { e.insert(Arc::clone(&res)); },
+			}
+		}
+		res
 	}
 
 	// Returns whether we were a recursive lock (only relevant for read)
@@ -150,7 +163,7 @@ impl LockMetadata {
 				if !read && *locked == *this {
 					// With `feature = "backtrace"` set, we may be looking at different instances
 					// of the same lock.
-					debug_assert!(cfg!(feature = "backtrace"), "Tried to lock a lock while it was held!");
+					debug_assert!(cfg!(feature = "backtrace"), "Tried to acquire a lock while it was held!");
 				}
 				for locked_dep in locked.locked_before.lock().unwrap().iter() {
 					if locked_dep.lock == *this && locked_dep.lock != *locked {
@@ -409,7 +422,7 @@ mod tests {
 	}
 
 	#[test]
-	fn read_recurisve_no_lockorder() {
+	fn read_recursive_no_lockorder() {
 		// Like the above, but note that no lockorder is implied when we recursively read-lock a
 		// RwLock, causing this to pass just fine.
 		let a = RwLock::new(());