blockmanager_tests.cpp raw
1 // Copyright (c) 2022-present 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/common.h>
18 #include <test/util/logging.h>
19 #include <test/util/setup_common.h>
20
21 using kernel::CBlockFileInfo;
22 using node::STORAGE_HEADER_BYTES;
23 using node::BlockManager;
24 using node::KernelNotifications;
25 using node::MAX_BLOCKFILE_SIZE;
26
27 // use BasicTestingSetup here for the data directory configuration, setup, and cleanup
28 BOOST_FIXTURE_TEST_SUITE(blockmanager_tests, BasicTestingSetup)
29
30 BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos)
31 {
32 const auto params {CreateChainParams(ArgsManager{}, ChainType::MAIN)};
33 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)};
34 const BlockManager::Options blockman_opts{
35 .chainparams = *params,
36 .blocks_dir = m_args.GetBlocksDirPath(),
37 .notifications = notifications,
38 .block_tree_db_params = DBParams{
39 .path = m_args.GetDataDirNet() / "blocks" / "index",
40 .cache_bytes = 0,
41 },
42 };
43 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts};
44 // simulate adding a genesis block normally
45 LOCK(::cs_main);
46 BOOST_CHECK_EQUAL(blockman.WriteBlock(params->GenesisBlock(), 0).nPos, STORAGE_HEADER_BYTES);
47 // simulate what happens during reindex
48 // simulate a well-formed genesis block being found at offset 8 in the blk00000.dat file
49 // the block is found at offset 8 because there is an 8 byte serialization header
50 // consisting of 4 magic bytes + 4 length bytes before each block in a well-formed blk file.
51 const FlatFilePos pos{0, STORAGE_HEADER_BYTES};
52 blockman.UpdateBlockInfo(params->GenesisBlock(), 0, pos);
53 // now simulate what happens after reindex for the first new block processed
54 // the actual block contents don't matter, just that it's a block.
55 // verify that the write position is at offset 0x12d.
56 // this is a check to make sure that https://github.com/bitcoin/bitcoin/issues/21379 does not recur
57 // 8 bytes (for serialization header) + 285 (for serialized genesis block) = 293
58 // add another 8 bytes for the second block's serialization header and we get 293 + 8 = 301
59 FlatFilePos actual{blockman.WriteBlock(params->GenesisBlock(), 1)};
60 BOOST_CHECK_EQUAL(actual.nPos, STORAGE_HEADER_BYTES + ::GetSerializeSize(TX_WITH_WITNESS(params->GenesisBlock())) + STORAGE_HEADER_BYTES);
61 }
62
63 BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain100Setup)
64 {
65 // Cap last block file size, and mine new block in a new block file.
66 auto& chainman{*Assert(m_node.chainman)};
67 auto& blockman{chainman.m_blockman};
68 const CBlockIndex* old_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())};
69 WITH_LOCK(chainman.GetMutex(), blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
70 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
71
72 // Prune the older block file, but don't unlink it
73 int file_number;
74 {
75 LOCK(chainman.GetMutex());
76 file_number = old_tip->GetBlockPos().nFile;
77 blockman.PruneOneBlockFile(file_number);
78 }
79
80 const FlatFilePos pos(file_number, 0);
81
82 // Check that the file is not unlinked after ScanAndUnlinkAlreadyPrunedFiles
83 // if m_have_pruned is not yet set
84 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
85 BOOST_CHECK(!blockman.OpenBlockFile(pos, true).IsNull());
86
87 // Check that the file is unlinked after ScanAndUnlinkAlreadyPrunedFiles
88 // once m_have_pruned is set
89 blockman.m_have_pruned = true;
90 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
91 BOOST_CHECK(blockman.OpenBlockFile(pos, true).IsNull());
92
93 // Check that calling with already pruned files doesn't cause an error
94 WITH_LOCK(chainman.GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
95
96 // Check that the new tip file has not been removed
97 const CBlockIndex* new_tip{WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip())};
98 BOOST_CHECK_NE(old_tip, new_tip);
99 const int new_file_number{WITH_LOCK(chainman.GetMutex(), return new_tip->GetBlockPos().nFile)};
100 const FlatFilePos new_pos(new_file_number, 0);
101 BOOST_CHECK(!blockman.OpenBlockFile(new_pos, true).IsNull());
102 }
103
104 BOOST_FIXTURE_TEST_CASE(blockmanager_block_data_availability, TestChain100Setup)
105 {
106 // The goal of the function is to return the first not pruned block in the range [upper_block, lower_block].
107 LOCK(::cs_main);
108 auto& chainman = m_node.chainman;
109 auto& blockman = chainman->m_blockman;
110 const CBlockIndex& tip = *chainman->ActiveTip();
111
112 // Function to prune all blocks from 'last_pruned_block' down to the genesis block
113 const auto& func_prune_blocks = [&](CBlockIndex* last_pruned_block)
114 {
115 LOCK(::cs_main);
116 CBlockIndex* it = last_pruned_block;
117 while (it != nullptr && it->nStatus & BLOCK_HAVE_DATA) {
118 it->nStatus &= ~BLOCK_HAVE_DATA;
119 it = it->pprev;
120 }
121 };
122
123 // 1) Return genesis block when all blocks are available
124 BOOST_CHECK_EQUAL(&blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), chainman->ActiveChain()[0]);
125 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *chainman->ActiveChain()[0]));
126
127 // 2) Check lower_block when all blocks are available
128 CBlockIndex* lower_block = chainman->ActiveChain()[tip.nHeight / 2];
129 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *lower_block));
130
131 // Ensure we don't fail due to the expected absence of undo data in the genesis block
132 CBlockIndex* upper_block = chainman->ActiveChain()[2];
133 CBlockIndex* genesis = chainman->ActiveChain()[0];
134 BOOST_CHECK(blockman.CheckBlockDataAvailability(*upper_block, *genesis, BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO}));
135 // Ensure we detect absence of undo data in the first block
136 chainman->ActiveChain()[1]->nStatus &= ~BLOCK_HAVE_UNDO;
137 BOOST_CHECK(!blockman.CheckBlockDataAvailability(tip, *genesis, BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO}));
138
139 // Prune half of the blocks
140 int height_to_prune = tip.nHeight / 2;
141 CBlockIndex* first_available_block = chainman->ActiveChain()[height_to_prune + 1];
142 CBlockIndex* last_pruned_block = first_available_block->pprev;
143 func_prune_blocks(last_pruned_block);
144
145 // 3) The last block not pruned is in-between upper-block and the genesis block
146 BOOST_CHECK_EQUAL(&blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), first_available_block);
147 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *first_available_block));
148 BOOST_CHECK(!blockman.CheckBlockDataAvailability(tip, *last_pruned_block));
149
150 // Simulate that the first available block is missing undo data and
151 // detect this by using a status mask.
152 first_available_block->nStatus &= ~BLOCK_HAVE_UNDO;
153 BOOST_CHECK(!blockman.CheckBlockDataAvailability(tip, *first_available_block, BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO}));
154 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *first_available_block, BlockStatus{BLOCK_HAVE_DATA}));
155 }
156
157 BOOST_FIXTURE_TEST_CASE(blockmanager_block_data_part, TestChain100Setup)
158 {
159 LOCK(::cs_main);
160 auto& chainman{m_node.chainman};
161 auto& blockman{chainman->m_blockman};
162 const CBlockIndex& tip{*chainman->ActiveTip()};
163 const FlatFilePos tip_block_pos{tip.GetBlockPos()};
164
165 auto block{blockman.ReadRawBlock(tip_block_pos)};
166 BOOST_REQUIRE(block);
167 BOOST_REQUIRE_GE(block->size(), 200);
168
169 const auto expect_part{[&](size_t offset, size_t size) {
170 auto res{blockman.ReadRawBlock(tip_block_pos, std::pair{offset, size})};
171 BOOST_CHECK(res);
172 const auto& part{res.value()};
173 BOOST_CHECK_EQUAL_COLLECTIONS(part.begin(), part.end(), block->begin() + offset, block->begin() + offset + size);
174 }};
175
176 expect_part(0, 20);
177 expect_part(0, block->size() - 1);
178 expect_part(0, block->size() - 10);
179 expect_part(0, block->size());
180 expect_part(1, block->size() - 1);
181 expect_part(10, 20);
182 expect_part(block->size() - 1, 1);
183 }
184
185 BOOST_FIXTURE_TEST_CASE(blockmanager_block_data_part_error, TestChain100Setup)
186 {
187 LOCK(::cs_main);
188 auto& chainman{m_node.chainman};
189 auto& blockman{chainman->m_blockman};
190 const CBlockIndex& tip{*chainman->ActiveTip()};
191 const FlatFilePos tip_block_pos{tip.GetBlockPos()};
192
193 auto block{blockman.ReadRawBlock(tip_block_pos)};
194 BOOST_REQUIRE(block);
195 BOOST_REQUIRE_GE(block->size(), 200);
196
197 const auto expect_part_error{[&](size_t offset, size_t size) {
198 auto res{blockman.ReadRawBlock(tip_block_pos, std::pair{offset, size})};
199 BOOST_CHECK(!res);
200 BOOST_CHECK_EQUAL(res.error(), node::ReadRawError::BadPartRange);
201 }};
202
203 expect_part_error(0, 0);
204 expect_part_error(0, block->size() + 1);
205 expect_part_error(0, std::numeric_limits<size_t>::max());
206 expect_part_error(1, block->size());
207 expect_part_error(2, block->size() - 1);
208 expect_part_error(block->size() - 1, 2);
209 expect_part_error(block->size() - 2, 3);
210 expect_part_error(block->size() + 1, 0);
211 expect_part_error(block->size() + 1, 1);
212 expect_part_error(block->size() + 2, 2);
213 expect_part_error(block->size(), 0);
214 expect_part_error(block->size(), 1);
215 expect_part_error(std::numeric_limits<size_t>::max(), 1);
216 expect_part_error(std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max());
217 }
218
219 BOOST_FIXTURE_TEST_CASE(blockmanager_readblock_hash_mismatch, TestingSetup)
220 {
221 CBlockIndex index;
222 {
223 LOCK(cs_main);
224 const auto tip{m_node.chainman->ActiveTip()};
225 index.nStatus = tip->nStatus;
226 index.nDataPos = tip->nDataPos;
227 index.phashBlock = &uint256::ONE; // mismatched block hash
228 }
229
230 ASSERT_DEBUG_LOG("GetHash() doesn't match index");
231 CBlock block;
232 BOOST_CHECK(!m_node.chainman->m_blockman.ReadBlock(block, index));
233 }
234
235 BOOST_AUTO_TEST_CASE(blockmanager_flush_block_file)
236 {
237 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)};
238 node::BlockManager::Options blockman_opts{
239 .chainparams = Params(),
240 .blocks_dir = m_args.GetBlocksDirPath(),
241 .notifications = notifications,
242 .block_tree_db_params = DBParams{
243 .path = m_args.GetDataDirNet() / "blocks" / "index",
244 .cache_bytes = 0,
245 },
246 };
247 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts};
248
249 // Test blocks with no transactions, not even a coinbase
250 CBlock block1;
251 block1.nVersion = 1;
252 CBlock block2;
253 block2.nVersion = 2;
254 CBlock block3;
255 block3.nVersion = 3;
256
257 // They are 80 bytes header + 1 byte 0x00 for vtx length
258 constexpr int TEST_BLOCK_SIZE{81};
259
260 // Blockstore is empty
261 LOCK(::cs_main);
262 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), 0);
263
264 // Write the first block to a new location.
265 FlatFilePos pos1{blockman.WriteBlock(block1, /*nHeight=*/1)};
266
267 // Write second block
268 FlatFilePos pos2{blockman.WriteBlock(block2, /*nHeight=*/2)};
269
270 // Two blocks in the file
271 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + STORAGE_HEADER_BYTES) * 2);
272
273 // First two blocks are written as expected
274 // Errors are expected because block data is junk, thrown AFTER successful read
275 CBlock read_block;
276 BOOST_CHECK_EQUAL(read_block.nVersion, 0);
277 {
278 ASSERT_DEBUG_LOG("Errors in block header");
279 BOOST_CHECK(!blockman.ReadBlock(read_block, pos1, {}));
280 BOOST_CHECK_EQUAL(read_block.nVersion, 1);
281 }
282 {
283 ASSERT_DEBUG_LOG("Errors in block header");
284 BOOST_CHECK(!blockman.ReadBlock(read_block, pos2, {}));
285 BOOST_CHECK_EQUAL(read_block.nVersion, 2);
286 }
287
288 // During reindex, the flat file block storage will not be written to.
289 // UpdateBlockInfo will, however, update the blockfile metadata.
290 // Verify this behavior by attempting (and failing) to write block 3 data
291 // to block 2 location.
292 CBlockFileInfo* block_data = blockman.GetBlockFileInfo(0);
293 BOOST_CHECK_EQUAL(block_data->nBlocks, 2);
294 blockman.UpdateBlockInfo(block3, /*nHeight=*/3, /*pos=*/pos2);
295 // Metadata is updated...
296 BOOST_CHECK_EQUAL(block_data->nBlocks, 3);
297 // ...but there are still only two blocks in the file
298 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + STORAGE_HEADER_BYTES) * 2);
299
300 // Block 2 was not overwritten:
301 BOOST_CHECK(!blockman.ReadBlock(read_block, pos2, {}));
302 BOOST_CHECK_EQUAL(read_block.nVersion, 2);
303 }
304
305 BOOST_FIXTURE_TEST_CASE(prune_lock_update_and_delete, TestingSetup)
306 {
307 LOCK(::cs_main);
308 auto& chainman{*Assert(m_node.chainman)};
309 auto& blockman{chainman.m_blockman};
310
311 // Create a prune lock
312 blockman.UpdatePruneLock("test_lock", node::PruneLockInfo{.height_first = 100});
313
314 // Update it to a new height
315 blockman.UpdatePruneLock("test_lock", node::PruneLockInfo{.height_first = 200});
316
317 // Delete existing prune lock
318 BOOST_CHECK(blockman.DeletePruneLock("test_lock"));
319
320 // Verify deletion worked by trying to delete the same lock again
321 BOOST_CHECK(!blockman.DeletePruneLock("test_lock"));
322
323 // Deleting a non-existent lock returns false
324 BOOST_CHECK(!blockman.DeletePruneLock("nonexistent"));
325 }
326
327 BOOST_AUTO_TEST_SUITE_END()
328