Where validation becomes chain state

2751            if (!setFilesToPrune.empty()) {
2752                fFlushForPrune = true;
2753                if (!m_blockman.m_have_pruned) {
2754                    m_blockman.m_block_tree_db->WriteFlag("prunedblockfiles", true);
2755                    m_blockman.m_have_pruned = true;
2756                }
2757            }
2758        }
2759        const auto nNow{NodeClock::now()};
2760        // The cache is large and we're within 10% and 10 MiB of the limit, but we have time now (not in the middle of a block processing).
2761        bool fCacheLarge = mode == FlushStateMode::PERIODIC && cache_state >= CoinsCacheSizeState::LARGE;
2762        // The cache is over the limit, we have to write now.
2763        bool fCacheCritical = mode == FlushStateMode::IF_NEEDED && cache_state >= CoinsCacheSizeState::CRITICAL;
2764        // It's been a while since we wrote the block index and chain state to disk. Do this frequently, so we don't need to redownload or reindex after a crash.
2765        bool fPeriodicWrite = mode == FlushStateMode::PERIODIC && nNow >= m_next_write;
2766        const auto empty_cache{(mode == FlushStateMode::FORCE_FLUSH) || fCacheLarge || fCacheCritical};
2767        // Combine all conditions that result in a write to disk.
2768        bool should_write = (mode == FlushStateMode::FORCE_SYNC) || empty_cache || fPeriodicWrite || fFlushForPrune;
2769        // Write blocks, block index and best chain related state to disk.
2770        if (should_write) {
2771            LogDebug(BCLog::COINDB, "Writing chainstate to disk: flush mode=%s, prune=%d, large=%d, critical=%d, periodic=%d",
2772                     FlushStateModeNames[size_t(mode)], fFlushForPrune, fCacheLarge, fCacheCritical, fPeriodicWrite);
2773
2774            // Ensure we can write block index
2775            if (!CheckDiskSpace(m_blockman.m_opts.blocks_dir)) {
2776                return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!"));
2777            }
2778            {
2779                LOG_TIME_MILLIS_WITH_CATEGORY("write block and undo data to disk", BCLog::BENCH);
2780
2781                // First make sure all block and undo data is flushed to disk.
2782                // TODO: Handle return error, or add detailed comment why it is
2783                // safe to not return an error upon failure.
2784                if (!m_blockman.FlushChainstateBlockFile(m_chain.Height())) {
2785                    LogWarning("%s: Failed to flush block file.\n", __func__);
2786                }
2787            }
2788
2789            // Then update all block file information (which may refer to block and undo files).
2790            {
2791                LOG_TIME_MILLIS_WITH_CATEGORY("write block index to disk", BCLog::BENCH);
2792
2793                m_blockman.WriteBlockIndexDB();
2794            }
2795            // Finally remove any pruned files
2796            if (fFlushForPrune) {
2797                LOG_TIME_MILLIS_WITH_CATEGORY("unlink pruned files", BCLog::BENCH);
2798
2799                m_blockman.UnlinkPrunedFiles(setFilesToPrune);
2800            }
2801
2802            if (!CoinsTip().GetBestBlock().IsNull()) {
2803                // Typical Coin structures on disk are around 48 bytes in size.
2804                // Pushing a new one to the database can cause it to be written
2805                // twice (once in the log, and once in the tables). This is already
2806                // an overestimation, as most will delete an existing entry or
2807                // overwrite one. Still, use a conservative safety factor of 2.
2808                if (!CheckDiskSpace(m_chainman.m_options.datadir, 48 * 2 * 2 * CoinsTip().GetDirtyCount())) {
2809                    return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!"));
2810                }
2811                // Flush the chainstate (which may refer to block index entries).
2812                empty_cache ? CoinsTip().Flush() : CoinsTip().Sync();
2813                m_last_flushed_block = m_blockman.LookupBlockIndex(CoinsTip().GetBestBlock());
2814                full_flush_completed = true;
2815                TRACEPOINT(utxocache, flush,
2816                    int64_t{Ticks<std::chrono::microseconds>(NodeClock::now() - nNow)},
2817                    (uint32_t)mode,
2818                    (uint64_t)coins_count,
2819                    (uint64_t)coins_mem_usage,
2820                    (bool)fFlushForPrune);
2821            }
2822        }
2823
2824        if (should_write || m_next_write == NodeClock::time_point::max()) {
2825            constexpr auto range{DATABASE_WRITE_INTERVAL_MAX - DATABASE_WRITE_INTERVAL_MIN};
2826            m_next_write = FastRandomContext().rand_uniform_delay(NodeClock::now() + DATABASE_WRITE_INTERVAL_MIN, range);
2827        }
2828    }
2829    if (full_flush_completed) {
2830        if (m_chainman.m_options.signals) {
2831            m_chainman.m_options.signals->ChainStateFlushed(this->GetRole(), GetLocator(m_last_flushed_block));
2832        }
2833
2834        if (!m_chainman.m_interrupt && ShouldCompactChainstate(m_chainman.IsInitialBlockDownload())) {
2835            try {
2836                CoinsDB().CompactFullAsync();
2837            } catch (const std::exception& e) {
2838                LogWarning("Failed to start chainstate compaction (%s)", e.what());
2839            }
2840        }
2841    }
2842    } catch (const std::runtime_error& e) {
2843        return FatalError(m_chainman.GetNotifications(), state, strprintf(_("System error while flushing: %s"), e.what()));
2844    }
2845    return true;
2846}
2847
2848void Chainstate::ForceFlushStateToDisk(bool wipe_cache)
2849{
2850    BlockValidationState state;
2851    if (!this->FlushStateToDisk(state, wipe_cache ? FlushStateMode::FORCE_FLUSH : FlushStateMode::FORCE_SYNC)) {
2852        LogWarning("Failed to force flush state (%s)", state.ToString());
2853    }
2854}
2855
2856void Chainstate::PruneAndFlush()
2857{
2858    BlockValidationState state;
2859    m_blockman.m_check_for_pruning = true;
2860    if (!this->FlushStateToDisk(state, FlushStateMode::NONE)) {
2861        LogWarning("Failed to flush state (%s)", state.ToString());
2862    }
2863}
2864
2865static void UpdateTipLog(
2866    const ChainstateManager& chainman,
2867    const CCoinsViewCache& coins_tip,
2868    const CBlockIndex* tip,
2869    const std::string& func_name,
2870    const std::string& prefix,
2871    const std::string& warning_messages,
2872    const bool background_validation) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
2873{
2874
2875    AssertLockHeld(::cs_main);
2876
2877    // Disable rate limiting as this may log frequently during IBD.
2878    LogInfo(util::log::NO_RATE_LIMIT, "%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",
2879                   prefix, func_name,
2880                   tip->GetBlockHash().ToString(), tip->nHeight, tip->nVersion,
2881                   log(tip->nChainWork.getdouble()) / log(2.0), tip->m_chain_tx_count,
2882                   FormatISO8601DateTime(tip->GetBlockTime()),
2883                   background_validation ? chainman.GetBackgroundVerificationProgress(*tip) : chainman.GuessVerificationProgress(tip),
2884                   coins_tip.DynamicMemoryUsage() / double(1_MiB),
2885                   coins_tip.GetCacheSize(),
2886                   !warning_messages.empty() ? strprintf(" warning='%s'", warning_messages) : "");
2887}
2888
2889void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
2890{
2891    AssertLockHeld(::cs_main);
2892    const auto& coins_tip = this->CoinsTip();
2893
2894    // The remainder of the function isn't relevant if we are not acting on
2895    // the active chainstate, so return if need be.
2896    if (this != &m_chainman.ActiveChainstate()) {
2897        // Only log every so often so that we don't bury log messages at the tip.
2898        constexpr int BACKGROUND_LOG_INTERVAL = 2000;
2899        if (pindexNew->nHeight % BACKGROUND_LOG_INTERVAL == 0) {
2900            UpdateTipLog(m_chainman, coins_tip, pindexNew, __func__, "[background validation] ", "", /*background_validation=*/true);
2901        }
2902        return;
2903    }
2904
2905    // New best block
2906    if (m_mempool) {
2907        m_mempool->AddTransactionsUpdated(1);
2908    }
2909
2910    std::vector<bilingual_str> warning_messages;
2911    if (!m_chainman.IsInitialBlockDownload()) {
2912        auto bits = m_chainman.m_versionbitscache.CheckUnknownActivations(pindexNew, m_chainman.GetParams());
2913        for (auto [bit, active] : bits) {
2914            const bilingual_str warning = strprintf(_("Unknown new rules activated (versionbit %i)"), bit);
2915            if (active) {
2916                m_chainman.GetNotifications().warningSet(kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED, warning);
2917            } else {
2918                warning_messages.push_back(warning);
2919            }
2920        }
2921    }
2922    UpdateTipLog(m_chainman, coins_tip, pindexNew, __func__, "",
2923                 util::Join(warning_messages, Untranslated(", ")).original, /*background_validation=*/false);
2924}
2925
2926/** Disconnect m_chain's tip.
2927  * After calling, the mempool will be in an inconsistent state, with
2928  * transactions from disconnected blocks being added to disconnectpool.  You
2929  * should make the mempool consistent again by calling MaybeUpdateMempoolForReorg.
2930  * with cs_main held.
2931  *
2932  * If disconnectpool is nullptr, then no disconnected transactions are added to
2933  * disconnectpool (note that the caller is responsible for mempool consistency
2934  * in any case).
2935  */
2936bool Chainstate::DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool)
2937{
2938    AssertLockHeld(cs_main);
2939    if (m_mempool) AssertLockHeld(m_mempool->cs);
2940
2941    CBlockIndex *pindexDelete = m_chain.Tip();
2942    assert(pindexDelete);
2943    assert(pindexDelete->pprev);
2944    // Read block from disk.
2945    std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
2946    CBlock& block = *pblock;
2947    if (!m_blockman.ReadBlock(block, *pindexDelete)) {
2948        LogError("DisconnectTip(): Failed to read block\n");
2949        return false;
2950    }
2951    // Apply the block atomically to the chain state.
2952    const auto time_start{SteadyClock::now()};
2953    {
2954        CCoinsViewCache view(&CoinsTip());
2955        assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
2956        if (DisconnectBlock(block, pindexDelete, view) != DISCONNECT_OK) {
2957            LogError("DisconnectTip(): DisconnectBlock %s failed\n", pindexDelete->GetBlockHash().ToString());
2958            return false;
2959        }
2960        view.Flush(/*reallocate_cache=*/false); // local CCoinsViewCache goes out of scope
2961    }
2962    LogDebug(BCLog::BENCH, "- Disconnect block: %.2fms\n",
2963             Ticks<MillisecondsDouble>(SteadyClock::now() - time_start));
2964
2965    {
2966        // Prune locks that began at or after the tip should be moved backward so they get a chance to reorg
2967        const int max_height_first{pindexDelete->nHeight - 1};
2968        for (auto& prune_lock : m_blockman.m_prune_locks) {
2969            if (prune_lock.second.height_first <= max_height_first) continue;
2970
2971            prune_lock.second.height_first = max_height_first;
2972            LogDebug(BCLog::PRUNE, "%s prune lock moved back to %d\n", prune_lock.first, max_height_first);
2973        }
2974    }
2975
2976    // Write the chain state to disk, if necessary.
2977    if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
2978        return false;
2979    }
2980
2981    if (disconnectpool && m_mempool) {
2982        // Save transactions to re-add to mempool at end of reorg. If any entries are evicted for
2983        // exceeding memory limits, remove them and their descendants from the mempool.
2984        for (auto&& evicted_tx : disconnectpool->AddTransactionsFromBlock(block.vtx)) {
2985            m_mempool->removeRecursive(*evicted_tx, MemPoolRemovalReason::REORG);
2986        }
2987    }
2988
2989    m_chain.SetTip(*pindexDelete->pprev);
2990    m_chainman.UpdateIBDStatus();
2991
2992    UpdateTip(pindexDelete->pprev);
2993    // Let wallets know transactions went from 1-confirmed to
2994    // 0-confirmed or conflicted:
2995    if (m_chainman.m_options.signals) {
2996        m_chainman.m_options.signals->BlockDisconnected(std::move(pblock), pindexDelete);
2997    }
2998    return true;
2999}
3000