251    }
252
253    m_dirty_blockindex.insert(pindexNew);
254
255    return pindexNew;
256}
257
258void BlockManager::AddUnlinkedBlock(CBlockIndex* block)
259{
260    AssertLockHeld(cs_main);
261    Assume(block != nullptr);
262    Assume(block->nStatus & BLOCK_HAVE_DATA);
263    auto range = m_blocks_unlinked.equal_range(block->pprev);
264    for (auto it = range.first; it != range.second; ++it) {
265        if (it->second == block) return;  // don't insert duplicates
266    }
267    m_blocks_unlinked.emplace(block->pprev, block);
268}
269
270void BlockManager::PruneOneBlockFile(const int fileNumber)
271{
272    AssertLockHeld(cs_main);
273
274    for (auto& entry : m_block_index) {
275        CBlockIndex* pindex = &entry.second;
276        if (pindex->nFile == fileNumber) {
277            pindex->nStatus &= ~BLOCK_HAVE_DATA;
278            pindex->nStatus &= ~BLOCK_HAVE_UNDO;
279            pindex->nFile = 0;
280            pindex->nDataPos = 0;
281            pindex->nUndoPos = 0;
282            m_dirty_blockindex.insert(pindex);
283
284            // Prune from m_blocks_unlinked -- any block we prune would have
285            // to be downloaded again in order to consider its chain, at which
286            // point it would be considered as a candidate for
287            // m_blocks_unlinked or setBlockIndexCandidates.
288            auto range = m_blocks_unlinked.equal_range(pindex->pprev);
289            while (range.first != range.second) {
290                std::multimap<CBlockIndex*, CBlockIndex*>::iterator _it = range.first;
291                range.first++;
292                if (_it->second == pindex) {
293                    m_blocks_unlinked.erase(_it);
294                }
295            }
296        }
297    }
298
299    m_blockfile_info.at(fileNumber) = CBlockFileInfo{};
300    m_dirty_fileinfo.insert(fileNumber);
301}
302
303void BlockManager::FindFilesToPruneManual(
304    std::set<int>& setFilesToPrune,
305    int nManualPruneHeight,
306    const Chainstate& chain)
307{
308    assert(IsPruneMode() && nManualPruneHeight > 0);
309
310    LOCK(::cs_main);
311    if (chain.m_chain.Height() < 0) {
312        return;
313    }
314
315    const auto [min_block_to_prune, last_block_can_prune] = chain.GetPruneRange(nManualPruneHeight);
316
317    int count = 0;
318    for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {
319        const auto& fileinfo = m_blockfile_info[fileNumber];
320        if (fileinfo.nSize == 0 || fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
321            continue;
322        }
323
324        PruneOneBlockFile(fileNumber);
325        setFilesToPrune.insert(fileNumber);
326        count++;
327    }
328    LogInfo("[%s] Prune (Manual): prune_height=%d removed %d blk/rev pairs",
329        chain.GetRole(), last_block_can_prune, count);
330}
331
332void BlockManager::FindFilesToPrune(
333    std::set<int>& setFilesToPrune,
334    int last_prune,
335    const Chainstate& chain,
336    ChainstateManager& chainman)
337{
338    LOCK(::cs_main);
339    // Compute `target` value with maximum size (in bytes) of blocks below the
340    // `last_prune` height which should be preserved and not pruned. The
341    // `target` value will be derived from the -prune preference provided by the
342    // user. If there is a historical chainstate being used to populate indexes
343    // and validate the snapshot, the target is divided by two so half of the
344    // block storage will be reserved for the historical chainstate, and the
345    // other half will be reserved for the most-work chainstate.
346    const int num_chainstates{chainman.HistoricalChainstate() ? 2 : 1};
347    const auto target = std::max(
348        MIN_DISK_SPACE_FOR_BLOCK_FILES, GetPruneTarget() / num_chainstates);
349    const uint64_t target_sync_height = chainman.m_best_header->nHeight;
350
351    if (chain.m_chain.Height() < 0 || target == 0) {
352        return;
353    }
354    if (static_cast<uint64_t>(chain.m_chain.Height()) <= chainman.GetParams().PruneAfterHeight()) {
355        return;
356    }
357
358    const auto [min_block_to_prune, last_block_can_prune] = chain.GetPruneRange(last_prune);
359
360    uint64_t nCurrentUsage = CalculateCurrentUsage();
361    // We don't check to prune until after we've allocated new space for files
362    // So we should leave a buffer under our target to account for another allocation
363    // before the next pruning.
364    uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
365    uint64_t nBytesToPrune;
366    int count = 0;
367
368    if (nCurrentUsage + nBuffer >= target) {
369        // On a prune event, the chainstate DB is flushed.
370        // To avoid excessive prune events negating the benefit of high dbcache
371        // values, we should not prune too rapidly.
372        // So when pruning in IBD, increase the buffer to avoid a re-prune too soon.
373        const auto chain_tip_height = chain.m_chain.Height();
374        if (chainman.IsInitialBlockDownload() && target_sync_height > (uint64_t)chain_tip_height) {
375            // Since this is only relevant during IBD, we assume blocks are at least 1 MB on average
376            static constexpr uint64_t average_block_size = 1000000;  /* 1 MB */
377            const uint64_t remaining_blocks = target_sync_height - chain_tip_height;
378            nBuffer += average_block_size * remaining_blocks;
379        }
380
381        for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {
382            const auto& fileinfo = m_blockfile_info[fileNumber];
383            nBytesToPrune = fileinfo.nSize + fileinfo.nUndoSize;
384
385            if (fileinfo.nSize == 0) {
386                continue;
387            }
388
389            if (nCurrentUsage + nBuffer < target) { // are we below our target?
390                break;
391            }
392
393            // don't prune files that could have a block that's not within the allowable
394            // prune range for the chain being pruned.
395            if (fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
396                continue;
397            }
398
399            PruneOneBlockFile(fileNumber);
400            // Queue up the files for removal
401            setFilesToPrune.insert(fileNumber);
402            nCurrentUsage -= nBytesToPrune;
403            count++;
404        }
405    }
406
407    LogDebug(BCLog::PRUNE, "[%s] target=%dMiB actual=%dMiB diff=%dMiB min_height=%d max_prune_height=%d removed %d blk/rev pairs\n",
408             chain.GetRole(), target / 1_MiB, nCurrentUsage / 1_MiB,
409             (int64_t(target) - int64_t(nCurrentUsage)) / int64_t(1_MiB),
410             min_block_to_prune, last_block_can_prune, count);
411}
412
413void BlockManager::UpdatePruneLock(const std::string& name, const PruneLockInfo& lock_info) {
414    AssertLockHeld(::cs_main);
415    m_prune_locks[name] = lock_info;
416}
417
418bool BlockManager::DeletePruneLock(const std::string& name)
419{
420    AssertLockHeld(::cs_main);
421    return m_prune_locks.erase(name) > 0;
422}
423
424CBlockIndex* BlockManager::InsertBlockIndex(const uint256& hash)
425{
426    AssertLockHeld(cs_main);
427
428    if (hash.IsNull()) {
429        return nullptr;
430    }
431
432    const auto [mi, inserted]{m_block_index.try_emplace(hash)};
433    CBlockIndex* pindex = &(*mi).second;
434    if (inserted) {
435        pindex->phashBlock = &((*mi).first);
436    }
437    return pindex;
438}
439
440bool BlockManager::LoadBlockIndex(const std::optional<uint256>& snapshot_blockhash)
441{
442    if (!m_block_tree_db->LoadBlockIndexGuts(
443            GetConsensus(), [this](const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return this->InsertBlockIndex(hash); }, m_interrupt)) {
444        return false;
445    }
446
447    if (snapshot_blockhash) {
448        const std::optional<AssumeutxoData> maybe_au_data = GetParams().AssumeutxoForBlockhash(*snapshot_blockhash);
449        if (!maybe_au_data) {
450            m_opts.notifications.fatalError(strprintf(_("Assumeutxo data not found for the given blockhash '%s'."), snapshot_blockhash->ToString()));
451            return false;
452        }
453        const AssumeutxoData& au_data = *Assert(maybe_au_data);
454        m_snapshot_height = au_data.height;
455        CBlockIndex* base{LookupBlockIndex(*snapshot_blockhash)};
456
457        // Since m_chain_tx_count (responsible for estimated progress) isn't persisted
458        // to disk, we must bootstrap the value for assumedvalid chainstates
459        // from the hardcoded assumeutxo chainparams.
460        base->m_chain_tx_count = au_data.m_chain_tx_count;
461        LogInfo("[snapshot] set m_chain_tx_count=%d for %s", au_data.m_chain_tx_count, snapshot_blockhash->ToString());
462    } else {
463        // If this isn't called with a snapshot blockhash, make sure the cached snapshot height
464        // is null. This is relevant during snapshot completion, when the blockman may be loaded
465        // with a height that then needs to be cleared after the snapshot is fully validated.
466        m_snapshot_height.reset();
467    }
468
469    Assert(m_snapshot_height.has_value() == snapshot_blockhash.has_value());
470
471    // Calculate nChainWork
472    std::vector<CBlockIndex*> vSortedByHeight{GetAllBlockIndices()};
473    std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
474              CBlockIndexHeightOnlyComparator());
475
476    CBlockIndex* previous_index{nullptr};
477    for (CBlockIndex* pindex : vSortedByHeight) {
478        if (m_interrupt) return false;
479        if (previous_index && pindex->nHeight > previous_index->nHeight + 1) {
480            LogError("%s: block index is non-contiguous, index of height %d missing\n", __func__, previous_index->nHeight + 1);
481            return false;
482        }
483        previous_index = pindex;
484        pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) + GetBlockProof(*pindex);
485        pindex->nTimeMax = (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime) : pindex->nTime);
486
487        // We can link the chain of blocks for which we've received transactions at some point, or
488        // blocks that are assumed-valid on the basis of snapshot load (see
489        // PopulateAndValidateSnapshot()).
490        // Pruned nodes may have deleted the block.
491        if (pindex->nTx > 0) {
492            if (pindex->pprev) {
493                if (m_snapshot_height && pindex->nHeight == *m_snapshot_height &&
494                        pindex->GetBlockHash() == *snapshot_blockhash) {
495                    // Should have been set above; don't disturb it with code below.
496                    Assert(pindex->m_chain_tx_count > 0);
497                } else if (pindex->pprev->m_chain_tx_count > 0) {
498                    pindex->m_chain_tx_count = pindex->pprev->m_chain_tx_count + pindex->nTx;
499                } else {
500                    pindex->m_chain_tx_count = 0;