[refactor] interfaces: Add missing LockAnnotation for cs_main

MarcoFalke · MarcoFalke · commit fa3c65114351 · 2019-05-13T14:46:01.000-04:00
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
@@ -114,6 +114,7 @@ void benchmark::BenchRunner::RunAll(Printer& printer, uint64_t num_evals, double
     for (const auto& p : benchmarks()) {
         TestingSetup test{CBaseChainParams::REGTEST};
         {
+            LOCK(cs_main);
             assert(::ChainActive().Height() == 0);
             const bool witness_enabled{IsWitnessEnabled(::ChainActive().Tip(), Params().GetConsensus())};
             assert(witness_enabled);
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
@@ -29,6 +29,7 @@ static void DuplicateInputs(benchmark::State& state)
     CMutableTransaction coinbaseTx{};
     CMutableTransaction naughtyTx{};
 
+    LOCK(cs_main);
     CBlockIndex* pindexPrev = ::ChainActive().Tip();
     assert(pindexPrev != nullptr);
     block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());
diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
@@ -41,6 +41,7 @@ class LockImpl : public Chain::Lock
 {
     Optional<int> getHeight() override
     {
+        LockAnnotation lock(::cs_main);
         int height = ::ChainActive().Height();
         if (height >= 0) {
             return height;
@@ -49,6 +50,7 @@ class LockImpl : public Chain::Lock
     }
     Optional<int> getBlockHeight(const uint256& hash) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = LookupBlockIndex(hash);
         if (block && ::ChainActive().Contains(block)) {
             return block->nHeight;
@@ -63,29 +65,34 @@ class LockImpl : public Chain::Lock
     }
     uint256 getBlockHash(int height) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = ::ChainActive()[height];
         assert(block != nullptr);
         return block->GetBlockHash();
     }
     int64_t getBlockTime(int height) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = ::ChainActive()[height];
         assert(block != nullptr);
         return block->GetBlockTime();
     }
     int64_t getBlockMedianTimePast(int height) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = ::ChainActive()[height];
         assert(block != nullptr);
         return block->GetMedianTimePast();
     }
     bool haveBlockOnDisk(int height) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = ::ChainActive()[height];
         return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
     }
     Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override
     {
+        LockAnnotation lock(::cs_main);
         CBlockIndex* block = ::ChainActive().FindEarliestAtLeast(time, height);
         if (block) {
             if (hash) *hash = block->GetBlockHash();
@@ -95,6 +102,7 @@ class LockImpl : public Chain::Lock
     }
     Optional<int> findPruned(int start_height, Optional<int> stop_height) override
     {
+        LockAnnotation lock(::cs_main);
         if (::fPruneMode) {
             CBlockIndex* block = stop_height ? ::ChainActive()[*stop_height] : ::ChainActive().Tip();
             while (block && block->nHeight >= start_height) {
@@ -108,6 +116,7 @@ class LockImpl : public Chain::Lock
     }
     Optional<int> findFork(const uint256& hash, Optional<int>* height) override
     {
+        LockAnnotation lock(::cs_main);
         const CBlockIndex* block = LookupBlockIndex(hash);
         const CBlockIndex* fork = block ? ::ChainActive().FindFork(block) : nullptr;
         if (height) {
@@ -122,7 +131,11 @@ class LockImpl : public Chain::Lock
         }
         return nullopt;
     }
-    CBlockLocator getTipLocator() override { return ::ChainActive().GetLocator(); }
+    CBlockLocator getTipLocator() override
+    {
+        LockAnnotation lock(::cs_main);
+        return ::ChainActive().GetLocator();
+    }
     Optional<int> findLocatorFork(const CBlockLocator& locator) override
     {
         LockAnnotation lock(::cs_main);
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
@@ -145,6 +145,8 @@ void TestGUI()
     }
     {
         auto locked_chain = wallet->chain().lock();
+        LockAnnotation lock(::cs_main);
+
         WalletRescanReserver reserver(wallet.get());
         reserver.reserve();
         CWallet::ScanResult result = wallet->ScanForWalletTransactions(locked_chain->getBlockHash(0), {} /* stop_block */, reserver, true /* fUpdate */);
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
@@ -8,15 +8,15 @@
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
-#include <validation.h>
 #include <miner.h>
 #include <policy/policy.h>
 #include <pubkey.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
-#include <util/system.h>
 #include <util/strencodings.h>
+#include <util/system.h>
+#include <validation.h>
 
 #include <test/setup_common.h>
 
@@ -82,7 +82,7 @@ struct {
     {2, 0xbbbeb305}, {2, 0xfe1c810a},
 };
 
-static CBlockIndex CreateBlockIndex(int nHeight)
+static CBlockIndex CreateBlockIndex(int nHeight) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     CBlockIndex index;
     index.nHeight = nHeight;
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
@@ -66,26 +66,38 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
 
     // Test 1: block with both of those transactions should be rejected.
     block = CreateAndProcessBlock(spends, scriptPubKey);
-    BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    }
 
     // Test 2: ... and should be rejected if spend1 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[0]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
-    BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    }
     mempool.clear();
 
     // Test 3: ... and should be rejected if spend2 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
-    BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+    }
     mempool.clear();
 
     // Final sanity test: first spend in mempool, second in block, that's OK:
     std::vector<CMutableTransaction> oneSpend;
     oneSpend.push_back(spends[0]);
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(oneSpend, scriptPubKey);
-    BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
+    }
     // spends[1] should have been removed from the mempool when the
     // block with spends[0] is accepted:
     BOOST_CHECK_EQUAL(mempool.size(), 0U);
diff --git a/src/test/util.cpp b/src/test/util.cpp
@@ -84,6 +84,7 @@ std::shared_ptr<CBlock> PrepareBlock(const CScript& coinbase_scriptPubKey)
             .CreateNewBlock(coinbase_scriptPubKey)
             ->block);
 
+    LOCK(cs_main);
     block->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
     block->hashMerkleRoot = BlockMerkleRoot(*block);
 
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
@@ -181,6 +181,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
 
     UnregisterValidationInterface(&sub);
 
+    LOCK(cs_main);
     BOOST_CHECK_EQUAL(sub.m_expected_tip, ::ChainActive().Tip()->GetBlockHash());
 }
 
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -3224,7 +3224,7 @@ std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBloc
 }
 
 //! Returns last CBlockIndex* that is a checkpoint
-static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)
+static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     const MapCheckpoints& checkpoints = data.mapCheckpoints;
 
@@ -3248,7 +3248,7 @@ static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)
  *  in ConnectBlock().
  *  Note that -reindex-chainstate skips the validation that happens here!
  */
-static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& params, const CBlockIndex* pindexPrev, int64_t nAdjustedTime)
+static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& params, const CBlockIndex* pindexPrev, int64_t nAdjustedTime) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
diff --git a/src/validation.h b/src/validation.h
@@ -412,7 +412,7 @@ class CVerifyDB {
 /** Replay blocks that aren't fully applied to the database. */
 bool ReplayBlocks(const CChainParams& params, CCoinsView* view);
 
-inline CBlockIndex* LookupBlockIndex(const uint256& hash)
+inline CBlockIndex* LookupBlockIndex(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     AssertLockHeld(cs_main);
     BlockMap::const_iterator it = mapBlockIndex.find(hash);
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
@@ -12,12 +12,12 @@
 
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
+#include <policy/policy.h>
 #include <rpc/server.h>
 #include <test/setup_common.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/test/wallet_test_fixture.h>
-#include <policy/policy.h>
 
 #include <boost/test/unit_test.hpp>
 #include <univalue.h>
@@ -36,16 +36,15 @@ static void AddKey(CWallet& wallet, const CKey& key)
 
 BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 {
-    auto chain = interfaces::MakeChain();
-
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex* oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex* newTip = ::ChainActive().Tip();
 
-    LockAnnotation lock(::cs_main);
+    auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
+    LockAnnotation lock(::cs_main);
 
     // Verify ScanForWalletTransactions accommodates a null start block.
     {
@@ -116,16 +115,15 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
 
 BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
 {
-    auto chain = interfaces::MakeChain();
-
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex* oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex* newTip = ::ChainActive().Tip();
 
-    LockAnnotation lock(::cs_main);
+    auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
+    LockAnnotation lock(::cs_main);
 
     // Prune the older block file.
     PruneOneBlockFile(oldTip->GetBlockPos().nFile);
@@ -177,8 +175,6 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
 // than or equal to key birthday.
 BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 {
-    auto chain = interfaces::MakeChain();
-
     // Create two blocks with same timestamp to verify that importwallet rescan
     // will pick up both blocks, not just the first.
     const int64_t BLOCK_TIME = ::ChainActive().Tip()->GetBlockTimeMax() + 5;
@@ -192,7 +188,9 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
     SetMockTime(KEY_TIME);
     m_coinbase_txns.emplace_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
 
+    auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
+    LockAnnotation lock(::cs_main);
 
     std::string backup_file = (SetDataDir("importwallet_rescan") / "wallet.backup").string();
 
@@ -245,10 +243,14 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
 BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
 {
     auto chain = interfaces::MakeChain();
+
     CWallet wallet(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
+
     auto locked_chain = chain->lock();
+    LockAnnotation lock(::cs_main);
     LOCK(wallet.cs_wallet);
+
     wtx.hashBlock = ::ChainActive().Tip()->GetBlockHash();
     wtx.nIndex = 0;
 
@@ -375,6 +377,8 @@ class ListCoinsTestingSetup : public TestChain100Setup
             blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).tx);
         }
         CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+
+        LOCK(cs_main);
         LOCK(wallet->cs_wallet);
         auto it = wallet->mapWallet.find(tx->GetHash());
         BOOST_CHECK(it != wallet->mapWallet.end());

Original file line number	Diff line number	Diff line change
`@@ -114,6 +114,7 @@ void benchmark::BenchRunner::RunAll(Printer& printer, uint64_t num_evals, double`
`114`	`114`	`for (const auto& p : benchmarks()) {`
`115`	`115`	`TestingSetup test{CBaseChainParams::REGTEST};`
`116`	`116`	`{`
	`117`	`+ LOCK(cs_main);`
`117`	`118`	`assert(::ChainActive().Height() == 0);`
`118`	`119`	`const bool witness_enabled{IsWitnessEnabled(::ChainActive().Tip(), Params().GetConsensus())};`
`119`	`120`	`assert(witness_enabled);`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ class LockImpl : public Chain::Lock`
`41`	`41`	`{`
`42`	`42`	`Optional<int> getHeight() override`
`43`	`43`	`{`
	`44`	`+ LockAnnotation lock(::cs_main);`
`44`	`45`	`int height = ::ChainActive().Height();`
`45`	`46`	`if (height >= 0) {`
`46`	`47`	`return height;`
`@@ -49,6 +50,7 @@ class LockImpl : public Chain::Lock`
`49`	`50`	`}`
`50`	`51`	`Optional<int> getBlockHeight(const uint256& hash) override`
`51`	`52`	`{`
	`53`	`+ LockAnnotation lock(::cs_main);`
`52`	`54`	`CBlockIndex* block = LookupBlockIndex(hash);`
`53`	`55`	`if (block && ::ChainActive().Contains(block)) {`
`54`	`56`	`return block->nHeight;`
`@@ -63,29 +65,34 @@ class LockImpl : public Chain::Lock`
`63`	`65`	`}`
`64`	`66`	`uint256 getBlockHash(int height) override`
`65`	`67`	`{`
	`68`	`+ LockAnnotation lock(::cs_main);`
`66`	`69`	`CBlockIndex* block = ::ChainActive()[height];`
`67`	`70`	`assert(block != nullptr);`
`68`	`71`	`return block->GetBlockHash();`
`69`	`72`	`}`
`70`	`73`	`int64_t getBlockTime(int height) override`
`71`	`74`	`{`
	`75`	`+ LockAnnotation lock(::cs_main);`
`72`	`76`	`CBlockIndex* block = ::ChainActive()[height];`
`73`	`77`	`assert(block != nullptr);`
`74`	`78`	`return block->GetBlockTime();`
`75`	`79`	`}`
`76`	`80`	`int64_t getBlockMedianTimePast(int height) override`
`77`	`81`	`{`
	`82`	`+ LockAnnotation lock(::cs_main);`
`78`	`83`	`CBlockIndex* block = ::ChainActive()[height];`
`79`	`84`	`assert(block != nullptr);`
`80`	`85`	`return block->GetMedianTimePast();`
`81`	`86`	`}`
`82`	`87`	`bool haveBlockOnDisk(int height) override`
`83`	`88`	`{`
	`89`	`+ LockAnnotation lock(::cs_main);`
`84`	`90`	`CBlockIndex* block = ::ChainActive()[height];`
`85`	`91`	`return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;`
`86`	`92`	`}`
`87`	`93`	`Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override`
`88`	`94`	`{`
	`95`	`+ LockAnnotation lock(::cs_main);`
`89`	`96`	`CBlockIndex* block = ::ChainActive().FindEarliestAtLeast(time, height);`
`90`	`97`	`if (block) {`
`91`	`98`	`if (hash) *hash = block->GetBlockHash();`
`@@ -95,6 +102,7 @@ class LockImpl : public Chain::Lock`
`95`	`102`	`}`
`96`	`103`	`Optional<int> findPruned(int start_height, Optional<int> stop_height) override`
`97`	`104`	`{`
	`105`	`+ LockAnnotation lock(::cs_main);`
`98`	`106`	`if (::fPruneMode) {`
`99`	`107`	`CBlockIndex* block = stop_height ? ::ChainActive()[*stop_height] : ::ChainActive().Tip();`
`100`	`108`	`while (block && block->nHeight >= start_height) {`
`@@ -108,6 +116,7 @@ class LockImpl : public Chain::Lock`
`108`	`116`	`}`
`109`	`117`	`Optional<int> findFork(const uint256& hash, Optional<int>* height) override`
`110`	`118`	`{`
	`119`	`+ LockAnnotation lock(::cs_main);`
`111`	`120`	`const CBlockIndex* block = LookupBlockIndex(hash);`
`112`	`121`	`const CBlockIndex* fork = block ? ::ChainActive().FindFork(block) : nullptr;`
`113`	`122`	`if (height) {`
`@@ -122,7 +131,11 @@ class LockImpl : public Chain::Lock`
`122`	`131`	`}`
`123`	`132`	`return nullopt;`
`124`	`133`	`}`
`125`		`- CBlockLocator getTipLocator() override { return ::ChainActive().GetLocator(); }`
	`134`	`+ CBlockLocator getTipLocator() override`
	`135`	`+ {`
	`136`	`+ LockAnnotation lock(::cs_main);`
	`137`	`+ return ::ChainActive().GetLocator();`
	`138`	`+ }`
`126`	`139`	`Optional<int> findLocatorFork(const CBlockLocator& locator) override`
`127`	`140`	`{`
`128`	`141`	`LockAnnotation lock(::cs_main);`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,8 @@ void TestGUI()`
`145`	`145`	`}`
`146`	`146`	`{`
`147`	`147`	`auto locked_chain = wallet->chain().lock();`
	`148`	`+ LockAnnotation lock(::cs_main);`
	`149`	`+`
`148`	`150`	`WalletRescanReserver reserver(wallet.get());`
`149`	`151`	`reserver.reserve();`
`150`	`152`	`CWallet::ScanResult result = wallet->ScanForWalletTransactions(locked_chain->getBlockHash(0), {} /* stop_block /, reserver, true / fUpdate */);`
Original file line number	Diff line number	Diff line change
`@@ -181,6 +181,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)`
`181`	`181`
`182`	`182`	`UnregisterValidationInterface(&sub);`
`183`	`183`
	`184`	`+ LOCK(cs_main);`
`184`	`185`	`BOOST_CHECK_EQUAL(sub.m_expected_tip, ::ChainActive().Tip()->GetBlockHash());`
`185`	`186`	`}`
`186`	`187`
Original file line number	Diff line number	Diff line change
`@@ -3224,7 +3224,7 @@ std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBloc`
`3224`	`3224`	`}`
`3225`	`3225`
`3226`	`3226`	`//! Returns last CBlockIndex* that is a checkpoint`
`3227`		`-static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)`
	`3227`	`+static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data) EXCLUSIVE_LOCKS_REQUIRED(cs_main)`
`3228`	`3228`	`{`
`3229`	`3229`	`const MapCheckpoints& checkpoints = data.mapCheckpoints;`
`3230`	`3230`
`@@ -3248,7 +3248,7 @@ static CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)`
`3248`	`3248`	`* in ConnectBlock().`
`3249`	`3249`	`* Note that -reindex-chainstate skips the validation that happens here!`
`3250`	`3250`	`*/`
`3251`		`-static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& params, const CBlockIndex* pindexPrev, int64_t nAdjustedTime)`
	`3251`	`+static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& params, const CBlockIndex* pindexPrev, int64_t nAdjustedTime) EXCLUSIVE_LOCKS_REQUIRED(cs_main)`
`3252`	`3252`	`{`
`3253`	`3253`	`assert(pindexPrev != nullptr);`
`3254`	`3254`	`const int nHeight = pindexPrev->nHeight + 1;`
Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ class CVerifyDB {`
`412`	`412`	`/** Replay blocks that aren't fully applied to the database. */`
`413`	`413`	`bool ReplayBlocks(const CChainParams& params, CCoinsView* view);`
`414`	`414`
`415`		`-inline CBlockIndex* LookupBlockIndex(const uint256& hash)`
	`415`	`+inline CBlockIndex* LookupBlockIndex(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)`
`416`	`416`	`{`
`417`	`417`	`AssertLockHeld(cs_main);`
`418`	`418`	`BlockMap::const_iterator it = mapBlockIndex.find(hash);`