blockmanager_tests.cpp
1 // Copyright (c) 2022 The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <chain.h> 6 #include <chainparams.h> 7 #include <clientversion.h> 8 #include <node/blockstorage.h> 9 #include <node/context.h> 10 #include <node/kernel_notifications.h> 11 #include <script/solver.h> 12 #include <primitives/block.h> 13 #include <util/chaintype.h> 14 #include <validation.h> 15 16 #include <boost/test/unit_test.hpp> 17 #include <test/util/logging.h> 18 #include <test/util/setup_common.h> 19 20 using kernel::CBlockFileInfo; 21 using node::STORAGE_HEADER_BYTES; 22 using node::BlockManager; 23 using node::KernelNotifications; 24 using node::MAX_BLOCKFILE_SIZE; 25 26 // use BasicTestingSetup here for the data directory configuration, setup, and cleanup 27 BOOST_FIXTURE_TEST_SUITE(blockmanager_tests, BasicTestingSetup) 28 29 BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos) 30 { 31 const auto params {CreateChainParams(ArgsManager{}, ChainType::MAIN)}; 32 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)}; 33 const BlockManager::Options blockman_opts{ 34 .chainparams = *params, 35 .blocks_dir = m_args.GetBlocksDirPath(), 36 .notifications = notifications, 37 .block_tree_db_params = DBParams{ 38 .path = m_args.GetDataDirNet() / "blocks" / "index", 39 .cache_bytes = 0, 40 }, 41 }; 42 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts}; 43 // simulate adding a genesis block normally 44 BOOST_CHECK_EQUAL(blockman.WriteBlock(params->GenesisBlock(), 0).nPos, STORAGE_HEADER_BYTES); 45 // simulate what happens during reindex 46 // simulate a well-formed genesis block being found at offset 8 in the blk00000.dat file 47 // the block is found at offset 8 because there is an 8 byte serialization header 48 // consisting of 4 magic bytes + 4 length bytes before each block in a well-formed blk file. 49 const FlatFilePos pos{0, STORAGE_HEADER_BYTES}; 50 blockman.UpdateBlockInfo(params->GenesisBlock(), 0, pos); 51 // now simulate what happens after reindex for the first new block processed 52 // the actual block contents don't matter, just that it's a block. 53 // verify that the write position is at offset 0x12d. 54 // this is a check to make sure that https://github.com/bitcoin/bitcoin/issues/21379 does not recur 55 // 8 bytes (for serialization header) + 285 (for serialized genesis block) = 293 56 // add another 8 bytes for the second block's serialization header and we get 293 + 8 = 301 57 FlatFilePos actual{blockman.WriteBlock(params->GenesisBlock(), 1)}; 58 BOOST_CHECK_EQUAL(actual.nPos, STORAGE_HEADER_BYTES + ::GetSerializeSize(TX_WITH_WITNESS(params->GenesisBlock())) + STORAGE_HEADER_BYTES); 59 } 60 61 BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain100Setup) 62 { 63 // Cap last block file size, and mine new block in a new block file. 64 auto& chainman{*Assert(m_node.chainman)}; 65 auto& blockman{chainman.m_blockman}; 66 const CBlockIndex* old_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())}; 67 WITH_LOCK(chainman.GetMutex(), blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE); 68 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())); 69 70 // Prune the older block file, but don't unlink it 71 int file_number; 72 { 73 LOCK(chainman.GetMutex()); 74 file_number = old_tip->GetBlockPos().nFile; 75 blockman.PruneOneBlockFile(file_number); 76 } 77 78 const FlatFilePos pos(file_number, 0); 79 80 // Check that the file is not unlinked after ScanAndUnlinkAlreadyPrunedFiles 81 // if m_have_pruned is not yet set 82 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles()); 83 BOOST_CHECK(!blockman.OpenBlockFile(pos, true).IsNull()); 84 85 // Check that the file is unlinked after ScanAndUnlinkAlreadyPrunedFiles 86 // once m_have_pruned is set 87 blockman.m_have_pruned = true; 88 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles()); 89 BOOST_CHECK(blockman.OpenBlockFile(pos, true).IsNull()); 90 91 // Check that calling with already pruned files doesn't cause an error 92 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles()); 93 94 // Check that the new tip file has not been removed 95 const CBlockIndex* new_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())}; 96 BOOST_CHECK_NE(old_tip, new_tip); 97 const int new_file_number{WITH_LOCK(chainman.GetMutex(), return new_tip->GetBlockPos().nFile)}; 98 const FlatFilePos new_pos(new_file_number, 0); 99 BOOST_CHECK(!blockman.OpenBlockFile(new_pos, true).IsNull()); 100 } 101 102 BOOST_FIXTURE_TEST_CASE(blockmanager_block_data_availability, TestChain100Setup) 103 { 104 // The goal of the function is to return the first not pruned block in the range [upper_block, lower_block]. 105 LOCK(::cs_main); 106 auto& chainman = m_node.chainman; 107 auto& blockman = chainman->m_blockman; 108 const CBlockIndex& tip = *chainman->ActiveTip(); 109 110 // Function to prune all blocks from 'last_pruned_block' down to the genesis block 111 const auto& func_prune_blocks = [&](CBlockIndex* last_pruned_block) 112 { 113 LOCK(::cs_main); 114 CBlockIndex* it = last_pruned_block; 115 while (it != nullptr && it->nStatus & BLOCK_HAVE_DATA) { 116 it->nStatus &= ~BLOCK_HAVE_DATA; 117 it = it->pprev; 118 } 119 }; 120 121 // 1) Return genesis block when all blocks are available 122 BOOST_CHECK_EQUAL(&blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), chainman->ActiveChain()[0]); 123 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *chainman->ActiveChain()[0])); 124 125 // 2) Check lower_block when all blocks are available 126 CBlockIndex* lower_block = chainman->ActiveChain()[tip.nHeight / 2]; 127 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *lower_block)); 128 129 // Prune half of the blocks 130 int height_to_prune = tip.nHeight / 2; 131 CBlockIndex* first_available_block = chainman->ActiveChain()[height_to_prune + 1]; 132 CBlockIndex* last_pruned_block = first_available_block->pprev; 133 func_prune_blocks(last_pruned_block); 134 135 // 3) The last block not pruned is in-between upper-block and the genesis block 136 BOOST_CHECK_EQUAL(&blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), first_available_block); 137 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *first_available_block)); 138 BOOST_CHECK(!blockman.CheckBlockDataAvailability(tip, *last_pruned_block)); 139 } 140 141 BOOST_FIXTURE_TEST_CASE(blockmanager_readblock_hash_mismatch, TestingSetup) 142 { 143 CBlockIndex index; 144 { 145 LOCK(cs_main); 146 const auto tip{m_node.chainman->ActiveTip()}; 147 index.nStatus = tip->nStatus; 148 index.nDataPos = tip->nDataPos; 149 index.phashBlock = &uint256::ONE; // mismatched block hash 150 } 151 152 ASSERT_DEBUG_LOG("GetHash() doesn't match index"); 153 CBlock block; 154 BOOST_CHECK(!m_node.chainman->m_blockman.ReadBlock(block, index)); 155 } 156 157 BOOST_AUTO_TEST_CASE(blockmanager_flush_block_file) 158 { 159 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)}; 160 node::BlockManager::Options blockman_opts{ 161 .chainparams = Params(), 162 .blocks_dir = m_args.GetBlocksDirPath(), 163 .notifications = notifications, 164 .block_tree_db_params = DBParams{ 165 .path = m_args.GetDataDirNet() / "blocks" / "index", 166 .cache_bytes = 0, 167 }, 168 }; 169 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts}; 170 171 // Test blocks with no transactions, not even a coinbase 172 CBlock block1; 173 block1.nVersion = 1; 174 CBlock block2; 175 block2.nVersion = 2; 176 CBlock block3; 177 block3.nVersion = 3; 178 179 // They are 80 bytes header + 1 byte 0x00 for vtx length 180 constexpr int TEST_BLOCK_SIZE{81}; 181 182 // Blockstore is empty 183 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), 0); 184 185 // Write the first block to a new location. 186 FlatFilePos pos1{blockman.WriteBlock(block1, /*nHeight=*/1)}; 187 188 // Write second block 189 FlatFilePos pos2{blockman.WriteBlock(block2, /*nHeight=*/2)}; 190 191 // Two blocks in the file 192 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + STORAGE_HEADER_BYTES) * 2); 193 194 // First two blocks are written as expected 195 // Errors are expected because block data is junk, thrown AFTER successful read 196 CBlock read_block; 197 BOOST_CHECK_EQUAL(read_block.nVersion, 0); 198 { 199 ASSERT_DEBUG_LOG("Errors in block header"); 200 BOOST_CHECK(!blockman.ReadBlock(read_block, pos1, {})); 201 BOOST_CHECK_EQUAL(read_block.nVersion, 1); 202 } 203 { 204 ASSERT_DEBUG_LOG("Errors in block header"); 205 BOOST_CHECK(!blockman.ReadBlock(read_block, pos2, {})); 206 BOOST_CHECK_EQUAL(read_block.nVersion, 2); 207 } 208 209 // During reindex, the flat file block storage will not be written to. 210 // UpdateBlockInfo will, however, update the blockfile metadata. 211 // Verify this behavior by attempting (and failing) to write block 3 data 212 // to block 2 location. 213 CBlockFileInfo* block_data = blockman.GetBlockFileInfo(0); 214 BOOST_CHECK_EQUAL(block_data->nBlocks, 2); 215 blockman.UpdateBlockInfo(block3, /*nHeight=*/3, /*pos=*/pos2); 216 // Metadata is updated... 217 BOOST_CHECK_EQUAL(block_data->nBlocks, 3); 218 // ...but there are still only two blocks in the file 219 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + STORAGE_HEADER_BYTES) * 2); 220 221 // Block 2 was not overwritten: 222 BOOST_CHECK(!blockman.ReadBlock(read_block, pos2, {})); 223 BOOST_CHECK_EQUAL(read_block.nVersion, 2); 224 } 225 226 BOOST_AUTO_TEST_SUITE_END()