[net processing] Move block inventory data to Peer

Summary:
Partial backport of [[bitcoin/bitcoin#19829 | core#19829]]:
bitcoin/bitcoin@53b7ac1

Ref T1696.

Depends on D10867.

Test Plan:
  ninja all check-all

Reviewers: #bitcoin_abc, PiRK

Reviewed By: #bitcoin_abc, PiRK

Maniphest Tasks: T1696

Differential Revision: https://reviews.bitcoinabc.org/D10868

Author: jnewbery

src/net.h

@@ -1106,12 +1106,6 @@ class CNode {
     std::chrono::microseconds
         m_next_local_addr_send GUARDED_BY(cs_sendProcessing){0};
 
-    // List of block ids we still have to announce.
-    // There is no final sorting before sending, as they are always sent
-    // immediately and in the order requested.
-    std::vector<BlockHash> vInventoryBlockToSend GUARDED_BY(cs_inventory);
-    Mutex cs_inventory;
-
     struct TxRelay {
         mutable RecursiveMutex cs_filter;
         // We use fRelayTxes for two purposes -
@@ -1212,9 +1206,6 @@ class CNode {
     // m_avalanche_state == nullptr if we're not using avalanche with this peer
     std::unique_ptr<AvalancheState> m_avalanche_state;
 
-    // Used for headers announcements - unfiltered blocks to relay
-    std::vector<BlockHash> vBlockHashesToAnnounce GUARDED_BY(cs_inventory);
-
     /**
      * UNIX epoch time of the last block received from this peer that we had
      * not yet seen (e.g. not already received from another peer), that passed

src/net_processing.cpp

@@ -1722,13 +1722,17 @@ void PeerManager::UpdatedBlockTip(const CBlockIndex *pindexNew,
         }
     }
 
-    // Relay to all peers
-    m_connman.ForEachNode([&vHashes](CNode *pnode) {
-        LOCK(pnode->cs_inventory);
-        for (const BlockHash &hash : reverse_iterate(vHashes)) {
-            pnode->vBlockHashesToAnnounce.push_back(hash);
+    {
+        LOCK(m_peer_mutex);
+        for (auto &it : m_peer_map) {
+            Peer &peer = *it.second;
+            LOCK(peer.m_block_inv_mutex);
+            for (const BlockHash &hash : reverse_iterate(vHashes)) {
+                peer.vBlockHashesToAnnounce.push_back(hash);
+            }
         }
-    });
+    }
+
     m_connman.WakeMessageHandler();
 }
 
@@ -3519,8 +3523,9 @@ void PeerManager::ProcessMessage(const Config &config, CNode &pfrom,
                     pindex->nHeight, pindex->GetBlockHash().ToString());
                 break;
             }
-            WITH_LOCK(pfrom.cs_inventory, pfrom.vInventoryBlockToSend.push_back(
-                                              pindex->GetBlockHash()));
+            WITH_LOCK(
+                peer->m_block_inv_mutex,
+                peer->vInventoryBlockToSend.push_back(pindex->GetBlockHash()));
             if (--nLimit <= 0) {
                 // When this block is requested, we'll send an inv that'll
                 // trigger the peer to getblocks the next batch of inventory.
@@ -5382,13 +5387,13 @@ bool PeerManager::SendMessages(const Config &config, CNode *pto,
             // connect, and send. If no header would connect, or if we have too
             // many blocks, or if the peer doesn't want headers, just add all to
             // the inv queue.
-            LOCK(pto->cs_inventory);
+            LOCK(peer->m_block_inv_mutex);
             std::vector<CBlock> vHeaders;
             bool fRevertToInv =
                 ((!state.fPreferHeaders &&
                   (!state.fPreferHeaderAndIDs ||
-                   pto->vBlockHashesToAnnounce.size() > 1)) ||
-                 pto->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE);
+                   peer->vBlockHashesToAnnounce.size() > 1)) ||
+                 peer->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE);
             // last header queued for delivery
             const CBlockIndex *pBestIndex = nullptr;
             // ensure pindexBestKnownBlock is up-to-date
@@ -5399,7 +5404,7 @@ bool PeerManager::SendMessages(const Config &config, CNode *pto,
                 // Try to find first header that our peer doesn't have, and then
                 // send all headers past that one. If we come across an headers
                 // that aren't on ::ChainActive(), give up.
-                for (const BlockHash &hash : pto->vBlockHashesToAnnounce) {
+                for (const BlockHash &hash : peer->vBlockHashesToAnnounce) {
                     const CBlockIndex *pindex = LookupBlockIndex(hash);
                     assert(pindex);
                     if (::ChainActive()[pindex->nHeight] != pindex) {
@@ -5505,9 +5510,9 @@ bool PeerManager::SendMessages(const Config &config, CNode *pto,
                 // If falling back to using an inv, just try to inv the tip. The
                 // last entry in vBlockHashesToAnnounce was our tip at some
                 // point in the past.
-                if (!pto->vBlockHashesToAnnounce.empty()) {
+                if (!peer->vBlockHashesToAnnounce.empty()) {
                     const BlockHash &hashToAnnounce =
-                        pto->vBlockHashesToAnnounce.back();
+                        peer->vBlockHashesToAnnounce.back();
                     const CBlockIndex *pindex =
                         LookupBlockIndex(hashToAnnounce);
                     assert(pindex);
@@ -5525,14 +5530,14 @@ bool PeerManager::SendMessages(const Config &config, CNode *pto,
 
                     // If the peer's chain has this block, don't inv it back.
                     if (!PeerHasHeader(&state, pindex)) {
-                        pto->vInventoryBlockToSend.push_back(hashToAnnounce);
+                        peer->vInventoryBlockToSend.push_back(hashToAnnounce);
                         LogPrint(BCLog::NET,
                                  "%s: sending inv peer=%d hash=%s\n", __func__,
                                  pto->GetId(), hashToAnnounce.ToString());
                     }
                 }
             }
-            pto->vBlockHashesToAnnounce.clear();
+            peer->vBlockHashesToAnnounce.clear();
         }
     } // release cs_main
 
@@ -5550,17 +5555,17 @@ bool PeerManager::SendMessages(const Config &config, CNode *pto,
     };
 
     {
-        LOCK2(cs_main, pto->cs_inventory);
+        LOCK2(cs_main, peer->m_block_inv_mutex);
 
-        vInv.reserve(std::max<size_t>(pto->vInventoryBlockToSend.size(),
+        vInv.reserve(std::max<size_t>(peer->vInventoryBlockToSend.size(),
                                       INVENTORY_BROADCAST_MAX_PER_MB *
                                           config.GetMaxBlockSize() / 1000000));
 
         // Add blocks
-        for (const BlockHash &hash : pto->vInventoryBlockToSend) {
+        for (const BlockHash &hash : peer->vInventoryBlockToSend) {
             addInvAndMaybeFlush(MSG_BLOCK, hash);
         }
-        pto->vInventoryBlockToSend.clear();
+        peer->vInventoryBlockToSend.clear();
 
         auto computeNextInvSendTime =
             [&](std::chrono::microseconds &next) -> bool {

src/net_processing.h

@@ -75,6 +75,21 @@ struct Peer {
      * (unless it has the noban permission). */
     bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};
 
+    /** Protects block inventory data members */
+    Mutex m_block_inv_mutex;
+    /**
+     * List of blocks that we'll anounce via an `inv` message.
+     * There is no final sorting before sending, as they are always sent
+     * immediately and in the order requested.
+     */
+    std::vector<BlockHash> vInventoryBlockToSend GUARDED_BY(m_block_inv_mutex);
+    /**
+     * Unfiltered list of blocks that we'd like to announce via a `headers`
+     * message. If we can't announce via a `headers` message, we'll fall back to
+     * announcing via `inv`.
+     */
+    std::vector<BlockHash> vBlockHashesToAnnounce GUARDED_BY(m_block_inv_mutex);
+
     /** This peer's reported block height when we connected */
     std::atomic<int> m_starting_height{-1};