Branch data Line data Source code
1 : : // Copyright (c) 2011-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 <node/blockstorage.h>
6 : :
7 : : #include <arith_uint256.h>
8 : : #include <chain.h>
9 : : #include <consensus/params.h>
10 : : #include <consensus/validation.h>
11 : : #include <dbwrapper.h>
12 : : #include <flatfile.h>
13 : : #include <hash.h>
14 : : #include <kernel/blockmanager_opts.h>
15 : : #include <kernel/chainparams.h>
16 : : #include <kernel/messagestartchars.h>
17 : : #include <kernel/notifications_interface.h>
18 : : #include <logging.h>
19 : : #include <pow.h>
20 : : #include <primitives/block.h>
21 : : #include <primitives/transaction.h>
22 : : #include <random.h>
23 : : #include <serialize.h>
24 : : #include <signet.h>
25 : : #include <span.h>
26 : : #include <streams.h>
27 : : #include <sync.h>
28 : : #include <tinyformat.h>
29 : : #include <uint256.h>
30 : : #include <undo.h>
31 : : #include <util/batchpriority.h>
32 : : #include <util/check.h>
33 : : #include <util/fs.h>
34 : : #include <util/signalinterrupt.h>
35 : : #include <util/strencodings.h>
36 : : #include <util/translation.h>
37 : : #include <validation.h>
38 : :
39 : : #include <map>
40 : : #include <ranges>
41 : : #include <unordered_map>
42 : :
43 : : namespace kernel {
44 : : static constexpr uint8_t DB_BLOCK_FILES{'f'};
45 : : static constexpr uint8_t DB_BLOCK_INDEX{'b'};
46 : : static constexpr uint8_t DB_FLAG{'F'};
47 : : static constexpr uint8_t DB_REINDEX_FLAG{'R'};
48 : : static constexpr uint8_t DB_LAST_BLOCK{'l'};
49 : : // Keys used in previous version that might still be found in the DB:
50 : : // BlockTreeDB::DB_TXINDEX_BLOCK{'T'};
51 : : // BlockTreeDB::DB_TXINDEX{'t'}
52 : : // BlockTreeDB::ReadFlag("txindex")
53 : :
54 : 340 : bool BlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo& info)
55 : : {
56 : 340 : return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
57 : : }
58 : :
59 : 0 : bool BlockTreeDB::WriteReindexing(bool fReindexing)
60 : : {
61 [ # # ]: 0 : if (fReindexing) {
62 : 0 : return Write(DB_REINDEX_FLAG, uint8_t{'1'});
63 : : } else {
64 : 0 : return Erase(DB_REINDEX_FLAG);
65 : : }
66 : : }
67 : :
68 : 168 : void BlockTreeDB::ReadReindexing(bool& fReindexing)
69 : : {
70 : 168 : fReindexing = Exists(DB_REINDEX_FLAG);
71 : 168 : }
72 : :
73 : 168 : bool BlockTreeDB::ReadLastBlockFile(int& nFile)
74 : : {
75 : 168 : return Read(DB_LAST_BLOCK, nFile);
76 : : }
77 : :
78 : 69 : bool BlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo)
79 : : {
80 : 69 : CDBBatch batch(*this);
81 [ + - + + ]: 85 : for (const auto& [file, info] : fileInfo) {
82 [ + - ]: 16 : batch.Write(std::make_pair(DB_BLOCK_FILES, file), *info);
83 : : }
84 [ + - ]: 69 : batch.Write(DB_LAST_BLOCK, nLastFile);
85 [ + + ]: 1677 : for (const CBlockIndex* bi : blockinfo) {
86 [ + - ]: 1608 : batch.Write(std::make_pair(DB_BLOCK_INDEX, bi->GetBlockHash()), CDiskBlockIndex{bi});
87 : : }
88 [ + - ]: 138 : return WriteBatch(batch, true);
89 : 69 : }
90 : :
91 : 0 : bool BlockTreeDB::WriteFlag(const std::string& name, bool fValue)
92 : : {
93 [ # # # # ]: 0 : return Write(std::make_pair(DB_FLAG, name), fValue ? uint8_t{'1'} : uint8_t{'0'});
94 : : }
95 : :
96 : 168 : bool BlockTreeDB::ReadFlag(const std::string& name, bool& fValue)
97 : : {
98 : 168 : uint8_t ch;
99 [ + - - + ]: 168 : if (!Read(std::make_pair(DB_FLAG, name), ch)) {
100 : : return false;
101 : : }
102 : 0 : fValue = ch == uint8_t{'1'};
103 : 0 : return true;
104 : : }
105 : :
106 : 168 : bool BlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, const util::SignalInterrupt& interrupt)
107 : : {
108 : 168 : AssertLockHeld(::cs_main);
109 [ + - ]: 168 : std::unique_ptr<CDBIterator> pcursor(NewIterator());
110 [ + - ]: 168 : pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
111 : :
112 : : // Load m_block_index
113 [ + - + + ]: 1012 : while (pcursor->Valid()) {
114 [ + - + - ]: 848 : if (interrupt) return false;
115 : 848 : std::pair<uint8_t, uint256> key;
116 [ + - + + : 848 : if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
+ - ]
117 : 844 : CDiskBlockIndex diskindex;
118 [ + - + - ]: 844 : if (pcursor->GetValue(diskindex)) {
119 : : // Construct block index object
120 [ + - + - ]: 844 : CBlockIndex* pindexNew = insertBlockIndex(diskindex.ConstructBlockHash());
121 [ + - ]: 844 : pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
122 : 844 : pindexNew->nHeight = diskindex.nHeight;
123 : 844 : pindexNew->nFile = diskindex.nFile;
124 : 844 : pindexNew->nDataPos = diskindex.nDataPos;
125 : 844 : pindexNew->nUndoPos = diskindex.nUndoPos;
126 : 844 : pindexNew->nVersion = diskindex.nVersion;
127 : 844 : pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
128 : 844 : pindexNew->nTime = diskindex.nTime;
129 : 844 : pindexNew->nBits = diskindex.nBits;
130 : 844 : pindexNew->nNonce = diskindex.nNonce;
131 : 844 : pindexNew->nStatus = diskindex.nStatus;
132 : 844 : pindexNew->nTx = diskindex.nTx;
133 : :
134 [ + - - + ]: 844 : if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams)) {
135 [ # # # # ]: 0 : LogError("%s: CheckProofOfWork failed: %s\n", __func__, pindexNew->ToString());
136 : 0 : return false;
137 : : }
138 : :
139 [ + - ]: 844 : pcursor->Next();
140 : : } else {
141 [ # # ]: 0 : LogError("%s: failed to read value\n", __func__);
142 : : return false;
143 : : }
144 : : } else {
145 : : break;
146 : : }
147 : : }
148 : :
149 : : return true;
150 : 168 : }
151 : : } // namespace kernel
152 : :
153 : : namespace node {
154 : :
155 : 19340196 : bool CBlockIndexWorkComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
156 : : {
157 : : // First sort by most total work, ...
158 [ + + ]: 19340196 : if (pa->nChainWork > pb->nChainWork) return false;
159 [ + + ]: 12798256 : if (pa->nChainWork < pb->nChainWork) return true;
160 : :
161 : : // ... then by earliest time received, ...
162 [ + + ]: 142021 : if (pa->nSequenceId < pb->nSequenceId) return false;
163 [ + + ]: 132465 : if (pa->nSequenceId > pb->nSequenceId) return true;
164 : :
165 : : // Use pointer address as tie breaker (should only happen with blocks
166 : : // loaded from disk, as those all have id 0).
167 [ + - ]: 122544 : if (pa < pb) return false;
168 [ - + ]: 122544 : if (pa > pb) return true;
169 : :
170 : : // Identical blocks.
171 : : return false;
172 : : }
173 : :
174 : 19308 : bool CBlockIndexHeightOnlyComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
175 : : {
176 : 19308 : return pa->nHeight < pb->nHeight;
177 : : }
178 : :
179 : 336 : std::vector<CBlockIndex*> BlockManager::GetAllBlockIndices()
180 : : {
181 : 336 : AssertLockHeld(cs_main);
182 : 336 : std::vector<CBlockIndex*> rv;
183 [ + - ]: 336 : rv.reserve(m_block_index.size());
184 [ + - + + ]: 2508 : for (auto& [_, block_index] : m_block_index) {
185 [ + - ]: 2172 : rv.push_back(&block_index);
186 : : }
187 : 336 : return rv;
188 : 0 : }
189 : :
190 : 26764 : CBlockIndex* BlockManager::LookupBlockIndex(const uint256& hash)
191 : : {
192 : 26764 : AssertLockHeld(cs_main);
193 : 26764 : BlockMap::iterator it = m_block_index.find(hash);
194 [ + + ]: 26764 : return it == m_block_index.end() ? nullptr : &it->second;
195 : : }
196 : :
197 : 0 : const CBlockIndex* BlockManager::LookupBlockIndex(const uint256& hash) const
198 : : {
199 : 0 : AssertLockHeld(cs_main);
200 : 0 : BlockMap::const_iterator it = m_block_index.find(hash);
201 [ # # ]: 0 : return it == m_block_index.end() ? nullptr : &it->second;
202 : : }
203 : :
204 : 7384 : CBlockIndex* BlockManager::AddToBlockIndex(const CBlockHeader& block, CBlockIndex*& best_header)
205 : : {
206 : 7384 : AssertLockHeld(cs_main);
207 : :
208 [ + + ]: 7384 : auto [mi, inserted] = m_block_index.try_emplace(block.GetHash(), block);
209 [ + + ]: 7384 : if (!inserted) {
210 : 2 : return &mi->second;
211 : : }
212 : 7382 : CBlockIndex* pindexNew = &(*mi).second;
213 : :
214 : : // We assign the sequence id to blocks only when the full data is available,
215 : : // to avoid miners withholding blocks but broadcasting headers, to get a
216 : : // competitive advantage.
217 : 7382 : pindexNew->nSequenceId = 0;
218 : :
219 : 7382 : pindexNew->phashBlock = &((*mi).first);
220 : 7382 : BlockMap::iterator miPrev = m_block_index.find(block.hashPrevBlock);
221 [ + + ]: 7382 : if (miPrev != m_block_index.end()) {
222 : 7219 : pindexNew->pprev = &(*miPrev).second;
223 : 7219 : pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
224 : 7219 : pindexNew->BuildSkip();
225 : : }
226 [ + + + + ]: 7382 : pindexNew->nTimeMax = (pindexNew->pprev ? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime) : pindexNew->nTime);
227 [ + + + - ]: 22146 : pindexNew->nChainWork = (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) + GetBlockProof(*pindexNew);
228 : 7382 : pindexNew->RaiseValidity(BLOCK_VALID_TREE);
229 [ + + + + ]: 7382 : if (best_header == nullptr || best_header->nChainWork < pindexNew->nChainWork) {
230 : 6701 : best_header = pindexNew;
231 : : }
232 : :
233 : 7382 : m_dirty_blockindex.insert(pindexNew);
234 : :
235 : 7382 : return pindexNew;
236 : : }
237 : :
238 : 4 : void BlockManager::PruneOneBlockFile(const int fileNumber)
239 : : {
240 : 4 : AssertLockHeld(cs_main);
241 : 4 : LOCK(cs_LastBlockFile);
242 : :
243 [ + + ]: 412 : for (auto& entry : m_block_index) {
244 : 408 : CBlockIndex* pindex = &entry.second;
245 [ + + ]: 408 : if (pindex->nFile == fileNumber) {
246 : 304 : pindex->nStatus &= ~BLOCK_HAVE_DATA;
247 : 304 : pindex->nStatus &= ~BLOCK_HAVE_UNDO;
248 : 304 : pindex->nFile = 0;
249 : 304 : pindex->nDataPos = 0;
250 : 304 : pindex->nUndoPos = 0;
251 [ + - ]: 304 : m_dirty_blockindex.insert(pindex);
252 : :
253 : : // Prune from m_blocks_unlinked -- any block we prune would have
254 : : // to be downloaded again in order to consider its chain, at which
255 : : // point it would be considered as a candidate for
256 : : // m_blocks_unlinked or setBlockIndexCandidates.
257 : 304 : auto range = m_blocks_unlinked.equal_range(pindex->pprev);
258 [ - + ]: 304 : while (range.first != range.second) {
259 : 0 : std::multimap<CBlockIndex*, CBlockIndex*>::iterator _it = range.first;
260 : 0 : range.first++;
261 [ # # ]: 0 : if (_it->second == pindex) {
262 : 0 : m_blocks_unlinked.erase(_it);
263 : : }
264 : : }
265 : : }
266 : : }
267 : :
268 [ + - ]: 4 : m_blockfile_info.at(fileNumber) = CBlockFileInfo{};
269 [ + - ]: 4 : m_dirty_fileinfo.insert(fileNumber);
270 : 4 : }
271 : :
272 : 0 : void BlockManager::FindFilesToPruneManual(
273 : : std::set<int>& setFilesToPrune,
274 : : int nManualPruneHeight,
275 : : const Chainstate& chain,
276 : : ChainstateManager& chainman)
277 : : {
278 [ # # # # ]: 0 : assert(IsPruneMode() && nManualPruneHeight > 0);
279 : :
280 [ # # ]: 0 : LOCK2(cs_main, cs_LastBlockFile);
281 [ # # ]: 0 : if (chain.m_chain.Height() < 0) {
282 [ # # ]: 0 : return;
283 : : }
284 : :
285 [ # # ]: 0 : const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, nManualPruneHeight);
286 : :
287 : 0 : int count = 0;
288 [ # # ]: 0 : for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {
289 [ # # ]: 0 : const auto& fileinfo = m_blockfile_info[fileNumber];
290 [ # # # # : 0 : if (fileinfo.nSize == 0 || fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
# # ]
291 : 0 : continue;
292 : : }
293 : :
294 [ # # ]: 0 : PruneOneBlockFile(fileNumber);
295 [ # # ]: 0 : setFilesToPrune.insert(fileNumber);
296 : 0 : count++;
297 : : }
298 [ # # # # ]: 0 : LogPrintf("[%s] Prune (Manual): prune_height=%d removed %d blk/rev pairs\n",
299 : : chain.GetRole(), last_block_can_prune, count);
300 [ # # # # ]: 0 : }
301 : :
302 : 0 : void BlockManager::FindFilesToPrune(
303 : : std::set<int>& setFilesToPrune,
304 : : int last_prune,
305 : : const Chainstate& chain,
306 : : ChainstateManager& chainman)
307 : : {
308 [ # # ]: 0 : LOCK2(cs_main, cs_LastBlockFile);
309 : : // Distribute our -prune budget over all chainstates.
310 [ # # ]: 0 : const auto target = std::max(
311 [ # # # # ]: 0 : MIN_DISK_SPACE_FOR_BLOCK_FILES, GetPruneTarget() / chainman.GetAll().size());
312 : 0 : const uint64_t target_sync_height = chainman.m_best_header->nHeight;
313 : :
314 [ # # # # ]: 0 : if (chain.m_chain.Height() < 0 || target == 0) {
315 : : return;
316 : : }
317 [ # # ]: 0 : if (static_cast<uint64_t>(chain.m_chain.Height()) <= chainman.GetParams().PruneAfterHeight()) {
318 : : return;
319 : : }
320 : :
321 [ # # # # ]: 0 : const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, last_prune);
322 : :
323 [ # # ]: 0 : uint64_t nCurrentUsage = CalculateCurrentUsage();
324 : : // We don't check to prune until after we've allocated new space for files
325 : : // So we should leave a buffer under our target to account for another allocation
326 : : // before the next pruning.
327 : 0 : uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
328 : 0 : uint64_t nBytesToPrune;
329 : 0 : int count = 0;
330 : :
331 [ # # ]: 0 : if (nCurrentUsage + nBuffer >= target) {
332 : : // On a prune event, the chainstate DB is flushed.
333 : : // To avoid excessive prune events negating the benefit of high dbcache
334 : : // values, we should not prune too rapidly.
335 : : // So when pruning in IBD, increase the buffer to avoid a re-prune too soon.
336 [ # # ]: 0 : const auto chain_tip_height = chain.m_chain.Height();
337 [ # # # # : 0 : if (chainman.IsInitialBlockDownload() && target_sync_height > (uint64_t)chain_tip_height) {
# # ]
338 : : // Since this is only relevant during IBD, we assume blocks are at least 1 MB on average
339 : 0 : static constexpr uint64_t average_block_size = 1000000; /* 1 MB */
340 : 0 : const uint64_t remaining_blocks = target_sync_height - chain_tip_height;
341 : 0 : nBuffer += average_block_size * remaining_blocks;
342 : : }
343 : :
344 [ # # ]: 0 : for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {
345 [ # # ]: 0 : const auto& fileinfo = m_blockfile_info[fileNumber];
346 : 0 : nBytesToPrune = fileinfo.nSize + fileinfo.nUndoSize;
347 : :
348 [ # # ]: 0 : if (fileinfo.nSize == 0) {
349 : 0 : continue;
350 : : }
351 : :
352 [ # # ]: 0 : if (nCurrentUsage + nBuffer < target) { // are we below our target?
353 : : break;
354 : : }
355 : :
356 : : // don't prune files that could have a block that's not within the allowable
357 : : // prune range for the chain being pruned.
358 [ # # # # ]: 0 : if (fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
359 : 0 : continue;
360 : : }
361 : :
362 [ # # ]: 0 : PruneOneBlockFile(fileNumber);
363 : : // Queue up the files for removal
364 [ # # ]: 0 : setFilesToPrune.insert(fileNumber);
365 : 0 : nCurrentUsage -= nBytesToPrune;
366 : 0 : count++;
367 : : }
368 : : }
369 : :
370 [ # # # # : 0 : LogPrint(BCLog::PRUNE, "[%s] target=%dMiB actual=%dMiB diff=%dMiB min_height=%d max_prune_height=%d removed %d blk/rev pairs\n",
# # # # #
# ]
371 : : chain.GetRole(), target / 1024 / 1024, nCurrentUsage / 1024 / 1024,
372 : : (int64_t(target) - int64_t(nCurrentUsage)) / 1024 / 1024,
373 : : min_block_to_prune, last_block_can_prune, count);
374 [ # # # # ]: 0 : }
375 : :
376 : 20 : void BlockManager::UpdatePruneLock(const std::string& name, const PruneLockInfo& lock_info) {
377 : 20 : AssertLockHeld(::cs_main);
378 : 20 : m_prune_locks[name] = lock_info;
379 : 20 : }
380 : :
381 : 1688 : CBlockIndex* BlockManager::InsertBlockIndex(const uint256& hash)
382 : : {
383 : 1688 : AssertLockHeld(cs_main);
384 : :
385 [ + + ]: 1688 : if (hash.IsNull()) {
386 : : return nullptr;
387 : : }
388 : :
389 [ + + ]: 1684 : const auto [mi, inserted]{m_block_index.try_emplace(hash)};
390 [ + + ]: 1684 : CBlockIndex* pindex = &(*mi).second;
391 [ + + ]: 1684 : if (inserted) {
392 : 633 : pindex->phashBlock = &((*mi).first);
393 : : }
394 : : return pindex;
395 : : }
396 : :
397 : 168 : bool BlockManager::LoadBlockIndex(const std::optional<uint256>& snapshot_blockhash)
398 : : {
399 [ + - + - ]: 168 : if (!m_block_tree_db->LoadBlockIndexGuts(
400 [ + - ]: 1856 : GetConsensus(), [this](const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return this->InsertBlockIndex(hash); }, m_interrupt)) {
401 : : return false;
402 : : }
403 : :
404 [ + + ]: 168 : if (snapshot_blockhash) {
405 : 3 : const std::optional<AssumeutxoData> maybe_au_data = GetParams().AssumeutxoForBlockhash(*snapshot_blockhash);
406 [ - + ]: 3 : if (!maybe_au_data) {
407 [ # # # # : 0 : m_opts.notifications.fatalError(strprintf(_("Assumeutxo data not found for the given blockhash '%s'."), snapshot_blockhash->ToString()));
# # ]
408 : 0 : return false;
409 : : }
410 : 3 : const AssumeutxoData& au_data = *Assert(maybe_au_data);
411 : 3 : m_snapshot_height = au_data.height;
412 : 3 : CBlockIndex* base{LookupBlockIndex(*snapshot_blockhash)};
413 : :
414 : : // Since m_chain_tx_count (responsible for estimated progress) isn't persisted
415 : : // to disk, we must bootstrap the value for assumedvalid chainstates
416 : : // from the hardcoded assumeutxo chainparams.
417 : 3 : base->m_chain_tx_count = au_data.m_chain_tx_count;
418 [ + - ]: 6 : LogPrintf("[snapshot] set m_chain_tx_count=%d for %s\n", au_data.m_chain_tx_count, snapshot_blockhash->ToString());
419 : : } else {
420 : : // If this isn't called with a snapshot blockhash, make sure the cached snapshot height
421 : : // is null. This is relevant during snapshot completion, when the blockman may be loaded
422 : : // with a height that then needs to be cleared after the snapshot is fully validated.
423 [ + + ]: 165 : m_snapshot_height.reset();
424 : : }
425 : :
426 : 168 : Assert(m_snapshot_height.has_value() == snapshot_blockhash.has_value());
427 : :
428 : : // Calculate nChainWork
429 : 168 : std::vector<CBlockIndex*> vSortedByHeight{GetAllBlockIndices()};
430 : 168 : std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
431 : : CBlockIndexHeightOnlyComparator());
432 : :
433 : 168 : CBlockIndex* previous_index{nullptr};
434 [ + + ]: 1254 : for (CBlockIndex* pindex : vSortedByHeight) {
435 [ + - + - ]: 1086 : if (m_interrupt) return false;
436 [ + + - + ]: 1086 : if (previous_index && pindex->nHeight > previous_index->nHeight + 1) {
437 [ # # ]: 0 : LogError("%s: block index is non-contiguous, index of height %d missing\n", __func__, previous_index->nHeight + 1);
438 : : return false;
439 : : }
440 : 1086 : previous_index = pindex;
441 [ + - + + : 3258 : pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) + GetBlockProof(*pindex);
+ - ]
442 [ + + - + ]: 1086 : pindex->nTimeMax = (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime) : pindex->nTime);
443 : :
444 : : // We can link the chain of blocks for which we've received transactions at some point, or
445 : : // blocks that are assumed-valid on the basis of snapshot load (see
446 : : // PopulateAndValidateSnapshot()).
447 : : // Pruned nodes may have deleted the block.
448 [ + + ]: 1086 : if (pindex->nTx > 0) {
449 [ + + ]: 1066 : if (pindex->pprev) {
450 [ + + + + : 1062 : if (m_snapshot_height && pindex->nHeight == *m_snapshot_height &&
+ - ]
451 [ + - ]: 2 : pindex->GetBlockHash() == *snapshot_blockhash) {
452 : : // Should have been set above; don't disturb it with code below.
453 [ + - ]: 2 : Assert(pindex->m_chain_tx_count > 0);
454 [ + - ]: 1058 : } else if (pindex->pprev->m_chain_tx_count > 0) {
455 : 1058 : pindex->m_chain_tx_count = pindex->pprev->m_chain_tx_count + pindex->nTx;
456 : : } else {
457 : 0 : pindex->m_chain_tx_count = 0;
458 [ # # ]: 0 : m_blocks_unlinked.insert(std::make_pair(pindex->pprev, pindex));
459 : : }
460 : : } else {
461 : 6 : pindex->m_chain_tx_count = pindex->nTx;
462 : : }
463 : : }
464 [ + - + + : 1086 : if (!(pindex->nStatus & BLOCK_FAILED_MASK) && pindex->pprev && (pindex->pprev->nStatus & BLOCK_FAILED_MASK)) {
- + ]
465 : 0 : pindex->nStatus |= BLOCK_FAILED_CHILD;
466 [ # # ]: 0 : m_dirty_blockindex.insert(pindex);
467 : : }
468 [ + + ]: 1086 : if (pindex->pprev) {
469 [ + - ]: 1080 : pindex->BuildSkip();
470 : : }
471 : : }
472 : :
473 : : return true;
474 : 168 : }
475 : :
476 : 69 : bool BlockManager::WriteBlockIndexDB()
477 : : {
478 : 69 : AssertLockHeld(::cs_main);
479 : 69 : std::vector<std::pair<int, const CBlockFileInfo*>> vFiles;
480 [ + - ]: 69 : vFiles.reserve(m_dirty_fileinfo.size());
481 [ + + ]: 85 : for (std::set<int>::iterator it = m_dirty_fileinfo.begin(); it != m_dirty_fileinfo.end();) {
482 [ + - ]: 16 : vFiles.emplace_back(*it, &m_blockfile_info[*it]);
483 : 16 : m_dirty_fileinfo.erase(it++);
484 : : }
485 : 69 : std::vector<const CBlockIndex*> vBlocks;
486 [ + - ]: 69 : vBlocks.reserve(m_dirty_blockindex.size());
487 [ + + ]: 1677 : for (std::set<CBlockIndex*>::iterator it = m_dirty_blockindex.begin(); it != m_dirty_blockindex.end();) {
488 [ + - ]: 1608 : vBlocks.push_back(*it);
489 : 1608 : m_dirty_blockindex.erase(it++);
490 : : }
491 [ + - + - ]: 138 : int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());
492 [ + - - + ]: 69 : if (!m_block_tree_db->WriteBatchSync(vFiles, max_blockfile, vBlocks)) {
493 : 0 : return false;
494 : : }
495 : : return true;
496 : 69 : }
497 : :
498 : 168 : bool BlockManager::LoadBlockIndexDB(const std::optional<uint256>& snapshot_blockhash)
499 : : {
500 [ + - ]: 168 : if (!LoadBlockIndex(snapshot_blockhash)) {
501 : : return false;
502 : : }
503 : 168 : int max_blockfile_num{0};
504 : :
505 : : // Load block file info
506 : 168 : m_block_tree_db->ReadLastBlockFile(max_blockfile_num);
507 : 168 : m_blockfile_info.resize(max_blockfile_num + 1);
508 : 168 : LogPrintf("%s: last block file = %i\n", __func__, max_blockfile_num);
509 [ + + ]: 340 : for (int nFile = 0; nFile <= max_blockfile_num; nFile++) {
510 : 172 : m_block_tree_db->ReadBlockFileInfo(nFile, m_blockfile_info[nFile]);
511 : : }
512 [ + - ]: 168 : LogPrintf("%s: last block file info: %s\n", __func__, m_blockfile_info[max_blockfile_num].ToString());
513 : 168 : for (int nFile = max_blockfile_num + 1; true; nFile++) {
514 : 168 : CBlockFileInfo info;
515 [ - + ]: 168 : if (m_block_tree_db->ReadBlockFileInfo(nFile, info)) {
516 : 0 : m_blockfile_info.push_back(info);
517 : : } else {
518 : : break;
519 : : }
520 : 0 : }
521 : :
522 : : // Check presence of blk files
523 : 168 : LogPrintf("Checking all blk files are present...\n");
524 : 168 : std::set<int> setBlkDataFiles;
525 [ + + + + ]: 1254 : for (const auto& [_, block_index] : m_block_index) {
526 [ + + ]: 1086 : if (block_index.nStatus & BLOCK_HAVE_DATA) {
527 [ + - ]: 1066 : setBlkDataFiles.insert(block_index.nFile);
528 : : }
529 : : }
530 [ + + ]: 178 : for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++) {
531 [ + - ]: 10 : FlatFilePos pos(*it, 0);
532 [ + - + - ]: 20 : if (OpenBlockFile(pos, true).IsNull()) {
533 : : return false;
534 : : }
535 : : }
536 : :
537 : 168 : {
538 : : // Initialize the blockfile cursors.
539 [ + - ]: 168 : LOCK(cs_LastBlockFile);
540 [ + + ]: 340 : for (size_t i = 0; i < m_blockfile_info.size(); ++i) {
541 [ + + ]: 172 : const auto last_height_in_file = m_blockfile_info[i].nHeightLast;
542 [ + + ]: 344 : m_blockfile_cursors[BlockfileTypeForHeight(last_height_in_file)] = {static_cast<int>(i), 0};
543 : : }
544 : 168 : }
545 : :
546 : : // Check whether we have ever pruned block & undo files
547 [ + - + - ]: 168 : m_block_tree_db->ReadFlag("prunedblockfiles", m_have_pruned);
548 [ - + ]: 168 : if (m_have_pruned) {
549 [ # # ]: 0 : LogPrintf("LoadBlockIndexDB(): Block files have previously been pruned\n");
550 : : }
551 : :
552 : : // Check whether we need to continue reindexing
553 : 168 : bool fReindexing = false;
554 [ + - ]: 168 : m_block_tree_db->ReadReindexing(fReindexing);
555 [ - + ]: 168 : if (fReindexing) m_blockfiles_indexed = false;
556 : :
557 : : return true;
558 : 168 : }
559 : :
560 : 171 : void BlockManager::ScanAndUnlinkAlreadyPrunedFiles()
561 : : {
562 : 171 : AssertLockHeld(::cs_main);
563 [ + - ]: 342 : int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());
564 [ + + ]: 171 : if (!m_have_pruned) {
565 : : return;
566 : : }
567 : :
568 : 2 : std::set<int> block_files_to_prune;
569 [ + + ]: 4 : for (int file_number = 0; file_number < max_blockfile; file_number++) {
570 [ + - ]: 2 : if (m_blockfile_info[file_number].nSize == 0) {
571 [ + - ]: 2 : block_files_to_prune.insert(file_number);
572 : : }
573 : : }
574 : :
575 [ + - ]: 2 : UnlinkPrunedFiles(block_files_to_prune);
576 : 2 : }
577 : :
578 : 14351 : const CBlockIndex* BlockManager::GetLastCheckpoint(const CCheckpointData& data)
579 : : {
580 : 14351 : const MapCheckpoints& checkpoints = data.mapCheckpoints;
581 : :
582 [ + + ]: 16041 : for (const MapCheckpoints::value_type& i : checkpoints | std::views::reverse) {
583 : 15911 : const uint256& hash = i.second;
584 : 15911 : const CBlockIndex* pindex = LookupBlockIndex(hash);
585 [ + + ]: 15911 : if (pindex) {
586 : : return pindex;
587 : : }
588 : : }
589 : : return nullptr;
590 : : }
591 : :
592 : 0 : bool BlockManager::IsBlockPruned(const CBlockIndex& block) const
593 : : {
594 : 0 : AssertLockHeld(::cs_main);
595 [ # # # # : 0 : return m_have_pruned && !(block.nStatus & BLOCK_HAVE_DATA) && (block.nTx > 0);
# # ]
596 : : }
597 : :
598 : 9 : const CBlockIndex* BlockManager::GetFirstBlock(const CBlockIndex& upper_block, uint32_t status_mask, const CBlockIndex* lower_block) const
599 : : {
600 : 9 : AssertLockHeld(::cs_main);
601 : 9 : const CBlockIndex* last_block = &upper_block;
602 [ - + ]: 9 : assert((last_block->nStatus & status_mask) == status_mask); // 'upper_block' must satisfy the status mask
603 [ + + + + ]: 603 : while (last_block->pprev && ((last_block->pprev->nStatus & status_mask) == status_mask)) {
604 [ + + ]: 595 : if (lower_block) {
605 : : // Return if we reached the lower_block
606 [ + + ]: 446 : if (last_block == lower_block) return lower_block;
607 : : // if range was surpassed, means that 'lower_block' is not part of the 'upper_block' chain
608 : : // and so far this is not allowed.
609 [ - + ]: 445 : assert(last_block->nHeight >= lower_block->nHeight);
610 : : }
611 : : last_block = last_block->pprev;
612 : : }
613 [ - + ]: 8 : assert(last_block != nullptr);
614 : : return last_block;
615 : : }
616 : :
617 : 4 : bool BlockManager::CheckBlockDataAvailability(const CBlockIndex& upper_block, const CBlockIndex& lower_block)
618 : : {
619 [ + - ]: 4 : if (!(upper_block.nStatus & BLOCK_HAVE_DATA)) return false;
620 : 4 : return GetFirstBlock(upper_block, BLOCK_HAVE_DATA, &lower_block) == &lower_block;
621 : : }
622 : :
623 : : // If we're using -prune with -reindex, then delete block files that will be ignored by the
624 : : // reindex. Since reindexing works by starting at block file 0 and looping until a blockfile
625 : : // is missing, do the same here to delete any later block files after a gap. Also delete all
626 : : // rev files since they'll be rewritten by the reindex anyway. This ensures that m_blockfile_info
627 : : // is in sync with what's actually on disk by the time we start downloading, so that pruning
628 : : // works correctly.
629 : 0 : void BlockManager::CleanupBlockRevFiles() const
630 : : {
631 [ # # ]: 0 : std::map<std::string, fs::path> mapBlockFiles;
632 : :
633 : : // Glob all blk?????.dat and rev?????.dat files from the blocks directory.
634 : : // Remove the rev files immediately and insert the blk file paths into an
635 : : // ordered map keyed by block file index.
636 [ # # ]: 0 : LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");
637 [ # # # # : 0 : for (fs::directory_iterator it(m_opts.blocks_dir); it != fs::directory_iterator(); it++) {
# # ]
638 [ # # # # ]: 0 : const std::string path = fs::PathToString(it->path().filename());
639 [ # # # # ]: 0 : if (fs::is_regular_file(*it) &&
640 [ # # # # ]: 0 : path.length() == 12 &&
641 [ # # # # ]: 0 : path.substr(8,4) == ".dat")
642 : : {
643 [ # # # # ]: 0 : if (path.substr(0, 3) == "blk") {
644 [ # # # # : 0 : mapBlockFiles[path.substr(3, 5)] = it->path();
# # ]
645 [ # # # # ]: 0 : } else if (path.substr(0, 3) == "rev") {
646 [ # # ]: 0 : remove(it->path());
647 : : }
648 : : }
649 [ # # ]: 0 : }
650 : :
651 : : // Remove all block files that aren't part of a contiguous set starting at
652 : : // zero by walking the ordered map (keys are block file indices) by
653 : : // keeping a separate counter. Once we hit a gap (or if 0 doesn't exist)
654 : : // start removing block files.
655 : 0 : int nContigCounter = 0;
656 [ # # ]: 0 : for (const std::pair<const std::string, fs::path>& item : mapBlockFiles) {
657 [ # # # # ]: 0 : if (LocaleIndependentAtoi<int>(item.first) == nContigCounter) {
658 : 0 : nContigCounter++;
659 : 0 : continue;
660 : : }
661 [ # # ]: 0 : remove(item.second);
662 : : }
663 : 0 : }
664 : :
665 : 4 : CBlockFileInfo* BlockManager::GetBlockFileInfo(size_t n)
666 : : {
667 : 4 : LOCK(cs_LastBlockFile);
668 : :
669 [ + - + - ]: 4 : return &m_blockfile_info.at(n);
670 : 4 : }
671 : :
672 : 6925 : bool BlockManager::UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock) const
673 : : {
674 : : // Open history file to append
675 : 6925 : AutoFile fileout{OpenUndoFile(pos)};
676 [ - + ]: 6925 : if (fileout.IsNull()) {
677 [ # # ]: 0 : LogError("%s: OpenUndoFile failed\n", __func__);
678 : : return false;
679 : : }
680 : :
681 : : // Write index header
682 [ + - ]: 6925 : unsigned int nSize = GetSerializeSize(blockundo);
683 [ + - + - ]: 6925 : fileout << GetParams().MessageStart() << nSize;
684 : :
685 : : // Write undo data
686 [ + - ]: 6925 : long fileOutPos = ftell(fileout.Get());
687 [ - + ]: 6925 : if (fileOutPos < 0) {
688 [ # # ]: 0 : LogError("%s: ftell failed\n", __func__);
689 : : return false;
690 : : }
691 : 6925 : pos.nPos = (unsigned int)fileOutPos;
692 [ + - ]: 6925 : fileout << blockundo;
693 : :
694 : : // calculate & write checksum
695 [ + - ]: 6925 : HashWriter hasher{};
696 [ + - ]: 6925 : hasher << hashBlock;
697 [ + - ]: 6925 : hasher << blockundo;
698 [ + - ]: 13850 : fileout << hasher.GetHash();
699 : :
700 : : return true;
701 : 6925 : }
702 : :
703 : 900 : bool BlockManager::UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex& index) const
704 : : {
705 [ + - ]: 1800 : const FlatFilePos pos{WITH_LOCK(::cs_main, return index.GetUndoPos())};
706 : :
707 : : // Open history file to read
708 : 900 : AutoFile filein{OpenUndoFile(pos, true)};
709 [ - + ]: 900 : if (filein.IsNull()) {
710 [ # # # # ]: 0 : LogError("%s: OpenUndoFile failed for %s\n", __func__, pos.ToString());
711 : 0 : return false;
712 : : }
713 : :
714 : : // Read block
715 : 900 : uint256 hashChecksum;
716 [ + - ]: 900 : HashVerifier verifier{filein}; // Use HashVerifier as reserializing may lose data, c.f. commit d342424301013ec47dc146a4beb49d5c9319d80a
717 : 900 : try {
718 [ + - ]: 900 : verifier << index.pprev->GetBlockHash();
719 [ + - ]: 900 : verifier >> blockundo;
720 [ + - ]: 900 : filein >> hashChecksum;
721 [ - - ]: 0 : } catch (const std::exception& e) {
722 [ - - - - ]: 0 : LogError("%s: Deserialize or I/O error - %s at %s\n", __func__, e.what(), pos.ToString());
723 : 0 : return false;
724 : 0 : }
725 : :
726 : : // Verify checksum
727 [ + - - + ]: 900 : if (hashChecksum != verifier.GetHash()) {
728 [ # # # # ]: 0 : LogError("%s: Checksum mismatch at %s\n", __func__, pos.ToString());
729 : 0 : return false;
730 : : }
731 : :
732 : : return true;
733 : 900 : }
734 : :
735 : 67 : bool BlockManager::FlushUndoFile(int block_file, bool finalize)
736 : : {
737 : 67 : FlatFilePos undo_pos_old(block_file, m_blockfile_info[block_file].nUndoSize);
738 [ - + ]: 67 : if (!m_undo_file_seq.Flush(undo_pos_old, finalize)) {
739 [ # # ]: 0 : m_opts.notifications.flushError(_("Flushing undo file to disk failed. This is likely the result of an I/O error."));
740 : 0 : return false;
741 : : }
742 : : return true;
743 : : }
744 : :
745 : 67 : bool BlockManager::FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)
746 : : {
747 : 67 : bool success = true;
748 : 67 : LOCK(cs_LastBlockFile);
749 : :
750 [ + - ]: 67 : if (m_blockfile_info.size() < 1) {
751 : : // Return if we haven't loaded any blockfiles yet. This happens during
752 : : // chainstate init, when we call ChainstateManager::MaybeRebalanceCaches() (which
753 : : // then calls FlushStateToDisk()), resulting in a call to this function before we
754 : : // have populated `m_blockfile_info` via LoadBlockIndexDB().
755 : : return true;
756 : : }
757 [ - + ]: 67 : assert(static_cast<int>(m_blockfile_info.size()) > blockfile_num);
758 : :
759 [ + - ]: 67 : FlatFilePos block_pos_old(blockfile_num, m_blockfile_info[blockfile_num].nSize);
760 [ + - - + ]: 67 : if (!m_block_file_seq.Flush(block_pos_old, fFinalize)) {
761 [ # # # # ]: 0 : m_opts.notifications.flushError(_("Flushing block file to disk failed. This is likely the result of an I/O error."));
762 : 0 : success = false;
763 : : }
764 : : // we do not always flush the undo file, as the chain tip may be lagging behind the incoming blocks,
765 : : // e.g. during IBD or a sync after a node going offline
766 [ + - ]: 67 : if (!fFinalize || finalize_undo) {
767 [ + - - + ]: 67 : if (!FlushUndoFile(blockfile_num, finalize_undo)) {
768 : 0 : success = false;
769 : : }
770 : : }
771 : : return success;
772 : 67 : }
773 : :
774 : 14451 : BlockfileType BlockManager::BlockfileTypeForHeight(int height)
775 : : {
776 [ + + ]: 14451 : if (!m_snapshot_height) {
777 : : return BlockfileType::NORMAL;
778 : : }
779 [ + + ]: 849 : return (height >= *m_snapshot_height) ? BlockfileType::ASSUMED : BlockfileType::NORMAL;
780 : : }
781 : :
782 : 69 : bool BlockManager::FlushChainstateBlockFile(int tip_height)
783 : : {
784 : 69 : LOCK(cs_LastBlockFile);
785 [ + + ]: 69 : auto& cursor = m_blockfile_cursors[BlockfileTypeForHeight(tip_height)];
786 : : // If the cursor does not exist, it means an assumeutxo snapshot is loaded,
787 : : // but no blocks past the snapshot height have been written yet, so there
788 : : // is no data associated with the chainstate, and it is safe not to flush.
789 [ + + ]: 69 : if (cursor) {
790 [ + - ]: 64 : return FlushBlockFile(cursor->file_num, /*fFinalize=*/false, /*finalize_undo=*/false);
791 : : }
792 : : // No need to log warnings in this case.
793 : : return true;
794 : 69 : }
795 : :
796 : 3 : uint64_t BlockManager::CalculateCurrentUsage()
797 : : {
798 : 3 : LOCK(cs_LastBlockFile);
799 : :
800 : 3 : uint64_t retval = 0;
801 [ + + ]: 5 : for (const CBlockFileInfo& file : m_blockfile_info) {
802 : 2 : retval += file.nSize + file.nUndoSize;
803 : : }
804 [ + - ]: 3 : return retval;
805 : 3 : }
806 : :
807 : 5 : void BlockManager::UnlinkPrunedFiles(const std::set<int>& setFilesToPrune) const
808 : : {
809 : 5 : std::error_code ec;
810 [ + + ]: 10 : for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
811 : 5 : FlatFilePos pos(*it, 0);
812 : 5 : const bool removed_blockfile{fs::remove(m_block_file_seq.FileName(pos), ec)};
813 : 5 : const bool removed_undofile{fs::remove(m_undo_file_seq.FileName(pos), ec)};
814 [ + + ]: 5 : if (removed_blockfile || removed_undofile) {
815 [ + - ]: 4 : LogPrint(BCLog::BLOCKSTORAGE, "Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
816 : : }
817 : : }
818 : 5 : }
819 : :
820 : 9521 : AutoFile BlockManager::OpenBlockFile(const FlatFilePos& pos, bool fReadOnly) const
821 : : {
822 : 9521 : return AutoFile{m_block_file_seq.Open(pos, fReadOnly), m_xor_key};
823 : : }
824 : :
825 : : /** Open an undo file (rev?????.dat) */
826 : 7825 : AutoFile BlockManager::OpenUndoFile(const FlatFilePos& pos, bool fReadOnly) const
827 : : {
828 : 7825 : return AutoFile{m_undo_file_seq.Open(pos, fReadOnly), m_xor_key};
829 : : }
830 : :
831 : 0 : fs::path BlockManager::GetBlockPosFilename(const FlatFilePos& pos) const
832 : : {
833 : 0 : return m_block_file_seq.FileName(pos);
834 : : }
835 : :
836 : 7159 : FlatFilePos BlockManager::FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime)
837 : : {
838 : 7159 : LOCK(cs_LastBlockFile);
839 : :
840 : 7159 : const BlockfileType chain_type = BlockfileTypeForHeight(nHeight);
841 : :
842 [ + + ]: 7159 : if (!m_blockfile_cursors[chain_type]) {
843 : : // If a snapshot is loaded during runtime, we may not have initialized this cursor yet.
844 [ - + ]: 5 : assert(chain_type == BlockfileType::ASSUMED);
845 : 5 : const auto new_cursor = BlockfileCursor{this->MaxBlockfileNum() + 1};
846 [ + - ]: 5 : m_blockfile_cursors[chain_type] = new_cursor;
847 [ + - + - : 5 : LogPrint(BCLog::BLOCKSTORAGE, "[%s] initializing blockfile cursor to %s\n", chain_type, new_cursor);
+ - ]
848 : : }
849 [ + + ]: 7159 : const int last_blockfile = m_blockfile_cursors[chain_type]->file_num;
850 : :
851 : 7159 : int nFile = last_blockfile;
852 [ + + ]: 7159 : if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
853 [ + - ]: 8 : m_blockfile_info.resize(nFile + 1);
854 : : }
855 : :
856 : 7159 : bool finalize_undo = false;
857 : 7159 : unsigned int max_blockfile_size{MAX_BLOCKFILE_SIZE};
858 : : // Use smaller blockfiles in test-only -fastprune mode - but avoid
859 : : // the possibility of having a block not fit into the block file.
860 [ - + ]: 7159 : if (m_opts.fast_prune) {
861 : 0 : max_blockfile_size = 0x10000; // 64kiB
862 [ # # ]: 0 : if (nAddSize >= max_blockfile_size) {
863 : : // dynamically adjust the blockfile size to be larger than the added size
864 : 0 : max_blockfile_size = nAddSize + 1;
865 : : }
866 : : }
867 [ - + ]: 7159 : assert(nAddSize < max_blockfile_size);
868 : :
869 [ + + ]: 7162 : while (m_blockfile_info[nFile].nSize + nAddSize >= max_blockfile_size) {
870 : : // when the undo file is keeping up with the block file, we want to flush it explicitly
871 : : // when it is lagging behind (more blocks arrive than are being connected), we let the
872 : : // undo block write case handle it
873 : 6 : finalize_undo = (static_cast<int>(m_blockfile_info[nFile].nHeightLast) ==
874 [ + - + - ]: 3 : Assert(m_blockfile_cursors[chain_type])->undo_height);
875 : :
876 : : // Try the next unclaimed blockfile number
877 : 3 : nFile = this->MaxBlockfileNum() + 1;
878 : : // Set to increment MaxBlockfileNum() for next iteration
879 [ + - ]: 3 : m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};
880 : :
881 [ + - ]: 3 : if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
882 [ + - ]: 3 : m_blockfile_info.resize(nFile + 1);
883 : : }
884 : : }
885 : 7159 : FlatFilePos pos;
886 : 7159 : pos.nFile = nFile;
887 : 7159 : pos.nPos = m_blockfile_info[nFile].nSize;
888 : :
889 [ + + ]: 7159 : if (nFile != last_blockfile) {
890 [ + - + - : 6 : LogPrint(BCLog::BLOCKSTORAGE, "Leaving block file %i: %s (onto %i) (height %i)\n",
+ - + - ]
891 : : last_blockfile, m_blockfile_info[last_blockfile].ToString(), nFile, nHeight);
892 : :
893 : : // Do not propagate the return code. The flush concerns a previous block
894 : : // and undo file that has already been written to. If a flush fails
895 : : // here, and we crash, there is no expected additional block data
896 : : // inconsistency arising from the flush failure here. However, the undo
897 : : // data may be inconsistent after a crash if the flush is called during
898 : : // a reindex. A flush error might also leave some of the data files
899 : : // untrimmed.
900 [ + - - + ]: 3 : if (!FlushBlockFile(last_blockfile, /*fFinalize=*/true, finalize_undo)) {
901 [ # # # # : 0 : LogPrintLevel(BCLog::BLOCKSTORAGE, BCLog::Level::Warning,
# # ]
902 : : "Failed to flush previous block file %05i (finalize=1, finalize_undo=%i) before opening new block file %05i\n",
903 : : last_blockfile, finalize_undo, nFile);
904 : : }
905 : : // No undo data yet in the new file, so reset our undo-height tracking.
906 [ + - ]: 3 : m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};
907 : : }
908 : :
909 : 7159 : m_blockfile_info[nFile].AddBlock(nHeight, nTime);
910 [ + - ]: 7159 : m_blockfile_info[nFile].nSize += nAddSize;
911 : :
912 : 7159 : bool out_of_space;
913 [ + - ]: 7159 : size_t bytes_allocated = m_block_file_seq.Allocate(pos, nAddSize, out_of_space);
914 [ - + ]: 7159 : if (out_of_space) {
915 [ # # # # ]: 0 : m_opts.notifications.fatalError(_("Disk space is too low!"));
916 : 0 : return {};
917 : : }
918 [ + + - + ]: 7159 : if (bytes_allocated != 0 && IsPruneMode()) {
919 : 0 : m_check_for_pruning = true;
920 : : }
921 : :
922 [ + - ]: 7159 : m_dirty_fileinfo.insert(nFile);
923 : 7159 : return pos;
924 : 7159 : }
925 : :
926 : 2 : void BlockManager::UpdateBlockInfo(const CBlock& block, unsigned int nHeight, const FlatFilePos& pos)
927 : : {
928 : 2 : LOCK(cs_LastBlockFile);
929 : :
930 : : // Update the cursor so it points to the last file.
931 : 2 : const BlockfileType chain_type{BlockfileTypeForHeight(nHeight)};
932 [ + - ]: 2 : auto& cursor{m_blockfile_cursors[chain_type]};
933 [ + - - + ]: 2 : if (!cursor || cursor->file_num < pos.nFile) {
934 [ # # ]: 0 : m_blockfile_cursors[chain_type] = BlockfileCursor{pos.nFile};
935 : : }
936 : :
937 : : // Update the file information with the current block.
938 : 2 : const unsigned int added_size = ::GetSerializeSize(TX_WITH_WITNESS(block));
939 : 2 : const int nFile = pos.nFile;
940 [ - + ]: 2 : if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
941 [ # # ]: 0 : m_blockfile_info.resize(nFile + 1);
942 : : }
943 : 2 : m_blockfile_info[nFile].AddBlock(nHeight, block.GetBlockTime());
944 [ + - ]: 2 : m_blockfile_info[nFile].nSize = std::max(pos.nPos + added_size, m_blockfile_info[nFile].nSize);
945 [ + - ]: 2 : m_dirty_fileinfo.insert(nFile);
946 : 2 : }
947 : :
948 : 6925 : bool BlockManager::FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize)
949 : : {
950 : 6925 : pos.nFile = nFile;
951 : :
952 : 6925 : LOCK(cs_LastBlockFile);
953 : :
954 [ + - ]: 6925 : pos.nPos = m_blockfile_info[nFile].nUndoSize;
955 : 6925 : m_blockfile_info[nFile].nUndoSize += nAddSize;
956 [ + - ]: 6925 : m_dirty_fileinfo.insert(nFile);
957 : :
958 : 6925 : bool out_of_space;
959 [ + - ]: 6925 : size_t bytes_allocated = m_undo_file_seq.Allocate(pos, nAddSize, out_of_space);
960 [ - + ]: 6925 : if (out_of_space) {
961 [ # # # # ]: 0 : return FatalError(m_opts.notifications, state, _("Disk space is too low!"));
962 : : }
963 [ + + - + ]: 6925 : if (bytes_allocated != 0 && IsPruneMode()) {
964 : 0 : m_check_for_pruning = true;
965 : : }
966 : :
967 : : return true;
968 : 6925 : }
969 : :
970 : 7159 : bool BlockManager::WriteBlockToDisk(const CBlock& block, FlatFilePos& pos) const
971 : : {
972 : : // Open history file to append
973 : 7159 : AutoFile fileout{OpenBlockFile(pos)};
974 [ - + ]: 7159 : if (fileout.IsNull()) {
975 [ # # ]: 0 : LogError("%s: OpenBlockFile failed\n", __func__);
976 : : return false;
977 : : }
978 : :
979 : : // Write index header
980 : 7159 : unsigned int nSize = GetSerializeSize(TX_WITH_WITNESS(block));
981 [ + - + - ]: 7159 : fileout << GetParams().MessageStart() << nSize;
982 : :
983 : : // Write block
984 [ + - ]: 7159 : long fileOutPos = ftell(fileout.Get());
985 [ - + ]: 7159 : if (fileOutPos < 0) {
986 [ # # ]: 0 : LogError("%s: ftell failed\n", __func__);
987 : : return false;
988 : : }
989 : 7159 : pos.nPos = (unsigned int)fileOutPos;
990 [ + - ]: 14318 : fileout << TX_WITH_WITNESS(block);
991 : :
992 : : return true;
993 : 7159 : }
994 : :
995 : 7049 : bool BlockManager::WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex& block)
996 : : {
997 : 7049 : AssertLockHeld(::cs_main);
998 : 7049 : const BlockfileType type = BlockfileTypeForHeight(block.nHeight);
999 [ + + + - ]: 14098 : auto& cursor = *Assert(WITH_LOCK(cs_LastBlockFile, return m_blockfile_cursors[type]));
1000 : :
1001 : : // Write undo information to disk
1002 [ + + ]: 7049 : if (block.GetUndoPos().IsNull()) {
1003 : 6925 : FlatFilePos _pos;
1004 [ - + ]: 6925 : if (!FindUndoPos(state, block.nFile, _pos, ::GetSerializeSize(blockundo) + 40)) {
1005 : 0 : LogError("%s: FindUndoPos failed\n", __func__);
1006 : 0 : return false;
1007 : : }
1008 [ - + ]: 6925 : if (!UndoWriteToDisk(blockundo, _pos, block.pprev->GetBlockHash())) {
1009 [ # # ]: 0 : return FatalError(m_opts.notifications, state, _("Failed to write undo data."));
1010 : : }
1011 : : // rev files are written in block height order, whereas blk files are written as blocks come in (often out of order)
1012 : : // we want to flush the rev (undo) file once we've written the last block, which is indicated by the last height
1013 : : // in the block file info as below; note that this does not catch the case where the undo writes are keeping up
1014 : : // with the block writes (usually when a synced up node is getting newly mined blocks) -- this case is caught in
1015 : : // the FindNextBlockPos function
1016 [ - + - - ]: 6925 : if (_pos.nFile < cursor.file_num && static_cast<uint32_t>(block.nHeight) == m_blockfile_info[_pos.nFile].nHeightLast) {
1017 : : // Do not propagate the return code, a failed flush here should not
1018 : : // be an indication for a failed write. If it were propagated here,
1019 : : // the caller would assume the undo data not to be written, when in
1020 : : // fact it is. Note though, that a failed flush might leave the data
1021 : : // file untrimmed.
1022 [ # # ]: 0 : if (!FlushUndoFile(_pos.nFile, true)) {
1023 [ # # ]: 0 : LogPrintLevel(BCLog::BLOCKSTORAGE, BCLog::Level::Warning, "Failed to flush undo file %05i\n", _pos.nFile);
1024 : : }
1025 [ + - + + ]: 6925 : } else if (_pos.nFile == cursor.file_num && block.nHeight > cursor.undo_height) {
1026 : 6520 : cursor.undo_height = block.nHeight;
1027 : : }
1028 : : // update nUndoPos in block index
1029 : 6925 : block.nUndoPos = _pos.nPos;
1030 : 6925 : block.nStatus |= BLOCK_HAVE_UNDO;
1031 : 6925 : m_dirty_blockindex.insert(&block);
1032 : : }
1033 : :
1034 : : return true;
1035 : : }
1036 : :
1037 : 2239 : bool BlockManager::ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos) const
1038 : : {
1039 : 2239 : block.SetNull();
1040 : :
1041 : : // Open history file to read
1042 : 2239 : AutoFile filein{OpenBlockFile(pos, true)};
1043 [ + + ]: 2239 : if (filein.IsNull()) {
1044 [ + - + - ]: 104 : LogError("%s: OpenBlockFile failed for %s\n", __func__, pos.ToString());
1045 : 104 : return false;
1046 : : }
1047 : :
1048 : : // Read block
1049 : 2135 : try {
1050 [ + - ]: 2135 : filein >> TX_WITH_WITNESS(block);
1051 [ - - ]: 0 : } catch (const std::exception& e) {
1052 [ - - - - ]: 0 : LogError("%s: Deserialize or I/O error - %s at %s\n", __func__, e.what(), pos.ToString());
1053 : 0 : return false;
1054 : 0 : }
1055 : :
1056 : : // Check the header
1057 [ + - + - : 2135 : if (!CheckProofOfWork(block.GetHash(), block.nBits, GetConsensus())) {
+ + ]
1058 [ + - + - ]: 3 : LogError("%s: Errors in block header at %s\n", __func__, pos.ToString());
1059 : 3 : return false;
1060 : : }
1061 : :
1062 : : // Signet only: check block solution
1063 [ - + - - : 2132 : if (GetConsensus().signet_blocks && !CheckSignetBlockSolution(block, GetConsensus())) {
- - ]
1064 [ # # # # ]: 0 : LogError("%s: Errors in block solution at %s\n", __func__, pos.ToString());
1065 : 0 : return false;
1066 : : }
1067 : :
1068 : : return true;
1069 : 2239 : }
1070 : :
1071 : 2122 : bool BlockManager::ReadBlockFromDisk(CBlock& block, const CBlockIndex& index) const
1072 : : {
1073 [ + - ]: 4244 : const FlatFilePos block_pos{WITH_LOCK(cs_main, return index.GetBlockPos())};
1074 : :
1075 [ + + ]: 2122 : if (!ReadBlockFromDisk(block, block_pos)) {
1076 : : return false;
1077 : : }
1078 [ - + ]: 2018 : if (block.GetHash() != index.GetBlockHash()) {
1079 [ # # # # ]: 0 : LogError("%s: GetHash() doesn't match index for %s at %s\n", __func__, index.ToString(), block_pos.ToString());
1080 : 0 : return false;
1081 : : }
1082 : : return true;
1083 : : }
1084 : :
1085 : 0 : bool BlockManager::ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos) const
1086 : : {
1087 : 0 : FlatFilePos hpos = pos;
1088 : : // If nPos is less than 8 the pos is null and we don't have the block data
1089 : : // Return early to prevent undefined behavior of unsigned int underflow
1090 [ # # ]: 0 : if (hpos.nPos < 8) {
1091 [ # # ]: 0 : LogError("%s: OpenBlockFile failed for %s\n", __func__, pos.ToString());
1092 : 0 : return false;
1093 : : }
1094 : 0 : hpos.nPos -= 8; // Seek back 8 bytes for meta header
1095 : 0 : AutoFile filein{OpenBlockFile(hpos, true)};
1096 [ # # ]: 0 : if (filein.IsNull()) {
1097 [ # # # # ]: 0 : LogError("%s: OpenBlockFile failed for %s\n", __func__, pos.ToString());
1098 : 0 : return false;
1099 : : }
1100 : :
1101 : 0 : try {
1102 : 0 : MessageStartChars blk_start;
1103 : 0 : unsigned int blk_size;
1104 : :
1105 [ # # # # ]: 0 : filein >> blk_start >> blk_size;
1106 : :
1107 [ # # ]: 0 : if (blk_start != GetParams().MessageStart()) {
1108 [ # # # # : 0 : LogError("%s: Block magic mismatch for %s: %s versus expected %s\n", __func__, pos.ToString(),
# # # # ]
1109 : : HexStr(blk_start),
1110 : : HexStr(GetParams().MessageStart()));
1111 : 0 : return false;
1112 : : }
1113 : :
1114 [ # # ]: 0 : if (blk_size > MAX_SIZE) {
1115 [ # # # # ]: 0 : LogError("%s: Block data is larger than maximum deserialization size for %s: %s versus %s\n", __func__, pos.ToString(),
1116 : : blk_size, MAX_SIZE);
1117 : 0 : return false;
1118 : : }
1119 : :
1120 [ # # ]: 0 : block.resize(blk_size); // Zeroing of memory is intentional here
1121 [ # # ]: 0 : filein.read(MakeWritableByteSpan(block));
1122 [ - - ]: 0 : } catch (const std::exception& e) {
1123 [ - - - - ]: 0 : LogError("%s: Read from block file failed: %s for %s\n", __func__, e.what(), pos.ToString());
1124 : 0 : return false;
1125 : 0 : }
1126 : :
1127 : : return true;
1128 : 0 : }
1129 : :
1130 : 7159 : FlatFilePos BlockManager::SaveBlockToDisk(const CBlock& block, int nHeight)
1131 : : {
1132 : 7159 : unsigned int nBlockSize = ::GetSerializeSize(TX_WITH_WITNESS(block));
1133 : : // Account for the 4 magic message start bytes + the 4 length bytes (8 bytes total,
1134 : : // defined as BLOCK_SERIALIZATION_HEADER_SIZE)
1135 : 7159 : nBlockSize += static_cast<unsigned int>(BLOCK_SERIALIZATION_HEADER_SIZE);
1136 : 7159 : FlatFilePos blockPos{FindNextBlockPos(nBlockSize, nHeight, block.GetBlockTime())};
1137 [ - + ]: 7159 : if (blockPos.IsNull()) {
1138 : 0 : LogError("%s: FindNextBlockPos failed\n", __func__);
1139 : 0 : return FlatFilePos();
1140 : : }
1141 [ - + ]: 7159 : if (!WriteBlockToDisk(block, blockPos)) {
1142 [ # # ]: 0 : m_opts.notifications.fatalError(_("Failed to write block."));
1143 : 0 : return FlatFilePos();
1144 : : }
1145 : 7159 : return blockPos;
1146 : : }
1147 : :
1148 : 171 : static auto InitBlocksdirXorKey(const BlockManager::Options& opts)
1149 : : {
1150 : : // Bytes are serialized without length indicator, so this is also the exact
1151 : : // size of the XOR-key file.
1152 : 171 : std::array<std::byte, 8> xor_key{};
1153 : :
1154 [ + - + + ]: 171 : if (opts.use_xor && fs::is_empty(opts.blocks_dir)) {
1155 : : // Only use random fresh key when the boolean option is set and on the
1156 : : // very first start of the program.
1157 : 168 : FastRandomContext{}.fillrand(xor_key);
1158 : : }
1159 : :
1160 [ + - ]: 342 : const fs::path xor_key_path{opts.blocks_dir / "xor.dat"};
1161 [ + - + + ]: 171 : if (fs::exists(xor_key_path)) {
1162 : : // A pre-existing xor key file has priority.
1163 [ + - ]: 3 : AutoFile xor_key_file{fsbridge::fopen(xor_key_path, "rb")};
1164 [ + - ]: 6 : xor_key_file >> xor_key;
1165 : 3 : } else {
1166 : : // Create initial or missing xor key file
1167 : 168 : AutoFile xor_key_file{fsbridge::fopen(xor_key_path,
1168 : : #ifdef __MINGW64__
1169 : : "wb" // Temporary workaround for https://github.com/bitcoin/bitcoin/issues/30210
1170 : : #else
1171 : : "wbx"
1172 : : #endif
1173 [ + - ]: 168 : )};
1174 [ + - ]: 336 : xor_key_file << xor_key;
1175 : 168 : }
1176 : : // If the user disabled the key, it must be zero.
1177 [ - + - - ]: 171 : if (!opts.use_xor && xor_key != decltype(xor_key){}) {
1178 : 0 : throw std::runtime_error{
1179 [ # # ]: 0 : strprintf("The blocksdir XOR-key can not be disabled when a random key was already stored! "
1180 : : "Stored key: '%s', stored path: '%s'.",
1181 [ # # ]: 0 : HexStr(xor_key), fs::PathToString(xor_key_path)),
1182 [ # # # # ]: 0 : };
1183 : : }
1184 [ + - + - : 513 : LogInfo("Using obfuscation key for blocksdir *.dat files (%s): '%s'\n", fs::PathToString(opts.blocks_dir), HexStr(xor_key));
+ - ]
1185 [ + - ]: 171 : return std::vector<std::byte>{xor_key.begin(), xor_key.end()};
1186 : 171 : }
1187 : :
1188 : 171 : BlockManager::BlockManager(const util::SignalInterrupt& interrupt, Options opts)
1189 : 171 : : m_prune_mode{opts.prune_target > 0},
1190 [ + - ]: 171 : m_xor_key{InitBlocksdirXorKey(opts)},
1191 [ + - ]: 171 : m_opts{std::move(opts)},
1192 [ + - + - : 342 : m_block_file_seq{FlatFileSeq{m_opts.blocks_dir, "blk", m_opts.fast_prune ? 0x4000 /* 16kB */ : BLOCKFILE_CHUNK_SIZE}},
+ - ]
1193 [ + - + - ]: 171 : m_undo_file_seq{FlatFileSeq{m_opts.blocks_dir, "rev", UNDOFILE_CHUNK_SIZE}},
1194 [ + - + - ]: 342 : m_interrupt{interrupt} {}
1195 : :
1196 : : class ImportingNow
1197 : : {
1198 : : std::atomic<bool>& m_importing;
1199 : :
1200 : : public:
1201 : 0 : ImportingNow(std::atomic<bool>& importing) : m_importing{importing}
1202 : : {
1203 [ # # ]: 0 : assert(m_importing == false);
1204 : 0 : m_importing = true;
1205 : 0 : }
1206 : 0 : ~ImportingNow()
1207 : : {
1208 [ # # ]: 0 : assert(m_importing == true);
1209 : 0 : m_importing = false;
1210 : 0 : }
1211 : : };
1212 : :
1213 : 0 : void ImportBlocks(ChainstateManager& chainman, std::vector<fs::path> vImportFiles)
1214 : : {
1215 : 0 : ImportingNow imp{chainman.m_blockman.m_importing};
1216 : :
1217 : : // -reindex
1218 [ # # ]: 0 : if (!chainman.m_blockman.m_blockfiles_indexed) {
1219 : 0 : int nFile = 0;
1220 : : // Map of disk positions for blocks with unknown parent (only used for reindex);
1221 : : // parent hash -> child disk position, multiple children can have the same parent.
1222 : 0 : std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
1223 : 0 : while (true) {
1224 [ # # ]: 0 : FlatFilePos pos(nFile, 0);
1225 [ # # # # ]: 0 : if (!fs::exists(chainman.m_blockman.GetBlockPosFilename(pos))) {
1226 : : break; // No block files left to reindex
1227 : : }
1228 [ # # ]: 0 : AutoFile file{chainman.m_blockman.OpenBlockFile(pos, true)};
1229 [ # # ]: 0 : if (file.IsNull()) {
1230 : : break; // This error is logged in OpenBlockFile
1231 : : }
1232 [ # # ]: 0 : LogPrintf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);
1233 [ # # ]: 0 : chainman.LoadExternalBlockFile(file, &pos, &blocks_with_unknown_parent);
1234 [ # # # # ]: 0 : if (chainman.m_interrupt) {
1235 [ # # ]: 0 : LogPrintf("Interrupt requested. Exit %s\n", __func__);
1236 : 0 : return;
1237 : : }
1238 : 0 : nFile++;
1239 : 0 : }
1240 [ # # # # ]: 0 : WITH_LOCK(::cs_main, chainman.m_blockman.m_block_tree_db->WriteReindexing(false));
1241 [ # # ]: 0 : chainman.m_blockman.m_blockfiles_indexed = true;
1242 [ # # ]: 0 : LogPrintf("Reindexing finished\n");
1243 : : // To avoid ending up in a situation without genesis block, re-try initializing (no-op if reindexing worked):
1244 [ # # # # ]: 0 : chainman.ActiveChainstate().LoadGenesisBlock();
1245 : 0 : }
1246 : :
1247 : : // -loadblock=
1248 [ # # ]: 0 : for (const fs::path& path : vImportFiles) {
1249 [ # # ]: 0 : AutoFile file{fsbridge::fopen(path, "rb")};
1250 [ # # ]: 0 : if (!file.IsNull()) {
1251 [ # # # # ]: 0 : LogPrintf("Importing blocks file %s...\n", fs::PathToString(path));
1252 [ # # ]: 0 : chainman.LoadExternalBlockFile(file);
1253 [ # # # # ]: 0 : if (chainman.m_interrupt) {
1254 [ # # ]: 0 : LogPrintf("Interrupt requested. Exit %s\n", __func__);
1255 : 0 : return;
1256 : : }
1257 : : } else {
1258 [ # # # # ]: 0 : LogPrintf("Warning: Could not open blocks file %s\n", fs::PathToString(path));
1259 : : }
1260 : 0 : }
1261 : :
1262 : : // scan for better chains in the block chain database, that are not yet connected in the active best chain
1263 : :
1264 : : // We can't hold cs_main during ActivateBestChain even though we're accessing
1265 : : // the chainman unique_ptrs since ABC requires us not to be holding cs_main, so retrieve
1266 : : // the relevant pointers before the ABC call.
1267 [ # # # # : 0 : for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
# # ]
1268 [ # # ]: 0 : BlockValidationState state;
1269 [ # # # # : 0 : if (!chainstate->ActivateBestChain(state, nullptr)) {
# # ]
1270 [ # # # # : 0 : chainman.GetNotifications().fatalError(strprintf(_("Failed to connect best block (%s)."), state.ToString()));
# # # # ]
1271 : 0 : return;
1272 : : }
1273 : 0 : }
1274 : : // End scope of ImportingNow
1275 : 0 : }
1276 : :
1277 : 5 : std::ostream& operator<<(std::ostream& os, const BlockfileType& type) {
1278 [ - + - ]: 5 : switch(type) {
1279 : 0 : case BlockfileType::NORMAL: os << "normal"; break;
1280 : 5 : case BlockfileType::ASSUMED: os << "assumed"; break;
1281 : 0 : default: os.setstate(std::ios_base::failbit);
1282 : : }
1283 : 5 : return os;
1284 : : }
1285 : :
1286 : 5 : std::ostream& operator<<(std::ostream& os, const BlockfileCursor& cursor) {
1287 [ + - ]: 5 : os << strprintf("BlockfileCursor(file_num=%d, undo_height=%d)", cursor.file_num, cursor.undo_height);
1288 : 5 : return os;
1289 : : }
1290 : : } // namespace node
|
