Cleanup ChannelManager::write lockorder

Author: ViktorTigerstrom

lightning/src/ln/channelmanager.rs

@@ -6600,46 +6600,44 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable f
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		let _consistency_lock = self.total_consistency_lock.write().unwrap();
 
+		let forward_htlcs = self.forward_htlcs.lock().unwrap();
+		let channel_state = self.channel_state.lock().unwrap();
+		let per_peer_state = self.per_peer_state.write().unwrap();
+		let peer_states = per_peer_state.iter().map(|(peer_pubkey, peer_state_mutex)| (peer_pubkey, peer_state_mutex.lock().unwrap())).collect::<Vec<(&PublicKey, MutexGuard<'_, PeerState>)>>();
+		let pending_inbound_payments = self.pending_inbound_payments.lock().unwrap();
+		let pending_outbound_payments = self.pending_outbound_payments.lock().unwrap();
+		let best_block = self.best_block.write().unwrap();
+		let events = self.pending_events.lock().unwrap();
+		let background_events = self.pending_background_events.lock().unwrap();
+
 		write_ver_prefix!(writer, SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
 
 		self.genesis_hash.write(writer)?;
-		{
-			let best_block = self.best_block.read().unwrap();
-			best_block.height().write(writer)?;
-			best_block.block_hash().write(writer)?;
-		}
+		best_block.height().write(writer)?;
+		best_block.block_hash().write(writer)?;
 
-		{
-			// Take `channel_state` lock temporarily to avoid creating a lock order that requires
-			// that the `forward_htlcs` lock is taken after `channel_state`
-			let channel_state = self.channel_state.lock().unwrap();
-			let mut unfunded_channels = 0;
-			for (_, channel) in channel_state.by_id.iter() {
-				if !channel.is_funding_initiated() {
-					unfunded_channels += 1;
-				}
+		let mut unfunded_channels = 0;
+		for (_, channel) in channel_state.by_id.iter() {
+			if !channel.is_funding_initiated() {
+				unfunded_channels += 1;
 			}
-			((channel_state.by_id.len() - unfunded_channels) as u64).write(writer)?;
-			for (_, channel) in channel_state.by_id.iter() {
-				if channel.is_funding_initiated() {
-					channel.write(writer)?;
-				}
+		}
+		((channel_state.by_id.len() - unfunded_channels) as u64).write(writer)?;
+		for (_, channel) in channel_state.by_id.iter() {
+			if channel.is_funding_initiated() {
+				channel.write(writer)?;
 			}
 		}
 
-		{
-			let forward_htlcs = self.forward_htlcs.lock().unwrap();
-			(forward_htlcs.len() as u64).write(writer)?;
-			for (short_channel_id, pending_forwards) in forward_htlcs.iter() {
-				short_channel_id.write(writer)?;
-				(pending_forwards.len() as u64).write(writer)?;
-				for forward in pending_forwards {
-					forward.write(writer)?;
-				}
+		(forward_htlcs.len() as u64).write(writer)?;
+		for (short_channel_id, pending_forwards) in forward_htlcs.iter() {
+			short_channel_id.write(writer)?;
+			(pending_forwards.len() as u64).write(writer)?;
+			for forward in pending_forwards {
+				forward.write(writer)?;
 			}
 		}
 
-		let channel_state = self.channel_state.lock().unwrap();
 		let mut htlc_purposes: Vec<&events::PaymentPurpose> = Vec::new();
 		(channel_state.claimable_htlcs.len() as u64).write(writer)?;
 		for (payment_hash, (purpose, previous_hops)) in channel_state.claimable_htlcs.iter() {
@@ -6651,23 +6649,17 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable f
 			htlc_purposes.push(purpose);
 		}
 
-		let per_peer_state = self.per_peer_state.write().unwrap();
 		(per_peer_state.len() as u64).write(writer)?;
-		for (peer_pubkey, peer_state_mutex) in per_peer_state.iter() {
+		for (peer_pubkey, peer_state) in peer_states.iter() {
 			peer_pubkey.write(writer)?;
-			let peer_state = peer_state_mutex.lock().unwrap();
 			peer_state.latest_features.write(writer)?;
 		}
 
-		let pending_inbound_payments = self.pending_inbound_payments.lock().unwrap();
-		let pending_outbound_payments = self.pending_outbound_payments.lock().unwrap();
-		let events = self.pending_events.lock().unwrap();
 		(events.len() as u64).write(writer)?;
 		for event in events.iter() {
 			event.write(writer)?;
 		}
 
-		let background_events = self.pending_background_events.lock().unwrap();
 		(background_events.len() as u64).write(writer)?;
 		for event in background_events.iter() {
 			match event {