Where validation becomes chain state

5501    } else {
5502        // Otherwise, flush state to disk and deallocate the in-memory coins map.
5503        ret = FlushStateToDisk(state, FlushStateMode::FORCE_FLUSH);
5504    }
5505    return ret;
5506}
5507
5508double ChainstateManager::GuessVerificationProgress(const CBlockIndex* pindex) const
5509{
5510    AssertLockHeld(GetMutex());
5511    const ChainTxData& data{GetParams().TxData()};
5512    if (pindex == nullptr) {
5513        return 0.0;
5514    }
5515
5516    if (pindex->m_chain_tx_count == 0) {
5517        LogDebug(BCLog::VALIDATION, "Block %d has unset m_chain_tx_count. Unable to estimate verification progress.\n", pindex->nHeight);
5518        return 0.0;
5519    }
5520
5521    const int64_t nNow{TicksSinceEpoch<std::chrono::seconds>(NodeClock::now())};
5522    const auto block_time{
5523        (Assume(m_best_header) && std::abs(nNow - pindex->GetBlockTime()) <= Ticks<std::chrono::seconds>(2h) &&
5524         Assume(m_best_header->nHeight >= pindex->nHeight)) ?
5525            // When the header is known to be recent, switch to a height-based
5526            // approach. This ensures the returned value is quantized when
5527            // close to "1.0", because some users expect it to be. This also
5528            // avoids relying too much on the exact miner-set timestamp, which
5529            // may be off.
5530            nNow - (m_best_header->nHeight - pindex->nHeight) * GetConsensus().nPowTargetSpacing :
5531            pindex->GetBlockTime(),
5532    };
5533
5534    double fTxTotal;
5535
5536    if (pindex->m_chain_tx_count <= data.tx_count) {
5537        fTxTotal = data.tx_count + (nNow - data.nTime) * data.dTxRate;
5538    } else {
5539        fTxTotal = pindex->m_chain_tx_count + (nNow - block_time) * data.dTxRate;
5540    }
5541
5542    return std::min<double>(pindex->m_chain_tx_count / fTxTotal, 1.0);
5543}
5544
5545double ChainstateManager::GetBackgroundVerificationProgress(const CBlockIndex& pindex) const
5546{
5547    AssertLockHeld(GetMutex());
5548    Assert(HistoricalChainstate());
5549    auto target_block = HistoricalChainstate()->TargetBlock();
5550
5551    if (pindex.m_chain_tx_count == 0 || target_block->m_chain_tx_count == 0) {
5552        LogDebug(BCLog::VALIDATION, "[background validation] Block %d has unset m_chain_tx_count. Unable to estimate verification progress.", pindex.nHeight);
5553        return 0.0;
5554    }
5555    return static_cast<double>(pindex.m_chain_tx_count) / static_cast<double>(target_block->m_chain_tx_count);
5556}
5557
5558Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool)
5559{
5560    AssertLockHeld(::cs_main);
5561    assert(m_chainstates.empty());
5562    m_chainstates.emplace_back(std::make_unique<Chainstate>(mempool, m_blockman, *this));
5563    return *m_chainstates.back();
5564}
5565
5566[[nodiscard]] static bool DeleteCoinsDBFromDisk(const fs::path db_path, bool is_snapshot)
5567    EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
5568{
5569    AssertLockHeld(::cs_main);
5570
5571    if (is_snapshot) {
5572        fs::path base_blockhash_path = db_path / node::SNAPSHOT_BLOCKHASH_FILENAME;
5573
5574        try {
5575            bool existed = fs::remove(base_blockhash_path);
5576            if (!existed) {
5577                LogWarning("[snapshot] snapshot chainstate dir being removed lacks %s file",
5578                          fs::PathToString(node::SNAPSHOT_BLOCKHASH_FILENAME));
5579            }
5580        } catch (const fs::filesystem_error& e) {
5581            LogWarning("[snapshot] failed to remove file %s: %s\n",
5582                       fs::PathToString(base_blockhash_path), e.code().message());
5583        }
5584    }
5585
5586    std::string path_str = fs::PathToString(db_path);
5587    LogInfo("Removing leveldb dir at %s\n", path_str);
5588
5589    // We have to destruct before this call leveldb::DB in order to release the db
5590    // lock, otherwise `DestroyDB` will fail. See `leveldb::~DBImpl()`.
5591    const bool destroyed = DestroyDB(path_str);
5592
5593    if (!destroyed) {
5594        LogError("leveldb DestroyDB call failed on %s", path_str);
5595    }
5596
5597    // Datadir should be removed from filesystem; otherwise initialization may detect
5598    // it on subsequent statups and get confused.
5599    //
5600    // If the base_blockhash_path removal above fails in the case of snapshot
5601    // chainstates, this will return false since leveldb won't remove a non-empty
5602    // directory.
5603    return destroyed && !fs::exists(db_path);
5604}
5605
5606util::Result<CBlockIndex*> ChainstateManager::ActivateSnapshot(
5607        AutoFile& coins_file,
5608        const SnapshotMetadata& metadata,
5609        bool in_memory)
5610{
5611    uint256 base_blockhash = metadata.m_base_blockhash;
5612
5613    CBlockIndex* snapshot_start_block{};
5614
5615    {
5616        LOCK(::cs_main);
5617
5618        if (this->CurrentChainstate().m_from_snapshot_blockhash) {
5619            return util::Error{Untranslated("Can't activate a snapshot-based chainstate more than once")};
5620        }
5621        if (!GetParams().AssumeutxoForBlockhash(base_blockhash).has_value()) {
5622            auto available_heights = GetParams().GetAvailableSnapshotHeights();
5623            std::string heights_formatted = util::Join(available_heights, ", ", [&](const auto& i) { return util::ToString(i); });
5624            return util::Error{Untranslated(strprintf("assumeutxo block hash in snapshot metadata not recognized (hash: %s). The following snapshot heights are available: %s",
5625                base_blockhash.ToString(),
5626                heights_formatted))};
5627        }
5628
5629        snapshot_start_block = m_blockman.LookupBlockIndex(base_blockhash);
5630        if (!snapshot_start_block) {
5631            return util::Error{Untranslated(strprintf("The base block header (%s) must appear in the headers chain. Make sure all headers are syncing, and call loadtxoutset again",
5632                          base_blockhash.ToString()))};
5633        }
5634
5635        bool start_block_invalid = snapshot_start_block->nStatus & BLOCK_FAILED_VALID;
5636        if (start_block_invalid) {
5637            return util::Error{Untranslated(strprintf("The base block header (%s) is part of an invalid chain", base_blockhash.ToString()))};
5638        }
5639
5640        if (!m_best_header || m_best_header->GetAncestor(snapshot_start_block->nHeight) != snapshot_start_block) {
5641            return util::Error{Untranslated("A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo.")};
5642        }
5643
5644        auto mempool{CurrentChainstate().GetMempool()};
5645        if (mempool && mempool->size() > 0) {
5646            return util::Error{Untranslated("Can't activate a snapshot when mempool not empty")};
5647        }
5648    }
5649
5650    int64_t current_coinsdb_cache_size{0};
5651    int64_t current_coinstip_cache_size{0};
5652
5653    // Cache percentages to allocate to each chainstate.
5654    //
5655    // These particular percentages don't matter so much since they will only be
5656    // relevant during snapshot activation; caches are rebalanced at the conclusion of
5657    // this function. We want to give (essentially) all available cache capacity to the
5658    // snapshot to aid the bulk load later in this function.
5659    static constexpr double IBD_CACHE_PERC = 0.01;
5660    static constexpr double SNAPSHOT_CACHE_PERC = 0.99;
5661
5662    {
5663        LOCK(::cs_main);
5664        // Resize the coins caches to ensure we're not exceeding memory limits.
5665        //
5666        // Allocate the majority of the cache to the incoming snapshot chainstate, since
5667        // (optimistically) getting to its tip will be the top priority. We'll need to call
5668        // `MaybeRebalanceCaches()` once we're done with this function to ensure
5669        // the right allocation (including the possibility that no snapshot was activated
5670        // and that we should restore the active chainstate caches to their original size).
5671        //
5672        current_coinsdb_cache_size = this->ActiveChainstate().m_coinsdb_cache_size_bytes;
5673        current_coinstip_cache_size = this->ActiveChainstate().m_coinstip_cache_size_bytes;
5674
5675        // Temporarily resize the active coins cache to make room for the newly-created
5676        // snapshot chain.
5677        this->ActiveChainstate().ResizeCoinsCaches(
5678            static_cast<size_t>(current_coinstip_cache_size * IBD_CACHE_PERC),
5679            static_cast<size_t>(current_coinsdb_cache_size * IBD_CACHE_PERC));
5680    }
5681
5682    auto snapshot_chainstate = WITH_LOCK(::cs_main,
5683        return std::make_unique<Chainstate>(
5684            /*mempool=*/nullptr, m_blockman, *this, base_blockhash));
5685
5686    {
5687        LOCK(::cs_main);
5688        snapshot_chainstate->InitCoinsDB(
5689            static_cast<size_t>(current_coinsdb_cache_size * SNAPSHOT_CACHE_PERC),
5690            in_memory, /*should_wipe=*/false);
5691        snapshot_chainstate->InitCoinsCache(
5692            static_cast<size_t>(current_coinstip_cache_size * SNAPSHOT_CACHE_PERC));
5693    }
5694
5695    auto cleanup_bad_snapshot = [&](bilingual_str reason) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
5696        this->MaybeRebalanceCaches();
5697
5698        // PopulateAndValidateSnapshot can return (in error) before the leveldb datadir
5699        // has been created, so only attempt removal if we got that far.
5700        if (auto snapshot_datadir = node::FindAssumeutxoChainstateDir(m_options.datadir)) {
5701            // We have to destruct leveldb::DB in order to release the db lock, otherwise
5702            // DestroyDB() (in DeleteCoinsDBFromDisk()) will fail. See `leveldb::~DBImpl()`.
5703            // Destructing the chainstate (and so resetting the coinsviews object) does this.
5704            snapshot_chainstate.reset();
5705            bool removed = DeleteCoinsDBFromDisk(*snapshot_datadir, /*is_snapshot=*/true);
5706            if (!removed) {
5707                GetNotifications().fatalError(strprintf(_("Failed to remove snapshot chainstate dir (%s). "
5708                    "Manually remove it before restarting.\n"), fs::PathToString(*snapshot_datadir)));
5709            }
5710        }
5711        return util::Error{std::move(reason)};
5712    };
5713
5714    if (auto res{this->PopulateAndValidateSnapshot(*snapshot_chainstate, coins_file, metadata)}; !res) {
5715        LOCK(::cs_main);
5716        return cleanup_bad_snapshot(Untranslated(strprintf("Population failed: %s", util::ErrorString(res).original)));
5717    }
5718
5719    LOCK(::cs_main);  // cs_main required for rest of snapshot activation.
5720
5721    // Do a final check to ensure that the snapshot chainstate is actually a more
5722    // work chain than the active chainstate; a user could have loaded a snapshot
5723    // very late in the IBD process, and we wouldn't want to load a useless chainstate.
5724    if (!CBlockIndexWorkComparator()(ActiveTip(), snapshot_chainstate->m_chain.Tip())) {
5725        return cleanup_bad_snapshot(Untranslated("work does not exceed active chainstate"));
5726    }
5727    // If not in-memory, persist the base blockhash for use during subsequent
5728    // initialization.
5729    if (!in_memory) {
5730        if (!node::WriteSnapshotBaseBlockhash(*snapshot_chainstate)) {
5731            return cleanup_bad_snapshot(Untranslated("could not write base blockhash"));
5732        }
5733    }
5734
5735    Chainstate& chainstate{AddChainstate(std::move(snapshot_chainstate))};
5736    m_blockman.m_snapshot_height = Assert(chainstate.SnapshotBase())->nHeight;
5737
5738    chainstate.PopulateBlockIndexCandidates();
5739
5740    LogInfo("[snapshot] successfully activated snapshot %s", base_blockhash.ToString());
5741    LogInfo("[snapshot] (%.2f MB)",
5742              chainstate.CoinsTip().DynamicMemoryUsage() / (1000 * 1000));
5743
5744    this->MaybeRebalanceCaches();
5745    return snapshot_start_block;
5746}
5747
5748static void FlushSnapshotToDisk(CCoinsViewCache& coins_cache, bool snapshot_loaded)
5749{
5750    LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(