Call `ChannelMessageHandler::message_received` without peer lock

While `message_received` purports to be called on every message,
prior to the message, doing so on `Init` messages means we have to
call `message_received` while holding the per-peer mutex, which
can cause some lock contention.

Instead, here, we call `message_received` after processing `Init`
messages (which is probably more useful anyway - the peer isn't
really "connected" until we've processed the `Init` messages),
allowing us to call it unlocked.

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 3c0d724ad9423a2b18da59b734dd3e08d4bef287..6f0412ced4295e2ba812e098714fb537b430383a 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -1618,14 +1618,15 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
                let their_node_id = peer_lock.their_node_id.expect("We know the peer's public key by the time we receive messages").0;
                let logger = WithContext::from(&self.logger, Some(their_node_id), None, None);
 
+               let unprocessed_message = self.do_handle_message_holding_peer_lock(peer_lock, message, their_node_id, &logger)?;
+
                self.message_handler.chan_handler.message_received();
-               
-               let message = match self.do_handle_message_holding_peer_lock(peer_lock, message, their_node_id, &logger)? {
-                       Some(processed_message) => processed_message,
-                       None => return Ok(None),
-               };
 
-               self.do_handle_message_without_peer_lock(peer_mutex, message, their_node_id, &logger)
+               if let Some(message) = unprocessed_message {
+                       self.do_handle_message_without_peer_lock(peer_mutex, message, their_node_id, &logger)
+               } else {
+                       Ok(None)
+               }
        }
 
        // Conducts all message processing that requires us to hold the `peer_lock`.